//
//  EepromController.m
//  jacket_test_ios
//
//  Created by ドラッサル 亜嵐 on 2017/07/24.
//  Copyright © 2017年 ドラッサル 亜嵐. All rights reserved.
//

#import "EepromController.h"
#import "EepromTemplateController.h"
#import "DBManager.h"

@interface EepromController ()

@end

@implementation EepromController

- (void)viewDidLoad {
    [super viewDidLoad];

    //The setup code (in viewDidLoad in your view controller)
    UITapGestureRecognizer *singleFingerTap =
    [[UITapGestureRecognizer alloc] initWithTarget:self
                                            action:@selector(handleSingleTap:)];
    [self.view addGestureRecognizer:singleFingerTap];

    // Do any additional setup after loading the view from its nib.
    
    txtId.text = @"";
    txtModel.text = @"";
    txtType.text = @"";
    txtOs.text = @"";
    txtPin.text = @"";
    
    bleCommandState = EEPROM__EEPROM_READ_ID;
    [self bleCommandTask];
}

- (void)viewWillAppear:(BOOL)animated {
    [self registerForKeyboardNotifications];
    self.lastProtocolDelegate = self.protocol.delegate;
    self.protocol.delegate = self;
}

- (void)viewWillDisappear:(BOOL)animated {
    [self unregisterFromKeyboardNotifications];
    self.protocol.delegate = self.lastProtocolDelegate;
}

- (void)showAlert:(NSString*)title message:(NSString*)message{
    UIAlertView *alert = [[UIAlertView alloc] initWithTitle:title
                                                    message:message
                                                   delegate:self
                                          cancelButtonTitle:@"OK"
                                          otherButtonTitles:nil];
    [alert show];
}

// Call this method somewhere in your view controller setup code.
- (void)registerForKeyboardNotifications
{
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(keyboardWasShown:)
                                                 name:UIKeyboardDidShowNotification object:nil];
    
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(keyboardWillBeHidden:)
                                                 name:UIKeyboardWillHideNotification object:nil];
    
}

- (void)unregisterFromKeyboardNotifications
{
    /*
     [[NSNotificationCenter defaultCenter] addObserver:self
     selector:@selector(keyboardWasShown:)
     name:UIKeyboardDidShowNotification object:nil];
     
     [[NSNotificationCenter defaultCenter] addObserver:self
     selector:@selector(keyboardWillBeHidden:)
     name:UIKeyboardWillHideNotification object:nil];
     */
    
}

// Called when the UIKeyboardWillHideNotification is sent
- (void)keyboardWillBeHidden:(NSNotification*)aNotification
{
    UIEdgeInsets contentInsets = UIEdgeInsetsZero;
    scrollView.contentInset = contentInsets;
    scrollView.scrollIndicatorInsets = contentInsets;
}

- (void)textFieldDidBeginEditing:(UITextField *)textField
{
    activeField = textField;
}

- (void)textFieldDidEndEditing:(UITextField *)textField
{
    activeField = nil;
}

// Called when the UIKeyboardDidShowNotification is sent.
- (void)keyboardWasShown:(NSNotification*)aNotification
{
    NSDictionary* info = [aNotification userInfo];
    CGSize kbSize = [[info objectForKey:UIKeyboardFrameBeginUserInfoKey] CGRectValue].size;
    
    UIEdgeInsets contentInsets = UIEdgeInsetsMake(0.0, 0.0, kbSize.height, 0.0);
    scrollView.contentInset = contentInsets;
    scrollView.scrollIndicatorInsets = contentInsets;
    
    // If active text field is hidden by keyboard, scroll it so it's visible
    // Your app might not need or want this behavior.
    CGRect aRect = self.view.frame;
    aRect.size.height -= kbSize.height;
    if (!CGRectContainsPoint(aRect, activeField.frame.origin) ) {
        [scrollView scrollRectToVisible:activeField.frame animated:YES];
    }
}
/*
 There are other ways you can scroll the edited area in a scroll view above an obscuring keyboard. Instead of altering the bottom content inset of the scroll view, you can extend the height of the content view by the height of the keyboard and then scroll the edited text object into view. Although the UIScrollView class has a contentSize property that you can set for this purpose, you can also adjust the frame of the content view, as shown in Listing 4-3. This code also uses the setContentOffset:animated: method to scroll the edited field into view, in this case scrolling it just above the top of the keyboard.
 */
/*
- (void)keyboardWasShown:(NSNotification*)aNotification {
    NSDictionary* info = [aNotification userInfo];
    CGSize kbSize = [[info objectForKey:UIKeyboardFrameBeginUserInfoKey] CGRectValue].size;
    CGRect bkgndRect = activeField.superview.frame;
    bkgndRect.size.height += kbSize.height;
    [activeField.superview setFrame:bkgndRect];
    [scrollView setContentOffset:CGPointMake(0.0, activeField.frame.origin.y-kbSize.height) animated:YES];
}
*/
//The event handling method
- (void)handleSingleTap:(UITapGestureRecognizer *)recognizer
{
    //CGPoint location = [recognizer locationInView:[recognizer.view superview]];
    
    //Do stuff here...
    [self.view endEditing:YES];
}

- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

- (IBAction)cancelButtonClicked:(id)sender {
    [self dismissViewControllerAnimated:YES completion:Nil];
}

- (IBAction)saveButtonClicked:(id)sender {
    bleCommandState = EEPROM__EEPROM_WP_OFF;
    [self bleCommandTask];
}

- (IBAction)resetButtonClicked:(id)sender {
    txtId.text = @"";
    txtModel.text = @"";
    txtType.text = @"";
    txtOs.text = @"";
    
    bleCommandState = EEPROM__EEPROM_READ_ID;
    [self bleCommandTask];
}

- (IBAction)templateLoadButtonClicked:(id)sender {
    EepromTemplateController *viewObj=[[EepromTemplateController alloc] initWithNibName:@"EepromTemplateController" bundle:nil];
    viewObj.delegate = self;
    [self presentViewController:viewObj animated:YES completion: nil];
}

- (IBAction)templateSaveButtonClicked:(id)sender {
    UIAlertController *alert = [UIAlertController alertControllerWithTitle:@"Title"
                                                                   message:nil
                                                            preferredStyle:UIAlertControllerStyleAlert];
    [alert addTextFieldWithConfigurationHandler:^(UITextField *textField) {
        // optionally configure the text field
        textField.keyboardType = UIKeyboardTypeAlphabet;
    }];
    
    UIAlertAction *cancelAction = [UIAlertAction actionWithTitle:@"キャンセル"
                                                       style:UIAlertActionStyleDefault
                                                     handler:^(UIAlertAction *action) {
                                                         UITextField *textField = [alert.textFields firstObject];
                                                         textField.placeholder = @"Enter Input";
                                                     }];
    [alert addAction:cancelAction];

    UIAlertAction *okAction = [UIAlertAction actionWithTitle:@"保存"
                                                       style:UIAlertActionStyleDefault
                                                     handler:^(UIAlertAction *action) {
                                                         UITextField *textField = [alert.textFields firstObject];
                                                         textField.placeholder = @"Enter Input";
                                                         [self clickedSaveNameInput:textField.text];
                                                     }];
    [alert addAction:okAction];
    [self presentViewController:alert animated:YES completion:nil];
}

- (void)clickedSaveNameInput:(NSString *)textFieldText {
    NSLog(@"clickedSaveNameInput:'%@'",textFieldText);
    
    NSString *dataIdText = txtId.text;
    NSString *dataModelText = txtModel.text;
    NSString *dataTypeText = txtType.text;
    NSString *dataOsText = txtOs.text;
    NSString *dataPinText = txtPin.text;
    
    [[DBManager sharedInstance] saveEepromTemplateData:nil
                                            recordName:textFieldText
                                                dataId:dataIdText
                                           deviceModel:dataModelText
                                              dataType:dataTypeText
                                                dataOs:dataOsText
                                               dataPin:dataPinText];
}

- (void)didChoose:(NSString *)recordId
       recordName:(NSString *)recordName
           dataId:(NSString *)dataId
        dataModel:(NSString *)dataModel
         dataType:(NSString *)dataType
           dataOs:(NSString *)dataOs
          dataPin:(NSString *)dataPin {
    txtId.text = dataId;
    txtModel.text = dataModel;
    txtType.text = dataType;
    txtOs.text = dataOs;
    txtPin.text = dataPin;
}

- (BOOL)bleCommandTask {
    switch(bleCommandState) {
        case EEPROM__EEPROM_WP_OFF:
            [[self protocol]putData:@"eepromWriteProtect" data:@"0"];
            break;
        case EEPROM__EEPROM_WP_OFF_DONE:
            bleCommandState = EEPROM__EEPROM_WRITE_ID;
            [self bleCommandTask];
            break;
        case EEPROM__EEPROM_WP_ON:
            [[self protocol]putData:@"eepromWriteProtect" data:@"1"];
            break;
        case EEPROM__EEPROM_WP_ON_DONE:
            bleCommandState = EEPROM__DONE;
            [self bleCommandTask];
            break;
        case EEPROM__EEPROM_READ_ID:
            [[self protocol]putData:@"readDeviceId" data:nil];
            break;
        case EEPROM__EEPROM_READ_MODEL:
            [[self protocol]putData:@"readDeviceModel" data:nil];
            break;
        case EEPROM__EEPROM_READ_TYPE:
            [[self protocol]putData:@"readDeviceType" data:nil];
            break;
        case EEPROM__EEPROM_READ_OS:
            [[self protocol]putData:@"readDeviceOs" data:nil];
            break;
        case EEPROM__EEPROM_READ_PIN:
            [[self protocol]putData:@"readDevicePin" data:nil];
            break;
        case EEPROM__EEPROM_READ_ID_DONE:
            bleCommandState = EEPROM__EEPROM_READ_MODEL;
            [self bleCommandTask];
            break;
        case EEPROM__EEPROM_READ_MODEL_DONE:
            bleCommandState = EEPROM__EEPROM_READ_TYPE;
            [self bleCommandTask];
            break;
        case EEPROM__EEPROM_READ_TYPE_DONE:
            bleCommandState = EEPROM__EEPROM_READ_OS;
            [self bleCommandTask];
            break;
        case EEPROM__EEPROM_READ_OS_DONE:
            bleCommandState = EEPROM__EEPROM_READ_PIN;
            [self bleCommandTask];
            break;
        case EEPROM__EEPROM_READ_PIN_DONE:
            bleCommandState = EEPROM__DONE;
            [self bleCommandTask];
            break;
        case EEPROM__EEPROM_WRITE_ID:
            if(![strId isEqualToString:txtId.text]) {
                [[self protocol]putData:@"writeDeviceId" data:txtId.text];
            } else {
                bleCommandState = EEPROM__EEPROM_WRITE_ID_DONE;
                [self bleCommandTask];
            }
            break;
        case EEPROM__EEPROM_WRITE_MODEL:
            if(![strModel isEqualToString:txtModel.text]) {
                [[self protocol]putData:@"writeDeviceModel" data:txtModel.text];
            } else {
                bleCommandState = EEPROM__EEPROM_WRITE_MODEL_DONE;
                [self bleCommandTask];
            }
            break;
        case EEPROM__EEPROM_WRITE_TYPE:
            if(![strType isEqualToString:txtType.text]) {
                [[self protocol]putData:@"writeDeviceType" data:txtType.text];
            } else {
                bleCommandState = EEPROM__EEPROM_WRITE_TYPE_DONE;
                [self bleCommandTask];
            }
            break;
        case EEPROM__EEPROM_WRITE_OS:
            if(![strOs isEqualToString:txtOs.text]) {
                [[self protocol]putData:@"writeDeviceOs" data:txtOs.text];
            } else {
                bleCommandState = EEPROM__EEPROM_WRITE_OS_DONE;
                [self bleCommandTask];
            }
            break;
        case EEPROM__EEPROM_WRITE_PIN:
            if(![strOs isEqualToString:txtPin.text]) {
                [[self protocol]putData:@"writeDevicePin" data:txtPin.text];
            } else {
                bleCommandState = EEPROM__EEPROM_WRITE_PIN_DONE;
                [self bleCommandTask];
            }
            break;
        case EEPROM__EEPROM_WRITE_ID_DONE:
            bleCommandState = EEPROM__EEPROM_WRITE_MODEL;
            [self bleCommandTask];
            break;
        case EEPROM__EEPROM_WRITE_MODEL_DONE:
            bleCommandState = EEPROM__EEPROM_WRITE_TYPE;
            [self bleCommandTask];
            break;
        case EEPROM__EEPROM_WRITE_TYPE_DONE:
            bleCommandState = EEPROM__EEPROM_WRITE_OS;
            [self bleCommandTask];
            break;
        case EEPROM__EEPROM_WRITE_OS_DONE:
            bleCommandState = EEPROM__EEPROM_WRITE_PIN;
            [self bleCommandTask];
            break;
        case EEPROM__EEPROM_WRITE_PIN_DONE:
            bleCommandState = EEPROM__EEPROM_WP_ON;
            [self showAlert:@"EEPROM書き込み" message:@"EEPROMに保存しました。"];
            [self bleCommandTask];
            break;
        case EEPROM__DONE:
        {
            NSLog(@"Ble command set done!");
            break;
        }
    }
    return false;
}

- (void)protocolDidGetData:(NSString *)dataType data:(NSString *)dataData {
    if([dataType isEqualToString:@"eepromWriteProtect"]) {
        if([dataData isEqualToString:@"0"]) {
            NSLog(@"eepromWriteProtect 0");
            bleCommandState = EEPROM__EEPROM_WP_OFF_DONE;
            [self bleCommandTask];
        } else if([dataData isEqualToString:@"1"]) {
            NSLog(@"eepromWriteProtect 1");
            bleCommandState = EEPROM__EEPROM_WP_ON_DONE;
            [self bleCommandTask];
        }
    } else if([dataType isEqualToString:@"readDeviceId"]) {
        NSLog(@"infoDeviceId");
        strId = dataData;
        txtId.text = dataData;
        bleCommandState = EEPROM__EEPROM_READ_ID_DONE;
        [self bleCommandTask];
    } else if([dataType isEqualToString:@"readDeviceModel"]) {
        NSLog(@"infoDeviceModel");
        strModel = dataData;
        txtModel.text = dataData;
        bleCommandState = EEPROM__EEPROM_READ_MODEL_DONE;
        [self bleCommandTask];
    } else if([dataType isEqualToString:@"readDeviceType"]) {
        NSLog(@"infoDeviceType");
        strType = dataData;
        txtType.text = dataData;
        bleCommandState = EEPROM__EEPROM_READ_TYPE_DONE;
        [self bleCommandTask];
    } else if([dataType isEqualToString:@"readDeviceOs"]) {
        NSLog(@"infoDeviceOs");
        strOs = dataData;
        txtOs.text = dataData;
        bleCommandState = EEPROM__EEPROM_READ_OS_DONE;
        [self bleCommandTask];
    } else if([dataType isEqualToString:@"readDevicePin"]) {
        NSLog(@"infoDevicePin");
        strPin = dataData;
        txtPin.text = dataData;
        bleCommandState = EEPROM__EEPROM_READ_PIN_DONE;
        [self bleCommandTask];
    } else if([dataType isEqualToString:@"writeDeviceId"]) {
        NSLog(@"writeDeviceId");
        bleCommandState = EEPROM__EEPROM_WRITE_ID_DONE;
        [self bleCommandTask];
    } else if([dataType isEqualToString:@"writeDeviceModel"]) {
        NSLog(@"writeDeviceModel");
        bleCommandState = EEPROM__EEPROM_WRITE_MODEL_DONE;
        [self bleCommandTask];
    } else if([dataType isEqualToString:@"writeDeviceType"]) {
        NSLog(@"writeDeviceType");
        bleCommandState = EEPROM__EEPROM_WRITE_TYPE_DONE;
        [self bleCommandTask];
    } else if([dataType isEqualToString:@"writeDeviceOs"]) {
        NSLog(@"writeDeviceOs");
        bleCommandState = EEPROM__EEPROM_WRITE_OS_DONE;
        [self bleCommandTask];
    } else if([dataType isEqualToString:@"writeDevicePin"]) {
        NSLog(@"writeDevicePin");
        bleCommandState = EEPROM__EEPROM_WRITE_PIN_DONE;
        [self bleCommandTask];
    }
}

/*
#pragma mark - Navigation

// In a storyboard-based application, you will often want to do a little preparation before navigation
- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender {
    // Get the new view controller using [segue destinationViewController].
    // Pass the selected object to the new view controller.
}
*/

@end