//
//  FirmwareWriteController.m
//  jacket_ios
//
//  Created by ドラッサル 亜嵐 on 2017/06/06.
//  Copyright © 2017年 ドラッサル 亜嵐. All rights reserved.
//

#import "FirmwareWriteController.h"
#import "FirmwareWriteControllerTableViewCell.h"
#import "Operation.h"
#import "DBManager.h"
#import "NSData+NSString.h"

@interface FirmwareWriteController ()

@end

@implementation FirmwareWriteController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view from its nib.
    
    selectionEnabled = 1;
    
    arrResult = [[NSMutableArray alloc] init];
    
    UINib *nib = [UINib nibWithNibName:@"FirmwareWriteControllerTableViewCell" bundle:nil];
    [tblFirmware registerNib:nib forCellReuseIdentifier:@"mycell"];
    tblFirmware.delegate = self;
    tblFirmware.dataSource = self;
    
    [arrResult removeAllObjects];
    
    NSArray *result = [[DBManager sharedInstance] getFirmwareDataList];
    
    for(id key in result) {
        NSString *valueId = [key objectAtIndex:0];
        NSString *valueUuid = [key objectAtIndex:1];
        NSString *valueDeviceType = [key objectAtIndex:2];
        NSString *valueDeviceModel = [key objectAtIndex:3];
        NSString *valueVersion = [key objectAtIndex:4];
        NSString *valueVersionStamp = [key objectAtIndex:5];
        NSString *valueFile = [key objectAtIndex:6];
        
        NSMutableDictionary *newDict = [NSMutableDictionary dictionary];
        [newDict setObject:valueId forKey:@"id"];
        [newDict setObject:valueUuid forKey:@"uuid"];
        [newDict setObject:valueDeviceType forKey:@"deviceType"];
        [newDict setObject:valueDeviceModel forKey:@"deviceModel"];
        [newDict setObject:valueVersion forKey:@"version"];
        [newDict setObject:valueVersionStamp forKey:@"versionStamp"];
        [newDict setObject:valueFile forKey:@"file"];
        
        [arrResult addObject:newDict];
    }
    [tblFirmware reloadData];
}

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

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

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

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

- (NSIndexPath *)tableView:(UITableView *)tableView willSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    if(selectionEnabled == 1) {
        return indexPath;
    } else {
        return nil;
    }
}

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    NSInteger row = [indexPath row];
    NSDictionary *dataRecord = [arrResult objectAtIndex:row];
    
    NSString *filename = [dataRecord valueForKey:@"uuid"];
    
    //selectionEnabled = 0;
    
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,
                                                         NSUserDomainMask, YES);
    NSString *documentsDirectory = [paths objectAtIndex:0];
    NSString* path = [documentsDirectory stringByAppendingPathComponent:
                      [NSString stringWithFormat: @"/save/%@",filename]];
    firmwareFileStreamSize = [[[NSFileManager defaultManager] attributesOfItemAtPath:path error:nil] fileSize];
    firmwareFileStream = [[NSInputStream alloc] initWithFileAtPath:path];
    [firmwareFileStream open];
    
    startTime = CACurrentMediaTime();
    firmwareUpdateState = ERASE_PAGE_1;
    //firmwareUpdateState = UPLOAD_DONE;
    firmwareFileStreamPointer = 0;
    firmwareWriteBufferRetry = 0;
    
    [self firmwareWriteTask];
    
    NSLog(@"bin file readout complete");
}

- (NSArray *)tableView:(UITableView *)tableView editActionsForRowAtIndexPath:(NSIndexPath *)indexPath
{
    return @[
             [UITableViewRowAction rowActionWithStyle:UITableViewRowActionStyleDestructive
                                                title:@"削除"
                                              handler:^(UITableViewRowAction *action, NSIndexPath *indexPath) {
                                                  // own delete action
                                                  
                                                  
                                                  // Distructive button tapped.
                                                  NSLog(@"削除の確認");
                                                  
                                                  NSDictionary * selectedData = [arrResult objectAtIndex:indexPath.row];
                                                  NSString *firmwareTitle = [selectedData valueForKey:@"file"];
                                                  
                                                  UIAlertController *actionSheetConfirm = [UIAlertController alertControllerWithTitle:@"削除の確認" message:[NSString stringWithFormat:@"「%@」を削除します。よろしいですか？",firmwareTitle] preferredStyle:UIAlertControllerStyleAlert];
                                                  
                                                  [actionSheetConfirm addAction:[UIAlertAction actionWithTitle:@"削除" style:UIAlertActionStyleDestructive handler:^(UIAlertAction *actionConfirm) {
                                                      
                                                      
                                                      // Get the record ID of the selected name and set it to the recordIDToEdit property.
                                                      NSDictionary * selectedData = [arrResult objectAtIndex:indexPath.row];
                                                      
                                                      NSString *recordId = [selectedData valueForKey:@"id"];
                                                      NSLog(@"recordId = %@",recordId);
                                                      //NSString *firmwareFilename = [selectedData valueForKey:@"file"];
                                                      NSString *firmwareFilename = [selectedData valueForKey:@"uuid"];
                                                      NSLog(@"firmwareFilename = %@",firmwareFilename);
                                                      
                                                      
                                                      NSString *docPath = [NSSearchPathForDirectoriesInDomains
                                                                           (NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0];
                                                      NSString *docPathFull = [docPath stringByAppendingPathComponent:[NSString stringWithFormat:@"/save/%@",firmwareFilename]];
                                                      //NSURL *docPathFullUrl = [NSURL URLWithString:docPathFull];
                                                      
                                                      
                                                      NSFileManager *fileManager = [NSFileManager defaultManager];
                                                      NSError *error;
                                                      BOOL success = [fileManager removeItemAtPath:docPathFull error:&error];
                                                      if(success) {
                                                          NSLog(@"削除した");
                                                          [[DBManager sharedInstance] deleteFirmwareData:recordId];
                                                          //[self populateDetail];
                                                          //[self.tblResult reloadData];
                                                          [arrResult removeObjectAtIndex:indexPath.row];
                                                          [tblFirmware deleteRowsAtIndexPaths:@[indexPath] withRowAnimation:UITableViewRowAnimationAutomatic];
                                                      } else {
                                                          NSLog(@"削除を失敗した");
                                                          [[DBManager sharedInstance] deleteFirmwareData:recordId];
                                                          //[self populateDetail];
                                                          //[self.tblResult reloadData];
                                                          [arrResult removeObjectAtIndex:indexPath.row];
                                                          [tblFirmware deleteRowsAtIndexPaths:@[indexPath] withRowAnimation:UITableViewRowAnimationAutomatic];
                                                      }
                                                  }]];
                                                  [actionSheetConfirm addAction:[UIAlertAction actionWithTitle:@"キャンセル" style:UIAlertActionStyleDefault handler:^(UIAlertAction *actionConfirm) {
                                                      // Distructive button tapped.
                                                      NSLog(@"キャンセルの確認");
                                                  }]];
                                                  [self presentViewController:actionSheetConfirm animated:YES completion:nil];
                                              }],
             ];
}

- (BOOL)firmwareWriteTask {
    int packetDataSize = 18;
    int readLength = 18;
    unsigned long long firmwareFlashPageSize = 0x8000;
    //unsigned long long firmwareFlashPageSize = 0x100;
    
    switch(firmwareUpdateState) {
        case ERASE_PAGE_1:
            [[self protocol]putData:@"firmwareFlashErase" data:@"1"];
            break;
        case UPLOAD_PAGE_10_ERASE_TEMP:
            [[self protocol]putData:@"firmwareBufferClear" data:nil];
            break;
        case UPLOAD_PAGE_10_BEGIN:
        case UPLOAD_PAGE_11_BEGIN:
        case UPLOAD_PAGE_12_BEGIN:
        case UPLOAD_PAGE_13_BEGIN:
            firmwareFlashPagePointer = firmwareFlashPageSize;
            switch(firmwareUpdateState) {
                case UPLOAD_PAGE_10_BEGIN:
                    firmwareUpdateState = UPLOAD_PAGE_10_CONTINUE;
                    break;
                case UPLOAD_PAGE_11_BEGIN:
                    firmwareUpdateState = UPLOAD_PAGE_11_CONTINUE;
                    break;
                case UPLOAD_PAGE_12_BEGIN:
                    firmwareUpdateState = UPLOAD_PAGE_12_CONTINUE;
                    break;
                case UPLOAD_PAGE_13_BEGIN:
                    firmwareUpdateState = UPLOAD_PAGE_13_CONTINUE;
                    break;
                default:
                    break;
            }
        case UPLOAD_PAGE_10_CONTINUE:
        case UPLOAD_PAGE_11_CONTINUE:
        case UPLOAD_PAGE_12_CONTINUE:
        case UPLOAD_PAGE_13_CONTINUE:
        {
            if([firmwareFileStream hasBytesAvailable]) {
                switch(firmwareUpdateState) {
                    case UPLOAD_PAGE_10_CONTINUE:
                        if((firmwareFileStreamPointer + readLength) > (firmwareFlashPageSize - 1)) {
                            readLength = (int)(firmwareFlashPageSize - firmwareFileStreamPointer);
                        }
                        break;
                    case UPLOAD_PAGE_11_CONTINUE:
                        if((firmwareFileStreamPointer + readLength) > (firmwareFlashPageSize * 2 - 1)) {
                            readLength = (int)(firmwareFlashPageSize * 2 - firmwareFileStreamPointer);
                        }
                        break;
                    case UPLOAD_PAGE_12_CONTINUE:
                        if((firmwareFileStreamPointer + readLength) > (firmwareFlashPageSize * 3 - 1)) {
                            readLength = (int)(firmwareFlashPageSize * 3 - firmwareFileStreamPointer);
                        }
                        break;
                    case UPLOAD_PAGE_13_CONTINUE:
                        if((firmwareFileStreamPointer + readLength) > (firmwareFlashPageSize * 4 - 1)) {
                            readLength = (int)(firmwareFlashPageSize * 4 - firmwareFileStreamPointer);
                        }
                        break;
                    default:
                        break;
                }
                unsigned char outputBuffer[20];
                unsigned char outputBufferData[20];
                for(int i = 0; i < 20; i++) {
                    outputBuffer[i] = 0;
                    outputBufferData[i] = 0;
                }
                NSInteger length = [firmwareFileStream read:outputBufferData maxLength:readLength];
                firmwareFileStreamPointer += length;
                firmwareFlashPagePointer -= length;
                
                
                int indexFrom = 0;
                int indexTo = 0;
                outputBuffer[indexTo++] = 'x';
                uint8_t outputBufferChecksum = 0x00;
                while(indexFrom < length) {
                    outputBufferChecksum ^= outputBufferData[indexFrom];
                    outputBuffer[indexTo++] = outputBufferData[indexFrom++];
                }
                while(indexTo < (packetDataSize + 1)) {
                    outputBufferChecksum ^= 0xFF;
                    outputBuffer[indexTo++] = 0xFF;
                }
                outputBuffer[indexTo++] = outputBufferChecksum;
                
                firmwareWriteBuffer = [NSData dataWithBytes:outputBuffer length:indexTo];
                
                NSUInteger firmwareWriteBufferLength = [firmwareWriteBuffer length];
                Byte *firmwareWriteBufferLengthByteData = (Byte*)malloc(firmwareWriteBufferLength);
                memcpy(firmwareWriteBufferLengthByteData, [firmwareWriteBuffer bytes], firmwareWriteBufferLength);
                NSMutableString *firmwareWriteBufferString = [NSMutableString stringWithCapacity:0];
                for(int i = 0; i < [firmwareWriteBuffer length]; i++) {
                    [firmwareWriteBufferString appendFormat:@"%02x ", firmwareWriteBufferLengthByteData[i]];
                }
                CFTimeInterval elapsedTime = CACurrentMediaTime() - startTime;
                NSLog(@"BLE   SEND(%d) %@  %llu / %llu %.2f%%  %fsec",firmwareWriteBufferRetry,firmwareWriteBufferString,firmwareFileStreamPointer,firmwareFileStreamSize,(float)firmwareFileStreamPointer / (float)firmwareFileStreamSize * 100, elapsedTime);
                lblPercentComplete.text = [NSString stringWithFormat:@"%llu / %llu %.2f%%  %.02f秒",firmwareFileStreamPointer,firmwareFileStreamSize,(float)firmwareFileStreamPointer / (float)firmwareFileStreamSize * 100, elapsedTime];
                
                [self.protocol bleWriteRaw:firmwareWriteBuffer];
            } else if (firmwareFileStreamPointer == firmwareFileStreamSize) {
                switch(firmwareUpdateState) {
                    case UPLOAD_PAGE_10_CONTINUE:
                        firmwareUpdateState = UPLOAD_PAGE_10_END;
                        break;
                    case UPLOAD_PAGE_11_CONTINUE:
                        firmwareUpdateState = UPLOAD_PAGE_11_END;
                        break;
                    case UPLOAD_PAGE_12_CONTINUE:
                        firmwareUpdateState = UPLOAD_PAGE_12_END;
                        break;
                    case UPLOAD_PAGE_13_CONTINUE:
                        firmwareUpdateState = UPLOAD_PAGE_13_END;
                        break;
                    default:
                        break;
                }
                [self firmwareWriteTask];
            } else {
                NSLog(@"Should not get here, something bad bad happened!!!");
                NSLog(@"firmwareFileStreamPointer should never be larger than firmwareFileStreamSize, ever!!!");
            }
            
            //NSData *nsData = [@"fw@" dataUsingEncoding:NSUTF8StringEncoding];
            //[self.protocol putData:@"infoDeviceId" data:nil];
            
            return true;
            break;
        }
        case UPLOAD_PAGE_10_RETRY:
        case UPLOAD_PAGE_11_RETRY:
        case UPLOAD_PAGE_12_RETRY:
        case UPLOAD_PAGE_13_RETRY:
        {
            NSUInteger firmwareWriteBufferLength = [firmwareWriteBuffer length];
            
            Byte *firmwareWriteBufferLengthByteData = (Byte*)malloc(firmwareWriteBufferLength);
            memcpy(firmwareWriteBufferLengthByteData, [firmwareWriteBuffer bytes], firmwareWriteBufferLength);
            NSMutableString *firmwareWriteBufferString = [NSMutableString stringWithCapacity:0];
            for(int i = 0; i < [firmwareWriteBuffer length]; i++) {
                [firmwareWriteBufferString appendFormat:@"%02x ", firmwareWriteBufferLengthByteData[i]];
            }
            CFTimeInterval elapsedTime = CACurrentMediaTime() - startTime;
            NSLog(@"BLE RESEND(%d) %@  %llu / %llu %.2f%%  %fsec",firmwareWriteBufferRetry,firmwareWriteBufferString,firmwareFileStreamPointer,firmwareFileStreamSize,(float)firmwareFileStreamPointer / (float)firmwareFileStreamSize * 100, elapsedTime);
            [self.protocol bleWriteRaw:firmwareWriteBuffer];
            
            //NSData *nsData = [@"fw@" dataUsingEncoding:NSUTF8StringEncoding];
            //[self.protocol putData:@"infoDeviceId" data:nil];
            
            return true;
            break;
        }
        case UPLOAD_PAGE_10_END:
            firmwareUpdateState = WRITE_PAGE_10;
            [self firmwareWriteTask];
            break;
        case WRITE_PAGE_10:
            [[self protocol]putData:@"firmwareFlashWrite" data:@"10"];
            break;
        case WRITE_PAGE_10_DONE:
            if (firmwareFileStreamPointer != firmwareFileStreamSize) {
                firmwareUpdateState = UPLOAD_PAGE_11_ERASE_TEMP;
            } else {
                firmwareUpdateState = UPLOAD_DONE;
            }
            [self firmwareWriteTask];
            break;
        case UPLOAD_PAGE_11_ERASE_TEMP:
            [[self protocol]putData:@"firmwareBufferClear" data:nil];
            break;
        case UPLOAD_PAGE_11_END:
            firmwareUpdateState = WRITE_PAGE_11;
            [self firmwareWriteTask];
            break;
        case WRITE_PAGE_11:
            [[self protocol]putData:@"firmwareFlashWrite" data:@"11"];
            break;
        case WRITE_PAGE_11_DONE:
            if (firmwareFileStreamPointer != firmwareFileStreamSize) {
                firmwareUpdateState = UPLOAD_PAGE_12_ERASE_TEMP;
            } else {
                firmwareUpdateState = UPLOAD_DONE;
            }
            [self firmwareWriteTask];
            break;
        case UPLOAD_PAGE_12_ERASE_TEMP:
            [[self protocol]putData:@"firmwareBufferClear" data:nil];
            break;
        case UPLOAD_PAGE_12_END:
            firmwareUpdateState = WRITE_PAGE_12;
            [self firmwareWriteTask];
            break;
        case WRITE_PAGE_12:
            [[self protocol]putData:@"firmwareFlashWrite" data:@"12"];
            break;
        case WRITE_PAGE_12_DONE:
            if (firmwareFileStreamPointer != firmwareFileStreamSize) {
                firmwareUpdateState = UPLOAD_PAGE_13_ERASE_TEMP;
            } else {
                firmwareUpdateState = UPLOAD_DONE;
            }
            [self firmwareWriteTask];
            break;
        case UPLOAD_PAGE_13_ERASE_TEMP:
            [[self protocol]putData:@"firmwareBufferClear" data:nil];
            break;
        case UPLOAD_PAGE_13_END:
            firmwareUpdateState = WRITE_PAGE_13;
            [self firmwareWriteTask];
            break;
        case WRITE_PAGE_13:
            [[self protocol]putData:@"firmwareFlashWrite" data:@"13"];
            break;
        case WRITE_PAGE_13_DONE:
            firmwareUpdateState = UPLOAD_DONE;
            [self firmwareWriteTask];
            break;
        case UPLOAD_DONE:
            //firmwareUpdateState = EEPROM_WP_OFF;
            //[self firmwareWriteTask];
        {
            CFTimeInterval elapsedTime = CACurrentMediaTime() - startTime;
            NSLog(@"Firmware upload done!  %fsec", elapsedTime);
            break;
        }
        case EEPROM_WP_OFF:
            [[self protocol]putData:@"eepromWriteProtect" data:@"0"];
            break;
        case EEPROM_WP_OFF_DONE:
            firmwareUpdateState = FIRMWARE_IMAGE_SELECT_1;
            [self firmwareWriteTask];
            break;
        case FIRMWARE_IMAGE_SELECT_1:
            [[self protocol]putData:@"firmwareImageSelect" data:@"1"];
            break;
        case FIRMWARE_IMAGE_SELECT_1_DONE:
            firmwareUpdateState = RESET;
            [self firmwareWriteTask];
            break;
        case RESET:
            [[self protocol]putData:@"systemReset" data:nil];
            break;
        case RESET_DONE:
        {
            CFTimeInterval elapsedTime = CACurrentMediaTime() - startTime;
            NSLog(@"Firmware upload done!  %fsec", elapsedTime);
            break;
        }
    }
    return false;
}

- (void)protocolDidGetData:(NSString *)dataType data:(NSString *)dataData {
    if([dataType isEqualToString:@"firmwareFlashErase"]) {
        if([dataData isEqualToString: @"1"]) {
            if(firmwareUpdateState == ERASE_PAGE_1) {
                firmwareUpdateState = UPLOAD_PAGE_10_ERASE_TEMP;
                [self firmwareWriteTask];
            }
        }
    } else if([dataType isEqualToString:@"firmwareBufferClear"]) {
        switch(firmwareUpdateState) {
            case UPLOAD_PAGE_10_ERASE_TEMP:
                firmwareUpdateState = UPLOAD_PAGE_10_BEGIN;
                break;
            case UPLOAD_PAGE_11_ERASE_TEMP:
                firmwareUpdateState = UPLOAD_PAGE_11_BEGIN;
                break;
            case UPLOAD_PAGE_12_ERASE_TEMP:
                firmwareUpdateState = UPLOAD_PAGE_12_BEGIN;
                break;
            case UPLOAD_PAGE_13_ERASE_TEMP:
                firmwareUpdateState = UPLOAD_PAGE_13_BEGIN;
                break;
            default:
                break;
        }
        [self firmwareWriteTask];
    } else if([dataType isEqualToString:@"firmwareBufferWrite"]) {
        if([dataData isEqualToString: @"OK"]) {
            if(firmwareWriteBufferRetry != 0) {
                firmwareWriteBufferRetry = 0;
                switch(firmwareUpdateState) {
                    case UPLOAD_PAGE_10_RETRY:
                        firmwareUpdateState = UPLOAD_PAGE_10_CONTINUE;
                        break;
                    case UPLOAD_PAGE_11_RETRY:
                        firmwareUpdateState = UPLOAD_PAGE_11_CONTINUE;
                        break;
                    case UPLOAD_PAGE_12_RETRY:
                        firmwareUpdateState = UPLOAD_PAGE_12_CONTINUE;
                        break;
                    case UPLOAD_PAGE_13_RETRY:
                        firmwareUpdateState = UPLOAD_PAGE_13_CONTINUE;
                        break;
                    default:
                        break;
                }
            }
            if(firmwareFlashPagePointer == 0) {
                switch(firmwareUpdateState) {
                    case UPLOAD_PAGE_10_CONTINUE:
                        firmwareUpdateState = UPLOAD_PAGE_10_END;
                        break;
                    case UPLOAD_PAGE_11_CONTINUE:
                        firmwareUpdateState = UPLOAD_PAGE_11_END;
                        break;
                    case UPLOAD_PAGE_12_CONTINUE:
                        firmwareUpdateState = UPLOAD_PAGE_12_END;
                        break;
                    case UPLOAD_PAGE_13_CONTINUE:
                        firmwareUpdateState = UPLOAD_PAGE_13_END;
                        break;
                    default:
                        break;
                }
            }
            [self firmwareWriteTask];
        } else {
            if(firmwareWriteBufferRetry < 10) {
                firmwareWriteBufferRetry++;
                switch(firmwareUpdateState) {
                    case UPLOAD_PAGE_10_CONTINUE:
                        firmwareUpdateState = UPLOAD_PAGE_10_RETRY;
                        break;
                    case UPLOAD_PAGE_11_CONTINUE:
                        firmwareUpdateState = UPLOAD_PAGE_11_RETRY;
                        break;
                    case UPLOAD_PAGE_12_CONTINUE:
                        firmwareUpdateState = UPLOAD_PAGE_12_RETRY;
                        break;
                    case UPLOAD_PAGE_13_CONTINUE:
                        firmwareUpdateState = UPLOAD_PAGE_13_RETRY;
                        break;
                    default:
                        break;
                }
                [self firmwareWriteTask];
            } else {
                NSLog(@"BLE RESEND(%d) RETRY EXCEED, GIVE UP",firmwareWriteBufferRetry);
            }
        }
    } else if([dataType isEqualToString:@"firmwareFlashWrite"]) {
        if([dataData isEqualToString:@"10"]) {
            NSLog(@"firmwareFlashWrite 10");
            firmwareUpdateState = WRITE_PAGE_10_DONE;
            [self firmwareWriteTask];
        } else if([dataData isEqualToString:@"11"]) {
            NSLog(@"firmwareFlashWrite 11");
            firmwareUpdateState = WRITE_PAGE_11_DONE;
            [self firmwareWriteTask];
        } else if([dataData isEqualToString:@"12"]) {
            NSLog(@"firmwareFlashWrite 12");
            firmwareUpdateState = WRITE_PAGE_12_DONE;
            [self firmwareWriteTask];
        } else if([dataData isEqualToString:@"13"]) {
            NSLog(@"firmwareFlashWrite 13");
            firmwareUpdateState = WRITE_PAGE_13_DONE;
            [self firmwareWriteTask];
        }
    } else if([dataType isEqualToString:@"firmwareImageSelect"]) {
        if([dataData isEqualToString:@"1"]) {
            NSLog(@"firmwareImageSelect 1");
            firmwareUpdateState = FIRMWARE_IMAGE_SELECT_1_DONE;
            [self firmwareWriteTask];
        }
    } else if([dataType isEqualToString:@"eepromWriteProtect"]) {
        if([dataData isEqualToString:@"0"]) {
            NSLog(@"firmwareImageSelect 0");
            firmwareUpdateState = EEPROM_WP_OFF_DONE;
            [self firmwareWriteTask];
        }
    } else if([dataType isEqualToString:@"systemReset"]) {
        NSLog(@"firmwareImageSelect 1");
        firmwareUpdateState = RESET_DONE;
        [self firmwareWriteTask];
    }
}

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
    // Return the number of sections.
    return 1;
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
    // Return the number of rows in the section.
    return [arrResult count];
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSString *cellIdentifier = @"mycell";
    FirmwareWriteControllerTableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:cellIdentifier forIndexPath:indexPath];
    
    NSInteger row = [indexPath row];
    NSDictionary *dataRecord = [arrResult objectAtIndex:row];
    
    // Configure the cell...
    UIFont *newFont = [UIFont fontWithName:@"Arial" size:11.0];
    cell.lblTitle.font = newFont;
    cell.lblTitle.text = [dataRecord valueForKey:@"file"];
    
    newFont = [UIFont fontWithName:@"Arial" size:11.0];
    cell.lblSubtitle.font = newFont;
    cell.lblSubtitle.text = [dataRecord valueForKey:@"uuid"];
    
    return cell;
}

/*
 #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