Z5RemoteDataController.m

Go to the documentation of this file.

//
//  Z5RemoteDataController.m
//  Z7Ma2AminoLight
//
//  Created by Don Zeek on 11/12/14.
//  Copyright (c) 2014 net.dzeek.y2014.ios.aminoview. All rights reserved.
//

#import "Z5RemoteDataController.h"

// #import "GTLUtilities.h"
// #import "GTMHTTPFetcherLogging.h"

// #import "Z5GoogleProvided.h"
#import "Z5DataController.h"
#import "NSString+MD5.h"
#import "NSData+MD5.h"
#import "Z5RemoteDataFetchProtocol.h"
#import "MenuItem+CoreDataProperties.h"

#pragma mark - 
#pragma mark Proxy delegate

/*
@interface Z5RemoteDataDriveDelegate : NSObject <Z5RemoteDataFetchProtocol>
@property (nonatomic, strong) NSMutableArray *who;
@property (nonatomic, strong) Z5RemoteDataController *remoteDataController;
@end

@implementation Z5RemoteDataDriveDelegate
{
    BOOL    kHomeAsk;
    BOOL    kHomeError;
    GTLDriveFile *kHomeResult;
    BOOL    kFetchAsk;
    BOOL    kFetchError;
    NSArray *kFetchResults;
    BOOL    kPublishAsk;
    BOOL    kPublishError;
    id<Z5RemoteDataFetchProtocol> kController;
}
- (instancetype)initWith: (id<Z5RemoteDataFetchProtocol>)controller
{
    self = [super init];
    if (self) {
        // NSLog(@"Z5RemoteDataDriveDelegate.init");
        kHomeAsk = NO;
        kHomeError = NO;
        kHomeResult = nil;
        kFetchAsk = NO;
        kFetchError = NO;
        kFetchResults = nil;
        kPublishAsk = NO;
        kPublishError = NO;
        kController = controller;
    }
    return self;

}
- (void) showHomeAsk
{
    kHomeAsk = YES;
    [kController showHomeAsk];
}
- (void) showHomeError:(NSError *) error
{
    // NSLog(@"RemoteData/Z5RemoteDataDriveDelegate.showHomeError: %@", [error localizedDescription]);
    kHomeError = YES;
    [kController showHomeError:error];
}
- (BOOL) tellHomeError
{
    [kController tellHomeError];
    return kHomeError;
}
- (void) showHomeResult:(GTLDriveFile *)drivefile
{
    kHomeResult = drivefile;
    [kController showHomeResult:drivefile];
    [[self remoteDataController] homeResultAvailable];
}
- (GTLDriveFile *) tellHomeResult
{
    return kHomeResult;
}

- (void) showFetchAsk
{
    kFetchAsk = YES;
    [kController showFetchAsk];
}
- (void) showFetchError
{
    kFetchError = YES;
    [kController showFetchError];
}
- (void) showFetchResult: (NSArray *)filen
{
    kFetchResults = filen;  // may need to create my own copy
    [kController showFetchResult:filen];
}
- (void) showPublishAsk
{
    kPublishAsk = YES;
    [kController showPublishAsk];
}
- (void) showPublishError
{
    kPublishError = YES;
    [kController showPublishError];
}
- (void) showPublishResult
{
    [kController showPublishResult];
}
- (void) showDataFetch:(NSData *)data
{
    [kController showDataFetch:data];
}
- (void) showDataFetch:(NSData *)data fromFile: (NSString *)title withGoogleId: (NSString *)fileId
{
    [kController showDataFetch:data fromFile:title withGoogleId:fileId];
}
- (void) showGoogleFileTitle: (NSString *) title andId: (NSString *) fileId
{
    [kController showGoogleFileTitle:title andId:fileId];
}
- (void) showInsertResult: (GTLDriveFile *)newf
{
    [kController showInsertResult: newf];
}
- (void) updateUI
{
    // NSLog(@"RemoteData/Z5RemoteDataDriveDelegate.updateUI");
    [kController updateUI];
}
@end
*/

#pragma mark -
#pragma mark Remote Data Control

@interface Z5RemoteDataController ()

@property (nonatomic, readonly) UINavigationController *kNavigator;

@end

@implementation Z5RemoteDataController


NSString *const kKeychainItemName = @"Todays-Menu:Google";

- (instancetype)init
{
    self = [super init];
    if (self) {
        _loginController = [[Z5GoogleLoginController alloc] init];
        _emailController = [[Z5GmailDataController alloc] init];
        _driveController = [[Z5GoogleDriveController alloc] init];
        _calendarController = [[Z5GoogleCalendarDataController alloc] init];
        _sessionController = [[Z5URLSessionController alloc] init];
        
        [_loginController configureGoogleSignIn];
        GIDSignIn* signIn = [GIDSignIn sharedInstance];
        if (nil != [_loginController signedInUsername]) {
            [signIn signInSilently];
        }
     }
    return self;
}
#pragma mark -

- (void)loginDriveWithNavigation: (UINavigationController *)nav andHandler: (void (^)(void)) finishHandler
{
    NSLog(@"MemoteData.logWithNavigation:withHandler");
    assert(nil);        // old version, not exercised
    _kNavigator = nav;
    if (nav) {
        [self signInNowWithHandler:finishHandler];
    } else {
        NSLog(@"RemoteData.logWithNavigation:withHandler: ERROR");
    }
}
- (void)refreshAuthentication {
    
    // TODO: Get the saved authentication, if any, from the keychain.
    /*
    GTMOAuth2Authentication *auth;
    auth = [GTMOAuth2ViewControllerTouch authForGoogleFromKeychainForName:kKeychainItemName
                                                                 clientID:clientID
                                                             clientSecret:clientSecret];
    
    // Retain the authentication object, which holds the auth tokens
    //
    // We can determine later if the auth object contains an access token
    // by calling its -canAuthorize method
    [self setAuthentication:auth];
     */
}

- (BOOL)isSignedIn {
    NSString *name = [_loginController signedInUsername];
    return (name != nil);
}


- (void)signInNowWithHandler: (void (^)(void)) finishHandler
{
    if (![self isSignedIn]) {
        // Sign in
        [self runSigninThenHandler:finishHandler];
    } else {
        // Sign out
    
//        GTLServiceDrive *service = self.driveService;
//
//        [GTMOAuth2ViewControllerTouch removeAuthFromKeychainForName:kKeychainItemName];
//        service.authorizer = nil;

        [self updateUI];
    }
}

- (void)loginGoogleDrive {
    if (![self isSignedIn]) {
        // Sign in
        [self runSigninThenHandler:^{
            // [self updateUI];
        }];
    } else {
        // Sign out
        
//        GTLServiceDrive *service = self.driveService;
//
//        [GTMOAuth2ViewControllerTouch removeAuthFromKeychainForName:kKeychainItemName];
//        service.authorizer = nil;
        
        // [self updateUI];
    }
}

- (IBAction)logOffGoogleDrive
{
    /*
    [GTMOAuth2ViewControllerTouch removeAuthFromKeychainForName:kKeychainItemName];
    [GTMOAuth2ViewControllerTouch revokeTokenForGoogleAuthentication:class_auth];
     */
}



#pragma mark -
#pragma mark Sign In

- (void)runSigninThenHandler:(void (^)(void))handler {
    assert(nil);
}


#pragma mark Remote Home and List Access

- (void)initializeAvailableWithDelegate: (id<Z5RemoteDataFetchProtocol>) delegate
{
    [self refreshAuthentication];
    NSLog(@"RemoteData.initializeAvailable, %@", ([self isSignedIn]?@"signed in":@"Logged Off"));
    if ([self isSignedIn]) {
        
        /*
        homeRequestDelegate = [[Z5RemoteDataDriveDelegate alloc] initWith:delegate];
        [homeRequestDelegate setRemoteDataController:self];
        [self queryHomeDirectoryInfoWithDelegate:homeRequestDelegate];
         */
    }
}

- (void) homeResultAvailable
{
    // NSLog(@"RemaoteData.homeResultAvailable: calling for file list, home id: %@",
    //[[homeRequestDelegate tellHomeResult] identifier]);
    // [self queryFileListWithDelegate:homeRequestDelegate];
}


- (void)updateUI
{
    /*
    if (homeRequestDelegate) {
        [homeRequestDelegate updateUI];
    }
     */
}

/*
// this shoudlbe in Z5DataController
- (void)displayAlert:(NSString *)title format:(NSString *)format, ... {
    NSString *result = format;
    if (format) {
        va_list argList;
        va_start(argList, format);
        result = [[NSString alloc] initWithFormat:format
                                        arguments:argList];
        va_end(argList);
    }
    
    // UIAlertView *uav = [[UIAlertView alloc] initWithTitle:title message:result delegate:self cancelButtonTitle:@"OK/cancel" otherButtonTitles:nil];
    // [uav show];
 
 
    UIAlertController* alert = [UIAlertController alertControllerWithTitle:@"My Alert"
                                                                   message:@"This is an alert."
                                                            preferredStyle:UIAlertControllerStyleAlert];
    
    UIAlertAction* defaultAction = [UIAlertAction actionWithTitle:@"OK" style:UIAlertActionStyleDefault
                                                          handler:^(UIAlertAction * action) {}];
    
    [alert addAction:defaultAction];
    [self presentViewController:alert animated:YES completion:nil];
 }
*/




#pragma mark - find-or-create home directory, from Coord-Medic-Rove/ZCMRemoteDataController
#pragma mark Home and MainData access
/*
- (GTLDriveFile *) homeDirectoryDriveFile
{
    return [homeRequestDelegate tellHomeResult];
}
*/
- (void) queryHomeDirectoryInfoWithDelegate: (id<Z5RemoteDataFetchProtocol>) delegate
{
    /*
    GTLQueryDrive *query = [GTLQueryDrive queryForFilesList];
    
    query.q = @"'root' in parents and title = 'NutritionSummary'";
    query.maxResults = 150;
    __block NSString *ret = @"none";
    
    // NSLog(@"RemoteData.queryHomeDirectoryInfo: execute query");
    [delegate showHomeAsk];
    // GTLServiceTicket *fileListTicket =
    [self.driveService executeQuery:query
                  completionHandler:^(GTLServiceTicket *ticket,
                                      GTLDriveFileList *fileList,
                                      NSError *error) {
                      
                      // NSLog(@"RemoteData.queryHomeDirectoryInfo: nserror: %@", error);
                      if (nil == error) {
                          Boolean homeDirectoryFound = NO;
                          
                          for (GTLDriveFile *fil in fileList) {
                              if (![[fil.labels trashed] boolValue]) {
                                  if ([[fil title] compare:@"NutritionSummary"] == NSOrderedSame) {
                                      // NSLog(@"RemoteData.queryHomeDirectoryInfo: have home result: %@", delegate);
                                      GTLDateTime *homeCreateDateTime = [fil createdDate];
                                      ret = [[NSString alloc] initWithFormat:@"Home created: %@",[homeCreateDateTime stringValue]];
                                      self.homeCreateDateTime3339 = [homeCreateDateTime stringValue];
                                      self.homeDirectoryFileId = [fil identifier];
                                      
                                      homeDirectoryFound = YES;
                                      [delegate showHomeResult:fil];
                                  }
                              }
                          }
                          if (homeDirectoryFound) {
                              // NSLog(@"RemoteData.queryHomeDirectoryInfo/executeQuery: Finished home creation time check: ret: %@", ret);
                              // [self fetchMainDataInfo];
                          } else {
                              NSLog(@"RemoteData.queryHomeDirectoryInfo/executeQuery: Need to create NutritionSummary folder");
                              
                              //                              [self createHomeDirectoryFolder];
                              // moving code into this function
                              // allows getting delegate, however this is untested yet
                              
                              void (^w30HomeDirectory)(GTLServiceTicket *ticket,
                                                       GTLDriveFile *insertedFile, NSError *error) = ^(GTLServiceTicket *ticket,
                                                                                                       GTLDriveFile *insertedFile, NSError *error) {
                                  if (error == nil) {
                                      // Uncomment the following line to print the File ID.
                                      NSLog(@"RemoteData.w30HomeDirectory: Folder ID: %@", insertedFile.identifier);
                                      // completionBlock(insertedFile, nil);
                                      [self setHomeDirectoryFileId:insertedFile.identifier];
                                      
                                      [delegate showHomeResult:insertedFile];
                                      
                                  } else {
                                      NSLog(@"RemoteData.w30HomeDirectory: error occurred: %@", error);
                                      // completionBlock(nil, error);
                                  }
                              };
                              NSLog(@"RemoteData.createHomeDirectoryFolder: GOOD LUCK last time -- IT WORKED FIRST TIME!!");
                              [self createFolderOnDrive:mainFolderName withBlock:w30HomeDirectory];
                              
                          }
                      } else {
                          [delegate showHomeError:error];
                      }
                  }
     ];
     */
}


// TODO: connect firebase
/*
-(void)createFolderOnDrive: (NSString *)name withBlock:(void(^)(GTLServiceTicket *ticket, GTLDriveFile *insertedFile, NSError *error))finalFix
{
    [self createFolderOnDrive:name inDirectory:nil withBlock:finalFix];
}
-(void)createFolderOnDrive: (NSString *)name inDirectory: (NSString *)parentID withBlock:(void(^)(GTLServiceTicket *ticket, GTLDriveFile *insertedFile, NSError *error))finalFix
{

    GTLDriveFile *file = [GTLDriveFile object];
    NSString *mimeType = @"application/vnd.google-apps.folder";
    file.title = name;      // @"CoordinatedMedicine";
    file.descriptionProperty = @"folder for cloud app data";
    file.mimeType = mimeType;
    if (parentID.length && ![parentID isEqualToString:@"0"]) {
        GTLDriveParentReference *parentRef = [GTLDriveParentReference object];
        parentRef.identifier = parentID;
        file.parents = [NSArray arrayWithObject:parentRef];
    }
    
    
    GTLQueryDrive *query = [GTLQueryDrive queryForFilesInsertWithObject:file
                                                       uploadParameters:nil];
    
    // queryTicket can be used to track the status of the request, more information can
    // be found on https://code.google.com/p/google-api-objectivec-client/wiki/Introduction#Uploading_Files
    // GTLServiceTicket *queryTicket =
    [self.driveService executeQuery:query completionHandler:finalFix];


}
*/
- (BOOL) isHomeInfoError
{
    // NSLog(@"RemoteData.isHomeInfoError: reporting %@", ([homeRequestDelegate tellHomeError]? @"error" : @"all good"));
    // return [homeRequestDelegate tellHomeError];
    return NO;
}
- (void) queryFileListWithDelegate:(id<Z5RemoteDataFetchProtocol>) delegate
{
    /*
    if ([homeRequestDelegate tellHomeError]) {
        NSLog(@"RemoteData.queryFileListWithDelegate: HOME ERROR, NO-OP");
        return;
    }
    
    GTLServiceDrive *service = self.driveService;
    
    
    // NSString *homeId = [[delegate tellHomeResult] identifier];
    // NSLog(@"RemoteData.queryFileListWithDelegate: service: %@   home-id: %@", service, homeId);
    
    GTLQueryDrive *query = [GTLQueryDrive queryForFilesList];
    
    // maxResults specifies the number of results per page.  Since we earlier
    // specified shouldFetchNextPages=YES, all results should be fetched,
    // though specifying a larger maxResults will reduce the number of fetches
    // needed to retrieve all pages.
    query.maxResults = 150;
    */
    
    /*
    [delegate showFetchAsk];
    
    // _fileListTicket =
    [service executeQuery:query
        completionHandler:^(GTLServiceTicket *ticket,
                            GTLDriveFileList *fileList,
                            NSError *error) {
            // Callback
            _fileList = fileList;
            _fileListFetchError = error;
            // _fileListTicket = nil;
            
            if (nil == error) {
                
                [delegate showFetchResult:[fileList items]];
                
            } else {
                [delegate showFetchError];
            }
            
            [delegate updateUI];
        }];
        */
}

- (void) updateOrInsertMenuItemListOnDriveWithDelegate:(id<Z5RemoteDataFetchProtocol>) delegate
{
    /*
    GTLQueryDrive *query = [GTLQueryDrive queryForFilesList];
    
    NSString *queryString = [[NSString alloc] initWithFormat:@"'%@' in parents", [self homeDirectoryFileId]];
    NSLog(@"RemoteData.updateOrInsertMenuItemListOnDriveWithDelegate queryString: %@", queryString);
    query.q = queryString;
    query.maxResults = 150;
    
    [delegate showPublishAsk];
*/
    // This first search should give me CoordinatedMedicine (by fileId),
    // and all the 'name' ("coordmedic.json") data-file (also by fileId).
    // Then look through name-file-list for GTLDriveFile-s with folder in parents
    
    // Auxiliary search would show parents for all name data-files. No, there are no more data-files,
    // the shared files are elsewhere.
    
    // Auxiliary search first?  After completion of file search (all files this app)
    //      update data file by [self updateDriveFile];
    //      OR create the file in the [self homeDirectoryFileId] folder
    // GTLServiceTicket *fileListTicket =
    /*
    [self.driveService executeQuery:query completionHandler:^(GTLServiceTicket *ticket,
                                                              GTLDriveFileList *fileList,
                                                              NSError *error) {
        if (error) {
            [delegate showPublishError];
        } else {
            [delegate showPublishResult];
            for (GTLDriveFile *file in fileList) {
                NSLog(@"RemoteData.updateOrInsertMenuItemListOnDriveWithDelegate: file in home: %@", [file title]);
            }

            NSArray *names = [[NSArray alloc] initWithObjects:@"Leucine" , @"Arginine", nil];
            for (NSString *name in names) {
                NSLog(@"RemoteData.updateOrInsertMenuItemListOnDriveWithDelegate: name: %@", name);
            }




//            [self fillMenuItemList];
//            for (MenuItem *m5mo in [self menuItemsList]) {
//                [self updateOrInsertMenuItem:m5mo onDrive: (GTLDriveFileList *) fileList withDelegate:delegate];
//            }       // END -- for MenuItem in list



        }       // END -- if no error
    }];
     */
}

- (void) insertMenuItem: (MenuItem *)m5mo withDelegate: (id <Z5RemoteDataFetchProtocol>)delegate
{
    /*   TODO: hook firebase

    NSString *newStr = [m5mo bodytext];
    NSData* data = [newStr dataUsingEncoding:NSUTF8StringEncoding];
    
    // after check is complete, regardless, put up data file
    GTLDriveFile *file = [GTLDriveFile object];

    NSString *newFileName;  //    = [[m5mo name] stringByAppendingString:@".mol"];
    NSString *menuItemName = [m5mo name];
    if ([menuItemName containsString:@".mol"]) {
        newFileName = menuItemName;
    } else if ([menuItemName containsString:@".pdb"]) {
        newFileName = menuItemName;
    } else if ([[m5mo bodytext] containsString:@"HEADER"]) {
        newFileName = [[m5mo name] stringByAppendingString:@".pdb"];
    } else {
        newFileName = [[m5mo name] stringByAppendingString:@".mol"];
    }

    file.title = newFileName;
    file.descriptionProperty = @"Uploaded Menu-Item";
    file.mimeType = @"text/plain"; // @"image/png";
    
    GTLDriveParentReference *newParent = [GTLDriveParentReference object];
    newParent.identifier = [self homeDirectoryFileId];
    file.parents = [NSArray arrayWithObject:newParent];
    
    // where is my new file id?
    [self postData:data toNewGoogleDriveFile:file withDelegate:delegate];
    */
}

//- (void) updateOrInsertMenuItem: (MenuItem *) m5mo onDrive: (GTLDriveFileList *)fileList withDelegate:(id<Z5RemoteDataFetchProtocol>) delegate
//{
//    // NSLog(@"RemoteData.updateOrInsertMenuItemListOnDriveWithDelegate: generate file for %@", [m5mo name]);
//    NSString *newFileName = [[m5mo name] stringByAppendingString:@".mol"];
//    Boolean found_flag = NO;
//    GTLDriveFile *found_file = nil;
//    
//    found_flag = NO;
//    found_file = nil;
//    for (GTLDriveFile *file in fileList) {
//        if ([[file title] isEqualToString:newFileName]) {
//            // NSLog(@"RemoteData.updateOrInsertMenuItemListOnDriveWithDelegate: remote file: %@", [file title]);
//            found_flag = YES;
//            found_file = file;
//            break;
//        }
//    }
//    
//    
//    // After everything (/ this is more complicated now /),
//    // check JSON file found, if not, insert.
//    if (found_flag) {
//        //                NSString* newStr = [[NSString alloc] initWithData:[self mainData] encoding:NSUTF8StringEncoding];
//        //                NSLog(@"RemoteData.updateOrInsertDataFile: newStr: %@", newStr);
//        NSString *newStr = [m5mo bodytext];
//        // NSLog(@"RemoteData.updateOrInsertMenuItemListOnDriveWithDelegate: bodytext: %@", newStr);
//        NSString *localMD5hash = [newStr generateMD5Hash];
//        NSString *driveMD5hash = [found_file md5Checksum];
//        NSLog(@"RemoteData.updateOrInsertMenuItemListOnDriveWithDelegate: remote MD5: %@", [found_file md5Checksum]);
//        NSLog(@"RemoteData.updateOrInsertMenuItemListOnDriveWithDelegate: local MD5: %@", [newStr generateMD5Hash]);
//        if ([localMD5hash isEqualToString:driveMD5hash]) {
//            NSLog(@"... local and drive file equal");
//        } else {
//            NSLog(@"... local and drive file differ");
//            //                [self updateFragmentFile:found_file withData:content];
//            //                    NSData *fileData = [[NSData alloc] initWithBase64EncodedString:newStr options:NSDataBase64EncodingEndLineWithCarriageReturn];
//            NSData* data = [newStr dataUsingEncoding:NSUTF8StringEncoding];
//            
//            [self updateDriveFile:found_file withData: data];
//        }
//        
//        
//    } else {
//        NSLog(@"RemoteData.update-or-insert-datafile: INSERT");
//        
//        [self insertMenuItem:m5mo withDelegate:delegate];
//        
//    }   // END -- if found file
//}

/*
- (void) trashMenuItem: (GTLDriveFile *)file
{
    GTLQueryDrive *query = [GTLQueryDrive queryForFilesTrashWithFileId:[file identifier]];
    
    // GTLServiceTicket *fileListTicket =
    [self.driveService executeQuery:query completionHandler:^(GTLServiceTicket *ticket,
                                                              GTLDriveFileList *fileList,
                                                              NSError *error) {
        if (error) {
            NSLog(@"RemoteData.trashMenuItem: ERROR: %@", [error localizedDescription]);
        }
    }];
}
 */
- (void) fetchMenuItem: (NSString *)fileId onDriveWithDelegate:(id<Z5RemoteDataFetchProtocol>) delegate
{/*
    GTLQueryDrive *query = [GTLQueryDrive queryForFilesGetWithFileId:fileId];
    query.maxResults = 150;
    // GTLServiceTicket *fileListTicket =
    [self.driveService executeQuery:query completionHandler:^(GTLServiceTicket *ticket,
                                                              GTLDriveFile *file,
                                                              NSError *error) {
        if (error) {
            [delegate showPublishError];
        } else {
            [delegate showPublishResult];
        }
    }];
  */
}

/*
- (void) updateDriveFile: (GTLDriveFile *)file withData: (NSData *)data
{
 */
/*
    GTLUploadParameters *uploadParameters = [GTLUploadParameters uploadParametersWithData:data MIMEType:file.mimeType];
    GTLQueryDrive *query = [GTLQueryDrive queryForFilesUpdateWithObject:file
                                                                 fileId:file.identifier
                                                       uploadParameters:uploadParameters];
    
    // UIAlertView *waitIndicator = [Z5DataController showWaitIndicator:@"Updating on Google Drive"];
    
    [self.driveService executeQuery:query
                  completionHandler:^(GTLServiceTicket *ticket,
                                      GTLDriveFile *insertedFile, NSError *error) {
                      // [waitIndicator dismissWithClickedButtonIndex:0 animated:YES];
                      if (error == nil)
                      {
                          NSLog(@"RemoteDataController.updateDriveFile/complete: File ID: %@", insertedFile.identifier);

                          // [Z5DataController showAlert:@"Google Drive" message:@"File updated!"];
                          
                      }
                      else
                      {
                          NSLog(@"RemoteDataController.updateDriveFile/complete:An error occurred: %@", error);
                          // [Z5DataController showAlert:@"Google Drive Update" message:@"Sorry, an error occurred!"];
                      }
                  }];
}
*/

//- (void) putTestFile
//{
//    GTLDriveFile *rrfile;
//    GTLDriveFile *file = nil;
//    GTLDriveFile *found_file = nil;
//    NSString *rrDatabaseFilename = @"Leucine/Arganine";
//    if ([[rrfile title] compare:rrDatabaseFilename] == NSOrderedSame) {
//        NSLog(@"RemoteData.putTestFile: UPDATE");
//        // This is coordmedic.json file
//        //        if ([self beenTrashed:file]) { continue; }
//        //        if (![self isMyFile:file]) { continue; }
//        // file not trashed
//        // file belongs to us
//        //        found_flag = YES;
//        found_file = file;
//    }
//}
/*
- (void) postData: (NSData *)newfdata toNewGoogleDriveFile: (GTLDriveFile *) file withDelegate: (id <Z5RemoteDataFetchProtocol>)delegate
{

    GTLUploadParameters *uploadParameters = [GTLUploadParameters uploadParametersWithData:newfdata MIMEType:file.mimeType];
    
    
    GTLQueryDrive *query = [GTLQueryDrive queryForFilesInsertWithObject:file
                                                       uploadParameters:uploadParameters];
    
    // UIAlertView *waitIndicator = [Z5DataController showWaitIndicator:@"Uploading to Google Drive"];
    
    [self.driveService executeQuery:query
                  completionHandler:^(GTLServiceTicket *ticket,
                                      GTLDriveFile *insertedFile,
                                      NSError *error) {
                      // [waitIndicator dismissWithClickedButtonIndex:0 animated:YES];
                      if (error == nil)
                      {
                          [delegate showInsertResult:insertedFile];
                      }
                      else
                      {
                          NSLog(@"RemoteData.postData: An error occurred: %@", [error localizedDescription]);
                          // [Z5DataController showAlert:@"Google Drive" message:@"Sorry, an error occurred!"];
                      }
                  }];
}
 */

- (void)surveyDirectory: (UITextField *)result_text
{
    /*
    NSLog(@"RemoteData: Survey directory");
    GTLQueryDrive *query = [GTLQueryDrive queryForFilesList];
    
    NSLog(@"RemoteData.surveyDirectory: query: %@", [query description]);
    
    GTLServiceTicket *fileListTicket = [[[[Z5DataController sharedInstance] remoteDataController] driveService] executeQuery:query  completionHandler:^(GTLServiceTicket *ticket,
                                                GTLDriveFileList *fileList,
                                                NSError *error)
                                        {
                                            // Callbacka
                                            NSMutableString *result_out = [[NSMutableString alloc] initWithCapacity:256];
                                            for (GTLDriveFile *fil in fileList) {
                                                if (![[fil.labels trashed] boolValue]) {
                                                    NSLog(@"DebugExtraView.surveyDirectory: title: %@", [fil title]);
                                                    [result_out appendString:[fil title]];
                                                    [result_out appendString:@"\n"];
                                                } else {
                                                    NSLog(@"DebugExtraView.surveyDirectory: TRASHED: title: %@", [fil title]);
                                                }
                                            }
                                            result_text.text = result_out;
                                        }];
    
    NSLog(@"RemoteData.surveyDirectory: fileListTicket.statusCode: %ld", (long)[fileListTicket statusCode]);
    */
}

/*?
 * Unknown use
- (void) fillMenuItemList
{
    [self.menuItemsList removeAllObjects];
    NSArray *objects = [[[Z5DataController sharedInstance] localDataController] retrieveAllMenuItems:[NSNumber numberWithInt:1]];
    // NSLog(@"RemoteData.fillMenuItemList: #menuItems: %ld", (long)[objects count]);
    for (NSManagedObject *menuItem in objects) {
        MenuItem *dbMenuItem = (MenuItem *)menuItem;
        NSLog(@"RemoteData.fillMenuItemList: menuItem into list: %@", [dbMenuItem name]);
        //[self.menuItemsList addObject:menuItem];
    }
    // NSLog(@"RemoteData.fillMenuItemList: count: %lu", (unsigned long)[self.menuItemsList count]);
    // [self.tableView reloadData];
}
 */

#pragma mark -
#pragma mark Download file from drive


//- (void) downloadFile: (GTLDriveFile *)file withDelegate:(id<Z5RemoteDataFetchProtocol>) delegate
//{
//    // GTLServiceDrive *drive = ...;
//    // GTLDriveFile *file = ...;
//    __block NSString *driveFileTitle = [file title];
//    __block NSString *driveFileId = [file identifier];
//    GTMHTTPFetcher *fetcher = [self.driveService.fetcherService fetcherWithURLString:file.downloadUrl];
//
//    [fetcher beginFetchWithCompletionHandler:^(NSData *data, NSError *error) {
//        if (error == nil) {
//            // NSLog(@"RemoteData.downloadFile: Retrieved file content");
//            //        NSString *contents = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
//            //        NSLog(@"RemoteData.downloadFile: contents: %@", contents);
//
//            [delegate showDataFetch:data fromFile:driveFileTitle withGoogleId:driveFileId];
//
//        } else {
//            NSLog(@"RemoteDate.downloadFile: An error occurred: %@", error);
//        }
//    }];
//}


#pragma mark Fetch File Details

- (void)fetchSelectedFileDetails {
    /*
    _revisionList = nil;
    _revisionListFetchError = nil;
    _permissionList = nil;
    _permissionListFetchError = nil;
    _childList = nil;
    _childListFetchError = nil;
    _parentsList = nil;
    _parentsListFetchError = nil;
    
    _detailsFetchError = nil;
    
    GTLServiceDrive *service = self.driveService;
    
    GTLDriveFile *selectedFile = [self selectedFileListEntry:1];
    NSString *fileID = selectedFile.identifier;
    if (fileID) {
        // Rather than make separate fetches for each kind of detail for the
        // selected file, we'll make a single batch query to etch the various
        // details.  Each query in the batch will have its own result or error,
        // and the batch query execution itself may fail with an error.
        GTLQueryDrive *revisionQuery = [GTLQueryDrive queryForRevisionsListWithFileId:fileID];
        revisionQuery.completionBlock = ^(GTLServiceTicket *ticket, GTLDriveRevisionList *obj,
                                          NSError *error) {
            _revisionList = obj;
            _revisionListFetchError = error;
        };
        
        GTLQueryDrive *permissionQuery = [GTLQueryDrive queryForPermissionsListWithFileId:fileID];
        permissionQuery.completionBlock = ^(GTLServiceTicket *ticket, GTLDrivePermissionList *obj,
                                            NSError *error) {
            _permissionList = obj;
            _permissionListFetchError = error;
        };
        
        GTLQueryDrive *childQuery = [GTLQueryDrive queryForChildrenListWithFolderId:fileID];
        childQuery.completionBlock = ^(GTLServiceTicket *ticket, GTLDriveChildList *obj,
                                       NSError *error) {
            _childList = obj;
            _childListFetchError = error;
        };
        
        GTLQueryDrive *parentsQuery = [GTLQueryDrive queryForParentsListWithFileId:fileID];
        parentsQuery.completionBlock = ^(GTLServiceTicket *ticket, GTLDriveParentList *obj,
                                         NSError *error) {
            // Note that we could obtain the parents list for a file item from the
            // main file list feed, too.
            _parentsList = obj;
            _parentsListFetchError = error;
        };
        */
/*
        // Combine the separate queries into one batch.
        GTLBatchQuery *batchQuery = [GTLBatchQuery batchQuery];
        [batchQuery addQuery:revisionQuery];
        [batchQuery addQuery:permissionQuery];
        [batchQuery addQuery:childQuery];
        [batchQuery addQuery:parentsQuery];
        
        _detailsTicket = [service executeQuery:batchQuery
                             completionHandler:^(GTLServiceTicket *ticket,
                                                 GTLBatchResult *batchResult, NSError *error) {
                                 // Callback
                                 //
                                 // The batch query execution completionHandler runs after the individual
                                 // query completion handlers have been called.
                                 _detailsTicket = nil;
                                 _detailsFetchError = error;
                                 
                                 [self updateUI];
                             }];
 
        [self updateUI];
    }
 */
}

#pragma mark Delete a File

- (void)deleteSelectedFile {
    /*
    GTLServiceDrive *service = self.driveService;
    
    GTLDriveFile *selectedFile = [self selectedFileListEntry:1];
    NSString *fileID = selectedFile.identifier;
    if (fileID) {
        GTLQueryDrive *query = [GTLQueryDrive queryForFilesDeleteWithFileId:fileID];
        _editFileListTicket = [service executeQuery:query
                                  completionHandler:^(GTLServiceTicket *ticket,
                                                      id nilObject,
                                                      NSError *error) {
                                      // Callback
                                      _editFileListTicket = nil;
                                      if (error == nil) {
                                          [self displayAlert:@"Deleted"
                                                      format:@"Deleted \"%@\"",
                                           selectedFile.title];
                                          [self updateUI];
                                          // [self fetchFileList];
                                      } else {
                                          [self displayAlert:@"Delete Failed"
                                                      format:@"%@", error];
                                      }
                                  }];
    }
     */
}

#pragma mark - Google product
// From https://developers.google.com/drive/v2/reference/files/list
//- (void)retrieveAllFiles
//{
//    [Z5GoogleProvided retrieveAllFilesWithService: [self driveService] completionBlock:^void (NSArray *a2, NSError *e2) {
//        if (nil == e2) {
//            NSLog(@"RemoteData.retrieveAllFiles: data count: %lu", (unsigned long)[a2 count]);
//        }
//    }];
//}

//- (Z2MenuItem *)scanForMenuItemWithFileId:(NSString *)googlefileid
//{
//    NSLog(@"RemoteData.scanForZ2MenuItem: huh??");
//    return nil;
//}

#pragma mark - Plus Service


@end