Z5LocalDataController.m

Go to the documentation of this file.

//
//  Z5LocalDataController.m
//  TodaysMenu
//
//  Created by Don Zeek on 12/9/15.
//  Copyright © 2015 net.dzeek.y2015.ios.portfolio. All rights reserved.
//

#import <CoreData/CoreData.h>
#import <HealthKit/HealthKit.h>

#import "Z5DataController.h"

#import "Z5HealthConnectionProtocol.h"
#import "Z5GmailDataListener.h"

static NSString *componentNameKey;
static NSString *componentValueKey;
static NSString *componentSampleKey;
static NSString *componentAuthorityKey;
static NSString *componentAuthorityDateKey;
static NSString *componentHKComponentKey;

@implementation Z5LocalDataController
{
    id<Z5HealthConnectionProtocol> healthConnectDelegate;
}

@synthesize managedObjectContext = _managedObjectContext;
@synthesize managedObjectModel = _managedObjectModel;
@synthesize persistentStoreCoordinator = _persistentStoreCoordinator;

NSString* showTheaterMenu = @"show-theater-list";
NSString* showTheaterItem = @"zeroscene-theaterdetail";
NSString* showTheaterVersion1 = @"show-molecule-randomkey";
NSString* showCurrentScene = @"show-current-scene";
NSString* healthDataAuthority = @"healthDataAuthorization";
NSString* proposedMenuItemList = @"proposed-todays-menu";
NSString* healthkitNutritionKey = @"healthkit-nutrition-key";
NSString* healthkitNutritionValidated = @"health-nutrition-validated";
NSString* healthkitNutritionAuthorized = @"healthkit-nutrition-authorized";
NSString* healthKitAuthorityKey = @"health-kit-authority-key";

NSOperationQueue *healthKitOpQueue;
/*
 the following dictionary currently has an NSNumber is each key:hkQuantityName - to be changed to each entry being a dictionary, 
 with the authoriation status, and a date for the last change.
 */
NSMutableDictionary *healthKitNutritionAuthorityDict;

HKQuantityTypeIdentifier nutritionTypes[40];
NSInteger nutritionTypeCount;

UIColor *panelBackgroundColor;
UIColor *menuHeaderBackground;
UIColor *menuContentsBackground;
UIColor *wheatBackground;

NSRange currentMenuItemGalleryPositions;
//Meal *_todaysMeal;

//NSMutableArray *localDataListeners;

+ (NSString *)componentNameKey
{
    return componentNameKey;
}
+ (NSString *)componentValueKey
{
    return componentValueKey;
}
+ (NSString *)componentSampleKey
{
    return componentSampleKey;
}
+ (NSString *)componentAuthorityKey
{
    return componentAuthorityKey;
}
+ (NSString *)componentAuthorityDateKey
{
    return componentAuthorityDateKey;
}
+ (NSString *)componentHKComponentKey
{
    return componentHKComponentKey;
}
+ (UIColor *)panelBackgroundColor
{
    return panelBackgroundColor;
}
+ (UIColor *)menuHeaderBackground
{
    return menuHeaderBackground;
}
+ (UIColor *)menuContentsBackground
{
    return menuContentsBackground;
}
+ (UIColor *)wheatBackground
{
    return wheatBackground;
}
+ (UIColor *) colorForAuthority: (NSNumber *) authorityValue
{
    UIColor *ret;
    Z5DataController *z5Data = [Z5DataController sharedInstance];
    switch ([authorityValue integerValue]) {
        case HKAuthorizationStatusSharingAuthorized:
            ret = [z5Data healthKitParamSharedColor];
            break;
        case HKAuthorizationStatusNotDetermined:
            ret = [z5Data healthKitParamNotQueried];
            break;
        case HKAuthorizationStatusSharingDenied:
            ret = [z5Data healthKitParamDeniedAuthColor];
            break;
        case HKErrorAuthorizationDenied:
            ret = [z5Data healthKitParamDeniedAuthColor];
            break;
        case HKErrorAuthorizationNotDetermined:
            ret = [z5Data healthKitParamNotQueried];
            break;
    }
    return ret;
}
+ (NSString *) captionForAuthority: (NSNumber *) authorityValue
{
    NSString *ret;
    // Z5LocalDataController *localData = [[Z5DataController sharedInstance] localDataController];
    switch ([authorityValue integerValue]) {
        case HKAuthorizationStatusSharingAuthorized:
            // NSLog(@"Z5LocalDataController.colorForAuthority: HKAuthorizationStatusSharingAuthorized");
            ret = @"sharing authorized";
            break;
        case HKAuthorizationStatusNotDetermined:
            // NSLog(@"Z5LocalDataController.colorForAuthority: HKAuthorizationStatusNotDetermined");
            ret = @"status not determined";
            break;
        case HKAuthorizationStatusSharingDenied:
            // NSLog(@"Z5LocalDataController.colorForAuthority: HKAuthorizationStatusSharingDenied");
            ret = @"Sharing denied";
            break;
        case HKErrorAuthorizationDenied:
            // NSLog(@"Z5LocalDataController.colorForAuthority: HKErrorAuthorizationDenied");
            ret = @"authorization denied";
            break;
        case HKErrorAuthorizationNotDetermined:
            // NSLog(@"Z5LocalDataController.colorForAuthority: HKErrorAuthorizationNotDetermined");
            ret = @"authorization not determined";
            break;
    }
    return ret;
}
- (id) init
{
    self = [super init];
    
    self.availableNutritionParamArray = [self establishNutritionParameters];
    healthKitOpQueue = [[NSOperationQueue alloc] init];
    [healthKitOpQueue setMaxConcurrentOperationCount:36];
    healthKitNutritionAuthorityDict = [NSMutableDictionary dictionaryWithCapacity:50];
    [self initNutritionTypes];

    componentNameKey = @"component-type";
    componentValueKey = @"component-value";
    componentSampleKey = @"component-sample";
    componentAuthorityKey = @"component-HKauthority";
    componentAuthorityDateKey = @"component-HKauthority-date";
    componentHKComponentKey = @"component-HKcomponent";
    panelBackgroundColor = [UIColor colorWithHue:0.15 saturation:0.4 brightness:0.6 alpha:1.0];
    // menuHeaderBackground = [UIColor colorWithWhite:0.75 alpha:1.0f];
    menuContentsBackground = [UIColor colorWithRed:0.9351 green:0.8945 blue:0.7421 alpha:1.0];
    // menuContentsBackground = [UIColor colorWithWhite:0.9 alpha:1.0f];
    menuHeaderBackground = [UIColor colorWithRed:0.91 green:0.789 blue:0.4843 alpha:1.0];
    menuContentsBackground = [UIColor colorWithRed:245.0/255.0 green:222.0/255.0 blue:179.0/255.0 alpha:1.0];
/*
 panelBackgroundColor = [UIColor colorWithRed:244/256 green:229/256 blue:190/256 alpha:1];
 menuHeaderBackground = [UIColor colorWithRed:233/256 green:202/256 blue:124/256 alpha:1];
 */
    currentMenuItemGalleryPositions.location = 10;
    currentMenuItemGalleryPositions.length = 0;
    _todaysMeal = nil;
    
//    localDataListeners = [[NSMutableArray alloc] initWithCapacity:10];
    
    return self;
}

- (void) logGallery: (NSNumber *)galleryChoice caption: (NSString *) caption
{
    NSLog(@"Z5LocalDataController.logGallery: %@ caption: %@", galleryChoice, caption);
    // NSNumber *galleryChoice = [NSNumber numberWithInt:1];
    switch ([galleryChoice integerValue]) {
        case 0:
        {
            NSArray *localDataMenuItems = [self retrieveAllMenuItems:galleryChoice];
            for (MenuItem *mItem in localDataMenuItems) {
                NSLog(@"Z5LocalDataController.logGallery: mItem-name: %@", mItem.name);
            }
        }
        break;
        case 1:
        {
            NSArray *localDataMeals = [self retrieveAllMeals:galleryChoice];
            for (Meal *mItem in localDataMeals) {
                NSLog(@"Z5LocalDataController.logGallery: meal: %@", mItem);
            }
        }
        break;
        default:
        NSLog(@"Z5LocalDataController.logGallery: %@", galleryChoice);
    }
}

- (void)saveContext
{
    NSError *error = nil;
    NSManagedObjectContext *managedObjectContext = self.managedObjectContext;
    if (managedObjectContext != nil) {
        if ([managedObjectContext hasChanges] && ![managedObjectContext save:&error]) {
            // Replace this implementation with code to handle the error appropriately.
            // abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
            NSLog(@"Z5LocalDataController.saveContext: Unresolved error %@, %@", error, [error userInfo]);
            abort();
        }
    }
    
    NSLog(@"Z5LocalDataController.saveContext: write user prefs");
    [self putTodaysMenuInUserDefaults];
    [self putHealthKitAuthorityInUserDefaults];
    [self putCredentialsInUserDefaults];
}



#pragma mark - Core Data stack

- (NSManagedObjectContext *)managedObjectContext
{
    if (_managedObjectContext != nil) {
        return _managedObjectContext;
    }
    
    NSPersistentStoreCoordinator *coordinator = [self persistentStoreCoordinator];
    if (coordinator != nil) {
        // _managedObjectContext = [[NSManagedObjectContext alloc] init];
        _managedObjectContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSMainQueueConcurrencyType];
        [_managedObjectContext setPersistentStoreCoordinator:coordinator];
    }
    return _managedObjectContext;
}

- (NSManagedObjectModel *)managedObjectModel
{
    if (_managedObjectModel != nil) {
        return _managedObjectModel;
    }
    
    NSBundle *mainb = [NSBundle mainBundle];
    
    // NSLog(@"LocalData.managedObjectModel: mainb resourceURL: %@", [mainb resourceURL]);
    
    NSURL *modelURL = [mainb URLForResource:@"nutritionMenuModel" withExtension:@"momd"];
    _managedObjectModel = [[NSManagedObjectModel alloc] initWithContentsOfURL:modelURL];
    return _managedObjectModel;
}

- (NSPersistentStoreCoordinator *)persistentStoreCoordinator
{
    if (_persistentStoreCoordinator != nil) {
        return _persistentStoreCoordinator;
    }
    
    NSURL *storeURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:@"ProjectName.sqlite"];
    
    NSError *error = nil;
    _persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:[self managedObjectModel]];
    NSDictionary *options = @{
                              NSMigratePersistentStoresAutomaticallyOption : @YES,
                              NSInferMappingModelAutomaticallyOption: @YES
                              };
    if (![_persistentStoreCoordinator
          addPersistentStoreWithType:NSSQLiteStoreType
          configuration:nil
          URL:storeURL options:options
          error:&error]) {
        /*
         Replace this implementation with code to handle the error appropriately.
         
         abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
         
         Typical reasons for an error here include:
         * The persistent store is not accessible;
         * The schema for the persistent store is incompatible with current managed object model.
         Check the error message to determine what the actual problem was.
         
         If the persistent store is not accessible, there is typically something wrong with the file path. Often, a file URL is pointing into the application's resources directory instead of a writeable directory.
         
         If you encounter schema incompatibility errors during development, you can reduce their frequency by:
         * Simply deleting the existing store:
         [[NSFileManager defaultManager] removeItemAtURL:storeURL error:nil]
         
         * Performing automatic lightweight migration by passing the following dictionary as the options parameter:
         @{NSMigratePersistentStoresAutomaticallyOption:@YES, NSInferMappingModelAutomaticallyOption:@YES}
         
         Lightweight migration will only work for a limited set of schema changes; consult "Core Data Model Versioning and Data Migration Programming Guide" for details.
         
         */
        NSLog(@"Z5LocalDataController.persistentStoreCoordinator: Unresolved error %@, %@", error, [error userInfo]);
        // abort();
        // [[NSFileManager defaultManager] removeItemAtURL:storeURL error:nil];
    }
    
    return _persistentStoreCoordinator;
}


#pragma mark - Meal Data
- (NSArray<Meal *> *) findMealsWithDate: (NSDate *)findDate
{
    NSArray<Meal *> *ret = [Meal findMealsWithDate:findDate context:[self managedObjectContext]];
    
    return ret;
}
- (NSArray<Meal *> *) findMealsThisMonthDate: (NSDate *)findDate
{
    NSArray<Meal *> *ret = [Meal findMealsByMonth:findDate context:[self managedObjectContext]];
    
    return ret;
}
- (NSArray<Meal *> *) retrieveAllMeals: (NSNumber *)galleryNo
{
    NSLog(@"Z5LocalDataController.retrieveAllMeals: gallery: %@", galleryNo);
    
    NSArray<Meal *> *ret = [Meal retrieveAllMealsForGallery: (NSNumber *) galleryNo  context:[self managedObjectContext]];
    
    NSLog(@"Z5LocalDataController.retrieveAllMeals: meals retrieved: %lu", (unsigned long)[ret count]);
    
    return ret;
}

- (void) eraseMealsThisMonthDate: (NSDate *)findDate
{
    [Meal deleteMealsByMonth:findDate context:[self managedObjectContext]];
}

- (NSArray<Meal *> *) findOrCreateMealWithDate: (NSDate *)findDate
{
    NSArray<Meal *> *ret = [Meal findOrCreateMealWithDate:findDate context:[self managedObjectContext]];
    NSLog(@"Z5LocalDataController.findOrCreateMealWithDate: returning %lu meal(s)", (unsigned long)[ret count]);
    return ret;
}
- (Boolean) removeMealWithRandomkey: (NSString *)removeKey
{
    [Meal deleteMealByRandomkey:removeKey context:[self managedObjectContext]];
    
    return YES;
}
- (void) todaysMealRequested: (NSDate *)date
{
    NSArray<Meal *> *dailyMeal = [self findOrCreateMealWithDate: date];
    _todaysMeal = [dailyMeal lastObject];
    NSArray<MenuItem *> *todaysMenuItems = [self todaysMenuItems];
    _todaysMeal.containedItem = [NSSet setWithArray:todaysMenuItems];
    _todaysMeal.orderDate = date;
    _todaysMeal.randomkey = [Z5DataController produceRandomkey];

    [_todaysMenuItems removeAllObjects];
    _todaysMenuItems = nil;
}

- (void) todaysMealConsumed: (NSDate *)date forDelegate: (id<Z5HealthConnectionProtocol>)jingo
{
    [self goHealthData:[self todaysMenuComponents] forDelegate:jingo];

    // instead of right-now, take meal date from date-picker
    // NSDate *rightNow = [NSDate dateWithTimeIntervalSinceNow:0];

    // mmm

/*
    NSArray<Meal *> *dailyMeal = [self findOrCreateMealWithDate: date];
    Meal *meal = [dailyMeal lastObject];
    NSArray<MenuItem *> *todaysMenuItems = [self todaysMenuItems];
    meal.containedItem = [NSSet setWithArray:todaysMenuItems];
 */
    _todaysMeal.consumeDate = date;
    NSLog(@"Z5LocalDataController.todaysMealConsumed: rating: %3.2f", [_todaysMeal.rating floatValue]);
    
}
- (void) todaysMealRated: (float)rating
{
    NSNumber *ratingNumber = [NSNumber numberWithFloat:rating];
    [_todaysMeal setRating:ratingNumber];
}

- (void) todaysMealSkipped
{
    NSLog(@"Z5LocalDataController.todaysMealSkipped: _todaysMeal: %@", _todaysMeal);
    if (_todaysMeal) {
        [self removeTodaysMealFromDatabase];
    }
}
-(void) removeTodaysMealFromDatabase
{
    NSString *removeKey = [_todaysMeal randomkey];
    [self removeMealWithRandomkey:removeKey];
}
- (NSDate *) toLocalTime: (NSDate *)grenwich
{   
    NSCalendar *gregorian = [[NSCalendar alloc]
                             initWithCalendarIdentifier:NSCalendarIdentifierGregorian];
    NSDateComponents *dayComponents =
    [gregorian components:(NSCalendarUnitDay |
                           NSCalendarUnitMonth |
                           NSCalendarUnitYear) fromDate:grenwich];
    NSInteger day = [dayComponents day];
    NSInteger month = [dayComponents month];
    NSInteger year = [dayComponents year];
    
    NSCalendar *calendar = [NSCalendar currentCalendar];
    [calendar setTimeZone: [NSTimeZone systemTimeZone]];
    
    // Specify the date components manually (year, month, day, hour, minutes, etc.)
    NSDateComponents *timeZoneComps=[[NSDateComponents alloc] init];
    [timeZoneComps setSecond:0];
    [timeZoneComps setMinute:0];
    [timeZoneComps setHour:0];
    [timeZoneComps setDay:day];
    [timeZoneComps setMonth:month];
    [timeZoneComps setYear:year];
    [timeZoneComps setSecond:0];

    NSDate *ret = [calendar dateFromComponents:timeZoneComps];

    return ret;
}

#pragma mark - MenuItem Data
- (MenuItem *) findMenuItemWithRandomkey: (NSString *)randomkey
{
    MenuItem *ret = [MenuItem findMenuItemWithRandomkey:randomkey
                                          context:[self managedObjectContext]];
    
    return ret;
}


- (MenuItem *) findOrCreateMenuItemWithRandomkey: (NSString *)randomkey
{
    MenuItem *ret = [MenuItem findOrCreateMenuItemWithRandomkey:randomkey
                                                        context:[self managedObjectContext]];
    NSLog(@"Z5LocalDataController.findOrCreateMenuItemWithRandomkey: randomkey: %@  name: %@", randomkey, [ret name]);
    
    ret.galleryPositionNo = [NSNumber numberWithLong:[self getNextGalleryPositionIdx]];
    ret.galleryNumber = [NSNumber numberWithLong:1];
    
    return ret;
}
- (MenuItem *) findMenuItemWithFileIdentification: (NSString *)googlefileid
{
    MenuItem *ret = [MenuItem findMenuItemWithFileIdentification:googlefileid
                                                         context:[self managedObjectContext]];
    
    return ret;
}
- (MenuItem *) findOrCreateMenuItemWithFileIdentification: (NSString *)googlefileid
{
    MenuItem *ret = [MenuItem findOrCreateMenuItemWithFileIdentification: googlefileid context:[self managedObjectContext]];
    if (!ret.randomkey) {
        ret.randomkey = [Z5DataController produceRandomkey];
        ret.galleryPositionNo = [NSNumber numberWithLong:[self getNextGalleryPositionIdx]];
        ret.galleryNumber = [NSNumber numberWithLong:1];
    }
    return ret;
}

- (NSArray<MenuItem *> *) retrieveAllMenuItems: (NSNumber *)galleryNo
{
    NSArray<MenuItem *> *ret = [MenuItem retrieveAllMenuItemsForGallery: (NSNumber *) galleryNo  context:[self managedObjectContext]];
    
    
    return ret;
}
- (void) removeMenuItemWithKey:(NSString *)moleculekey fromTree:(NSDictionary *)tree
{
    
    // NSString *moleculeKey; // need key from tree when molecule found
    // this call works on the common theater list, not the local list
    
    
    // --todo- [self removeMenuItemKey:moleculekey fromTheaterList:tree];
    
    
    
    //     [self.managedObjectContext deleteObject:molecule];
    [self saveContext];
}

- (MenuItem *) findNextMenuItemForGallery: (NSNumber *) galleryNo afterPosition: (NSNumber *) positionInGallery
{
    MenuItem *ret = [MenuItem findNextMenuItemForGallery: (NSNumber *) galleryNo afterPosition: (NSNumber *) positionInGallery context:[self managedObjectContext]];
    
    return ret;
}
- (NSInteger) getPrevGalleryPositionIdx
{
    currentMenuItemGalleryPositions.location--;
    currentMenuItemGalleryPositions.length++;
    return currentMenuItemGalleryPositions.location;
  
}
- (NSInteger) getNextGalleryPositionIdx
{
    currentMenuItemGalleryPositions.length++;
    return (currentMenuItemGalleryPositions.location + currentMenuItemGalleryPositions.length);
}
- (void) initGalleryPositionsRange: (NSRange) fetchAllRange
{
    currentMenuItemGalleryPositions.location = fetchAllRange.location;
    currentMenuItemGalleryPositions.length = fetchAllRange.length;
}

- (void) logTodaysMenu: (NSString *) caption
{
    NSLog(@"Z5LocalDataController.logTodaysMenu");
    NSLog(@"%@(logTodaysMenu)  count: %ld", caption, (unsigned long)[[self todaysMenuItems] count]);
    for (MenuItem *mItem in [self todaysMenuItems]) {
        // get a list of components for the menu item - json avail, use compiled products
        NSLog(@"(logTodaysMenu)  item: %@", mItem.name);
        
        NSArray<NSDictionary *> *todaysParameters = [self todaysMenuComponents];
        // if there are parameters to check, go to local data for authorization
        // to put in the health-kit database.
        if (0 < [todaysParameters count]) {
            // [localData goHealthData:todaysParameters forDelegate:self];
        }
    }
    NSLog(@"Z5LocalDataController.logTodaysMenu: end");
}

#pragma mark - JSON formatter

- (NSString *)unitsForParameter:(NSString *)paramKeyStr
{
    NSString *ret;
    if ([paramKeyStr isEqualToString:@"sodium"]) {
        ret = @"mg";
    } else if ([paramKeyStr isEqualToString:@"total-fat"]) {
        ret = @"grams";
    } else {
        ret = @"";
    }
    NSLog(@"Z5LocalDataController.unitsForParameter: WHAT IS HERE? key: %@  ret: %@", paramKeyStr, ret);
    return ret;
}

- (NSMutableDictionary *) mergeJsonForUsdaNumbers:(NSDictionary *)usdaDictionary inMenuItem:(MenuItem *)menuItem inContext:(UIView *) screen
{
    NSMutableDictionary *ret = [[NSMutableDictionary alloc] initWithDictionary:[self jsonForUsdaNumbersInMenuItem:menuItem]];
    
    // for every entry in the incoming dictionary, check current menu
    NSEnumerator *enumerator = [usdaDictionary keyEnumerator];
    id key;
    while ((key = [enumerator nextObject])) {
        /* code that uses the returned key - sodium, total-fat*/
        NSString *keyStr = (NSString *)key;
        NSLog(@"Z5LocalDataController.mergeJsonForUsdaNumbers: keyStr: %@", keyStr);
        id value = [usdaDictionary objectForKey:key];
        if (![(NSString *)value isEqualToString:@""]) {
            NSString *valueStr = [NSString stringWithFormat:@"%@%@",(NSString *)value, [self unitsForParameter:keyStr]];
            [ret setObject:valueStr forKey:keyStr];
        }
        NSLog(@"Z5LocalDataController.mergeJsonForUsdaNumbers: ret: %@", ret);
        
        //        if (value) {
        //            [Z5DataController showQuery:@"new or old" message:@"Which?"];
        //        }
    }
    // if parameter is not found, add
    // if parameter is found, pop up a notice dialog 'new' or 'old'
    // update or ignore as directed
    return ret;
}
- (NSDictionary *) jsonForUsdaNumbersInMenuItem:(MenuItem *)menuItem
{
    /*
     * Existing data
     */
    // NSLog(@"Z5LocalDataController.jsonForUsdaNumbersInMenuItem: menuItem: %@", menuItem);
    NSString *usdaNumbers = [menuItem usdaNumbers];
    if (usdaNumbers) {
        if (![usdaNumbers isEqualToString:@""]) {
            NSData *existingUsdaNumbersData = [usdaNumbers dataUsingEncoding:NSUTF8StringEncoding];
            NSError *err_init_json;
            NSObject *extantUsdaJsonObj = [NSJSONSerialization JSONObjectWithData:existingUsdaNumbersData options:NSJSONReadingAllowFragments error:&err_init_json];
            if (!err_init_json) {
                if (extantUsdaJsonObj) {
                    if ([extantUsdaJsonObj isKindOfClass:[NSDictionary class]]) {
                        
                        // NSDictionary *jsonUsdaIn = (NSDictionary *)extantUsdaJsonObj;
                        // NSLog(@"Z5LocalDataController.jsonForUsdaNumbersInMenuItem: jsonUsdaIn: %@", jsonUsdaIn);
                        
                        return (NSDictionary *)extantUsdaJsonObj;
                    } else {
                        NSLog(@"Z5LocalDataController.jsonForUsdaNumbersInMenuItem: class: %@", NSStringFromClass([extantUsdaJsonObj class]));
                        return nil;
                    }
                }
            } else {        // err_init_json YES
                NSLog(@"Z5LocalDataController.vjsonForUsdaNumbersInMenuItem: err_init_json: %@", err_init_json);
                NSLog(@"Z5LocalDataController.jsonForUsdaNumbersInMenuItem: usdaNumbers: %@", usdaNumbers);
            }
        } else {
            NSLog(@"Z5LocalDataController.jsonForUsdaNumbersInMenuItem: no usdaNumbers");
        }
    } else {
        NSLog(@"Z5LocalDataController.jsonForUsdaNumbersInMenuItem: nil usdaNumbers");
    }
    return nil;
}
#pragma mark - Health Kit

- (void) setUseHealthKit:(Boolean)useHealthKit
{
    if (useHealthKit) {
        _usingHealthKit = [[NSNumber alloc] initWithBool:YES];
    } else {
        _usingHealthKit = [[NSNumber alloc] initWithBool:NO];
    }
    NSLog(@"LocalData.setUsingHealthKit: %@", _usingHealthKit);
    if ([_usingHealthKit boolValue]) {
        
        [self getHealthKitAuthorityFromUserDefaults];
        [self setupHealthKit];
        
        [self putHealthKitAuthorityInUserDefaults];
    }
}
-(void) setupHealthKit
{
    if (self.healthStore) {
        NSLog(@"LocalData.setupHealthKit: healthStore all ready set");
    } else if ([HKHealthStore isHealthDataAvailable]) {
        self.healthStore = [[HKHealthStore alloc] init];
        
        // do not pre-query anything, user to authorize as needed
        // need to remove and reinstall to initialize testing
        [self validateHealthKitAuthority];
    }
}

- (void) getAddedAuthorizationToShare: (NSSet *)writeNutrTypes
                          forDelegate: (id<Z5HealthConnectionProtocol>) requestFrom
{
    healthConnectDelegate = requestFrom;
    [self.healthStore requestAuthorizationToShareTypes:writeNutrTypes
                                             readTypes:writeNutrTypes
                                            completion:^(BOOL success, NSError *error) {
        if (!success) {
            NSLog(@"Z5LocalDataController.getAddedAuthorizationToWrite: You didn't allow HealthKit to access these read/write data types. In your app, try to handle this error gracefully when a user decides not to provide access. The error was: %@", error);
            
            return;
        } else {
            NSLog(@"Z5LocalDataController.getAddedAuthorizationToShare: authorization success");
        
            dispatch_async(dispatch_get_main_queue(), ^{
                // Update the user interface based on the current user's health information.
                // with follow two lines: Unbalanced calls to begin/end appearance transitions for <UIViewController
                // further - i even get unbalanced message without these lines
                [self validateHealthKitAuthority];
                [self->healthConnectDelegate updateToAuthorizationOK];
            });
        }
    }];
    NSLog(@"Z5LocalDataController.getAddedAuthorizationToWrite: end");
}
- (void) initNutritionTypes
{
    // NSArray<HKQuantityTypeIdentifier> *qtyTypes
    _hkQuantityTypes = [[NSArray alloc] initWithObjects:
        HKQuantityTypeIdentifierDietaryBiotin,
        HKQuantityTypeIdentifierDietaryCaffeine,
        HKQuantityTypeIdentifierDietaryCalcium,
        HKQuantityTypeIdentifierDietaryCarbohydrates,
        HKQuantityTypeIdentifierDietaryChloride,
        HKQuantityTypeIdentifierDietaryCholesterol,
        HKQuantityTypeIdentifierDietaryChromium,
        HKQuantityTypeIdentifierDietaryCopper,
        HKQuantityTypeIdentifierDietaryEnergyConsumed,
        HKQuantityTypeIdentifierDietaryFatMonounsaturated,
        HKQuantityTypeIdentifierDietaryFatPolyunsaturated,
        HKQuantityTypeIdentifierDietaryFatSaturated,
        HKQuantityTypeIdentifierDietaryFatTotal,
        HKQuantityTypeIdentifierDietaryFiber,
        HKQuantityTypeIdentifierDietaryFolate,
        HKQuantityTypeIdentifierDietaryIodine,
        HKQuantityTypeIdentifierDietaryIron,
        HKQuantityTypeIdentifierDietaryMagnesium,
        HKQuantityTypeIdentifierDietaryManganese,
        HKQuantityTypeIdentifierDietaryMolybdenum,
        HKQuantityTypeIdentifierDietaryNiacin,
        HKQuantityTypeIdentifierDietaryPantothenicAcid,
        HKQuantityTypeIdentifierDietaryPhosphorus,
        HKQuantityTypeIdentifierDietaryPotassium,
        HKQuantityTypeIdentifierDietaryProtein,
        HKQuantityTypeIdentifierDietaryRiboflavin,
        HKQuantityTypeIdentifierDietarySelenium,
        HKQuantityTypeIdentifierDietarySodium,
        HKQuantityTypeIdentifierDietarySugar,
        HKQuantityTypeIdentifierDietaryThiamin,
        HKQuantityTypeIdentifierDietaryVitaminA,
        HKQuantityTypeIdentifierDietaryVitaminB12,
        HKQuantityTypeIdentifierDietaryVitaminB6,
        HKQuantityTypeIdentifierDietaryVitaminC,
        HKQuantityTypeIdentifierDietaryVitaminD,
        HKQuantityTypeIdentifierDietaryVitaminE,
        HKQuantityTypeIdentifierDietaryVitaminK,
        HKQuantityTypeIdentifierDietaryWater,
        HKQuantityTypeIdentifierDietaryZinc,
        nil];

    nutritionTypeCount = [_hkQuantityTypes count];
    for (int j = 0; j < nutritionTypeCount; j++) {
        NSString *thisone = [_hkQuantityTypes[j] description];
        // NSLog(@"LocalData.initNutritionTypes: thisone: %@", thisone);
        nutritionTypes[j] = [[NSString alloc] initWithString:thisone];
    }
}

- (void) validateHealthKitAuthority
{
    int notDetermined = 0;
    int itemDenied = 0;
    int itemAuthorized = 0;
    for (int j = 0; j < nutritionTypeCount; j++) {
        
        NSString *hkQtypeString = nutritionTypes[j];
        HKQuantityType *hkQtype = [HKObjectType quantityTypeForIdentifier:hkQtypeString];
        
        // NSNumber *previousAuthority = [healthKitNutritionAuthorityDict objectForKey:hkQtypeString];
        HKAuthorizationStatus status = [self.healthStore authorizationStatusForType:hkQtype];
        NSNumber *statusNumb = [NSNumber numberWithInt:status];
        NSDate *freshAuthorityDate;
        
        NSMutableDictionary *knownAuthority = [healthKitNutritionAuthorityDict objectForKey:hkQtypeString];
        // TODO: check for knownDict inadequat, check knownDict->value != 0
        if (knownAuthority) {
            NSNumber *previousAuthority = [knownAuthority objectForKey:@"value"];
            NSDate *knownAuthorityDate = [knownAuthority objectForKey:@"data"];
            
            if ([statusNumb isEqualToNumber:previousAuthority]) {
                // TODO: if 0 == 0, then freshDate = nil;
                freshAuthorityDate = knownAuthorityDate;
            } else {
                //            NSDate *authorityDate = [NSDate dateWithTimeIntervalSinceNow:0];
                //            [healthKitNutritionAuthorityDict setObject:authorityDate forKey:healthKitAuthorityKey];
                NSLog(@"LocalData.validateHealthKitAuthority: old auth: %@ new auth: %@", previousAuthority, statusNumb);
                freshAuthorityDate = [NSDate dateWithTimeIntervalSinceNow:0];
            }
        } else {
            freshAuthorityDate = [NSDate dateWithTimeIntervalSinceNow:0];
        }
        NSDictionary *freshAuthorityDict = [[NSDictionary alloc] initWithObjectsAndKeys:statusNumb, @"value", freshAuthorityDate, @"date", nil];
        // [knownAuthority setObject:statusNumb forKey:@"value"];
        // [knownAuthority setObject:freshAuthorityDate forKey:@"date"];
        // [healthKitNutritionAuthorityDict setObject:statusNumb forKey:hkQtypeString];
        [healthKitNutritionAuthorityDict setObject:freshAuthorityDict forKey:hkQtypeString];
        
        switch (status) {
            case HKAuthorizationStatusNotDetermined:
                // NSLog(@"LocalData.validateHealthKitAuthority: %@ not determined", hkQtypeString);
                notDetermined++;
                break;
            case HKAuthorizationStatusSharingDenied:
                // NSLog(@"LocalData.validateHealthKitAuthority: %@ denied", hkQtypeString);
                itemDenied++;
                break;
            case HKAuthorizationStatusSharingAuthorized:
                // NSLog(@"LocalData.validateHealthKitAuthority: %@ authorized", hkQtypeString);
                itemAuthorized++;
                break;
        }       // end switch
    }           // end for
    NSLog(@"LocalData.validateHealthKitAuthority: notDetermined: %d  itemDenied: %d  itemAuthorized: %d", notDetermined, itemDenied, itemAuthorized);
}
- (void) putHealthKitAuthorityInUserDefaults
{
    NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
    
    [userDefaults setObject:healthKitNutritionAuthorityDict forKey:healthKitAuthorityKey];
    
    [userDefaults synchronize];
  
}
/*
 *  this method updates the global dictionary 'healthKitNutritionAuthorityDict' 
 * from user defaults.
 */
- (void) getHealthKitAuthorityFromUserDefaults
{
    NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
    
    [userDefaults synchronize];
    
    NSDictionary *hkUd = [userDefaults dictionaryForKey:healthKitAuthorityKey];
    
    NSLog(@"LocalData.getHealthKitAuthorityFromUserDefaults: prior on-board count: %ld user-defaults: %@", (unsigned long)[healthKitNutritionAuthorityDict count], hkUd);
    
    Boolean hkDictionaryEmpty = (0 == [healthKitNutritionAuthorityDict count]);
    if (0 < [hkUd count]) {
        for (int j = 0; j < nutritionTypeCount; j++) {
            NSString *hkQtypeString  = nutritionTypes[j].description;
            // Boolean stat = NO;
            NSDictionary *authorityInfo;
            NSNumber *statNumb;
            // HKQuantityType *hkQtype = [HKObjectType quantityTypeForIdentifier:hkQtypeString];
            if (!hkDictionaryEmpty) {
                // NSObject* priorAuthority = [healthKitNutritionAuthorityDict objectForKey:hkQtypeString];
                authorityInfo = [healthKitNutritionAuthorityDict objectForKey:hkQtypeString];
                statNumb = [authorityInfo objectForKey:@"@value"];
                // statNumb = (NSNumber *)priorAuthority;
                // stat = [priorAuthNumb boolValue];
            }
            // NSLog(@"LocalData.getHealthKitAuthorityFromUserDefaults: stat: %@", ( stat ? @"true" : @"false"));
            
            // NSObject* nextAuthority = [hkUd objectForKey:hkQtypeString];
            // NSNumber *nextAuthNumb = (NSNumber *)nextAuthority; /* 0 - no query, 1 - denied, 2 - shared, ... */
            NSMutableDictionary* userDefInfoDict = [hkUd objectForKey:hkQtypeString];
            NSNumber *udAuthNumb = [userDefInfoDict objectForKey:@"value"]; /* 0 - no query, 1 - denied, 2 - shared, ... */
            // Boolean next = [nextAuthNumb boolValue];
            // NSLog(@"LocalData.getHealthKitAuthorityFromUserDefaults: next: %@", ( next ? @"true" : @"false"));
//  RESTART HERE - healthKitNutritionAuthorityDict to be dictionary of dictionary, not auth values
            if ((nil != udAuthNumb) && (nil != statNumb) && (![udAuthNumb isEqualToNumber:statNumb])) {
                NSLog(@"LocalData.getHealthKitAuthorityFromUserDefaults:  type: %@ updated: new auth: %@", hkQtypeString, udAuthNumb);
                NSDate *authChangeDate = [NSDate dateWithTimeIntervalSinceNow:0];
                [userDefInfoDict setObject:authChangeDate forKey:@"date"];

//               if (next && !stat) {
//                    NSLog(@"LocalData.getHealthKitAuthorityFromUserDefaults: adding %@:%@", hkQtypeString, ( next ? @"true" : @"false"));
//                } else if (!next && stat) {
//                    NSLog(@"LocalData.getHealthKitAuthorityFromUserDefaults: removing %@", hkQtypeString);
//                }
            }
            if (userDefInfoDict) {
                // replace previous dictionary with dictionary from u/d, updated with date-of-change,
                // if applicable
                [healthKitNutritionAuthorityDict setObject:userDefInfoDict forKey:hkQtypeString];
            }
        }
    } else {
        NSLog(@"LocalData.getHealthKitAuthorityFromUserDefaults: no %@ dictionary entries in user defaults", healthKitAuthorityKey);
    }
}
- (NSNumber *) askAgain: (HKQuantityType *) quantityType
{
    __block NSNumber *statusFlag = [NSNumber numberWithBool:NO];
    NSSet *writeDataTypes = [NSSet setWithObjects:quantityType, nil];
    NSSet *readDataTypes = [[NSSet alloc] init];
    [self.healthStore requestAuthorizationToShareTypes:writeDataTypes readTypes:readDataTypes completion:^(BOOL success, NSError *error) {
        if (!success) {
            NSLog(@"Z5LocalDataController.askAgain: The error was: %@", error);
            return;
        } else {
            NSLog(@"Z5LocalDataController.askAgain: authorization success");
            statusFlag = [NSNumber numberWithBool:YES];
        }
        
        dispatch_async(dispatch_get_main_queue(), ^{
            [self->healthConnectDelegate updateToAuthorizationOK];
            // Update the user interface based on the current user's health information.
            // this is inside a completion handler
            /* [self updateUsersAgeLabel];
             [self updateUsersHeightLabel];
             [self updateUsersWeightLabel];  */
        });
    }];
    return statusFlag;
}

#pragma mark - HealthKit Permissions

// Returns the types of data that Fit wishes to write to HealthKit.
- (NSSet *)dataTypesToWrite {

    __block NSMutableSet *retSet = [[NSMutableSet alloc] init];

    [healthKitNutritionAuthorityDict enumerateKeysAndObjectsUsingBlock:^(id key, id object, BOOL *stop) {
        NSString *keyString = (NSString *)key;
        NSNumber *objectNumber = (NSNumber *)object;
        Boolean objBoolean = [objectNumber boolValue];
        if (objBoolean) {
            HKQuantityType *keyHkQtype = [HKObjectType quantityTypeForIdentifier:keyString];
            [retSet addObject:keyHkQtype];
        }
    }];
    // empty sets to check-authorization crashes app
    if (0 == [retSet count]) {
        HKQuantityType *sodiumType = [HKObjectType quantityTypeForIdentifier:HKQuantityTypeIdentifierDietarySodium];
        [retSet addObject:sodiumType];
    }
    return retSet;
}
 - (NSArray<HKQuantityType *> *)typesForWriting
{
    __block NSMutableArray *retArray = [[NSMutableArray alloc] init];
    [healthKitNutritionAuthorityDict enumerateKeysAndObjectsUsingBlock:^(id key, id object, BOOL *stop) {
        NSString *keyString = (NSString *)key;
        NSNumber *objectNumber = (NSNumber *)object;
        Boolean objBoolean = [objectNumber boolValue];
        if (objBoolean) {
            HKQuantityType *keyHkQtype = [HKObjectType quantityTypeForIdentifier:keyString];
            [retArray addObject:keyHkQtype];
        }
    }];
    return retArray;
}
- (NSArray<HKQuantityType *> *)allHkTypes
{
    NSMutableArray<HKQuantityType *> *returHkArray = [[NSMutableArray alloc] init];

    for (NSString *param in [self establishNutritionParameters]) {
        HKQuantityType *hkQtype = [HKObjectType quantityTypeForIdentifier:param];
        [returHkArray addObject:hkQtype];
    }
    return returHkArray;
}
- (NSMutableArray<NSString *> *)establishNutritionParameters
{
    NSMutableArray<NSString *> *availableNutritionParamArray = [[NSMutableArray alloc] init];
    
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietarySodium];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryBiotin];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryCaffeine];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryCalcium];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryCarbohydrates];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryChloride];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryCholesterol];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryChromium];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryCopper];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryEnergyConsumed];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryFatMonounsaturated];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryFatPolyunsaturated];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryFatSaturated];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryFatTotal];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryFiber];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryFolate];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryIodine];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryIron];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryMagnesium];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryManganese];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryMolybdenum];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryNiacin];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryPantothenicAcid];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryPhosphorus];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryPotassium];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryProtein];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryRiboflavin];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietarySelenium];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietarySugar];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryThiamin];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryVitaminA];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryVitaminB12];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryVitaminB6];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryVitaminC];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryVitaminD];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryVitaminE];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryVitaminK];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryWater];
    [availableNutritionParamArray addObject:HKQuantityTypeIdentifierDietaryZinc];

    return availableNutritionParamArray;
}


- (NSNumber *) checkTypeAuthorization: (HKQuantityType *) quantityType
{
    bool doDebug = NO;
    
    NSString *hkQtypeString  = quantityType.description;
    // NSNumber *knownAuthStatus = [healthKitNutritionAuthorityDict objectForKey:hkQtypeString];
    NSMutableDictionary *knownAuthStatusDict = [healthKitNutritionAuthorityDict objectForKey:hkQtypeString];
    NSNumber *knownAuthStatus = [knownAuthStatusDict objectForKey:@"value"];
    NSDate *knownAuthStatusDate = [knownAuthStatusDict objectForKey:@"date"];
    if (doDebug) NSLog(@"LocalData.checkTypeAuthorization: knownAuthStatus: for %@:  %@", hkQtypeString, knownAuthStatus);
//    NSLog(@"LocalData.checkTypeAuthorization: healthKitNutritionAuthorityDict: %@", healthKitNutritionAuthorityDict);
    NSInteger knownAuthStatusInt = [knownAuthStatus integerValue];
    if (doDebug) NSLog(@"LocalData.checkTypeAuthorization: type: %@:previous auth: %ld, date: %@", hkQtypeString, (long)[knownAuthStatus integerValue], [knownAuthStatusDate description]);


    NSInteger authStatus = [self.healthStore authorizationStatusForType:quantityType];

    if (authStatus != knownAuthStatusInt) {
        if (doDebug) NSLog(@"LocalData.checkTypeAuthorization: AUTH CHANGE: was %ld  now %ld", (long)knownAuthStatusInt, (long)authStatus);
    }
    switch (authStatus) {
        case HKAuthorizationStatusSharingAuthorized:
            if (doDebug) NSLog(@"Z5LocalDataController.checkTypeAuthorization: %@ HKAuthorizationStatusSharingAuthorized", [quantityType description]);
            break;
        case HKAuthorizationStatusNotDetermined:
            if (doDebug) NSLog(@"Z5LocalDataController.checkTypeAuthorization: %@ HKAuthorizationStatusNotDetermined", [quantityType description]);
            break;
        case HKAuthorizationStatusSharingDenied:
            if (doDebug) NSLog(@"Z5LocalDataController.checkTypeAuthorization: %@ HKAuthorizationStatusSharingDenied", [quantityType description]);
            break;
        case HKErrorAuthorizationDenied:
            if (doDebug) NSLog(@"Z5LocalDataController.checkTypeAuthorization: %@ HKErrorAuthorizationDenied", [quantityType description]);
            break;
        case HKErrorAuthorizationNotDetermined:
            if (doDebug) NSLog(@"Z5LocalDataController.checkTypeAuthorization: %@ HKErrorAuthorizationNotDetermined", [quantityType description]);
            break;
    }
    NSNumber *ret = [NSNumber numberWithInteger:authStatus];
    return ret;
}

// This method takes an array of dictionary items, one item per nutrition component,
// dictionary elements are component-Name-Key (input to authority check), and
// componen-Authority-key, added if it is not there already.  The array and dictionary
// input are simple, this is copied to mutable elements.
//
// Update: include the last authority change time.  The array of dictionaries is saved to user-defaults
// at synchronization.
//
- (NSMutableArray<NSMutableDictionary *> *) annotateAuthority:(NSArray *)componentArray
{
//    // log authority-dictionary information
//    [healthKitNutritionAuthorityDict enumerateKeysAndObjectsUsingBlock:^(id key, id object, BOOL *stop) {
//        NSString *keyString = (NSString *)key;
//        NSNumber *objectNumber = (NSNumber *)object;
//        Boolean objBoolean = [objectNumber boolValue];
//        if (objBoolean) {
//            NSLog(@"LocalData.annotateAuthority: key: %@  Authorized", keyString);
//        } else {
//            NSLog(@"LocalData.annotateAuthority: key: %@  Denied", keyString);
//        }
//    }];
//    // END -- log authority-dictionary information

    
    NSMutableArray *ret = [[NSMutableArray alloc] init];
    
    for (NSDictionary *component in componentArray) {
        NSString *componentType = [component objectForKey:[Z5LocalDataController componentNameKey]];
        if (componentType) {
            NSString *fullyQualifiedCompoName = [@"HKQuantityTypeIdentifierDietary" stringByAppendingString:componentType];
            HKQuantityType *rowQuantityType = [HKObjectType quantityTypeForIdentifier:fullyQualifiedCompoName];
            
            // get new authority info
            NSNumber *shareOK = [self checkTypeAuthorization:rowQuantityType];
            NSMutableDictionary *withAuthMarkDict = [[NSMutableDictionary alloc] initWithDictionary:component];
            [withAuthMarkDict setValue:shareOK forKey:[Z5LocalDataController componentAuthorityKey]];

            NSDate *authorityDate = [NSDate dateWithTimeIntervalSinceNow:0];        // TODO

            [withAuthMarkDict setValue:authorityDate forKey:[Z5LocalDataController componentAuthorityDateKey]];

            [ret addObject:withAuthMarkDict];
        }
    }
    return ret;
}

#pragma mark - Writing HealthKit Data
- (Boolean) goHealthData:(NSArray<NSDictionary *> *) parametersForHK forDelegate: (id<Z5HealthConnectionProtocol>)jingo
{
    healthConnectDelegate = jingo;
    
    Boolean ret = [HKHealthStore isHealthDataAvailable];
    if (ret) {
        NSLog(@"LocalData.goHealthData: addMenuItemOnToday: HKHealthStore is available");
        [[[Z5DataController sharedInstance] localDataController] setupHealthKit];
        
        for (NSDictionary *datum in parametersForHK) {
            NSLog(@"LocalData.goHealthData: datum: %@", datum);
            
            NSString *nutriType = [datum objectForKey:[Z5LocalDataController componentNameKey]];
            NSString *hkTypeStr = [@"HKQuantityTypeIdentifierDietary" stringByAppendingString:nutriType];
            HKQuantityType *hkType = [HKQuantityType quantityTypeForIdentifier:hkTypeStr];
            HKUnit *massUnit = [HKUnit unitFromString:@"g"];
            HKUnit *energyUnit = [HKUnit unitFromString:@"cal"];
            
            HKUnit *hkUnit = nil;
            NSString *nutriValue = [datum objectForKey:componentValueKey];
            NSLog(@"LocalData.goHealthData: nutriValue: %@", nutriValue);
            NSArray<NSString *> *pieces = [nutriValue componentsSeparatedByString:@" "];
            // HKUnit *hkUnit = nil;
            float quantityScalar = [pieces[0] floatValue];
            if ([hkType isCompatibleWithUnit:energyUnit])
            {
                if ([@"cal" isEqualToString:pieces[1]]) {
                    HKMetricPrefix microPrefix = HKMetricPrefixNone;
                    hkUnit = [HKUnit jouleUnitWithMetricPrefix:microPrefix];
                }
            } else if ([hkType isCompatibleWithUnit:massUnit]){
                if ([@"mcg" isEqualToString:pieces[1]]) {
                    HKMetricPrefix microPrefix = HKMetricPrefixMicro;
                    hkUnit = [HKUnit gramUnitWithMetricPrefix:microPrefix];
                } else if ([@"mg" isEqualToString:pieces[1]]) {
                    HKMetricPrefix milliPrefix = HKMetricPrefixMilli;
                    hkUnit = [HKUnit gramUnitWithMetricPrefix:milliPrefix];
                }
            }
            HKQuantity *hkQuantity = [HKQuantity quantityWithUnit:hkUnit doubleValue:quantityScalar];
            
            NSDictionary *opQueueIn = [[NSDictionary alloc] initWithObjectsAndKeys:hkType, @"HKtype", hkQuantity, @"HKquantity", nil];
            [healthKitOpQueue addOperation:[[NSInvocationOperation alloc] initWithTarget:self selector:@selector(tryHealthStore:) object:opQueueIn]];
            
        }
        [healthKitOpQueue waitUntilAllOperationsAreFinished];
        NSLog(@"LocalData.goHealthData: done waiting");
    }
    return ret;
}

- (void) tryHealthStore:(id)arg
{
    NSDictionary *inputVars = arg;
    
    HKQuantityType *hkType = [inputVars objectForKey:@"HKtype"];
    HKQuantity *hkQuantity = [inputVars objectForKey:@"HKquantity"];
    [self saveQuantityToHealthStore:hkType amount:hkQuantity];
}

- (void) saveQuantityToHealthStore:(HKQuantityType *)quantityType amount:(HKQuantity *)quantityAmount
{
    NSDate *now = [NSDate date];
    // Boolean isSuccess = NO;
    HKQuantitySample *quantitySample = [HKQuantitySample quantitySampleWithType:quantityType quantity:quantityAmount startDate:now endDate:now];
    NSInteger authStatus = [self.healthStore authorizationStatusForType:quantityType];
    NSString *quantityAuthority = @"none";
    switch (authStatus) {
        case HKAuthorizationStatusSharingAuthorized:
            NSLog(@"Z5LocalDataController.saveQuantityToHealthStore: HKAuthorizationStatusSharingAuthorized");
            quantityAuthority = @"HKAuthorizationStatusSharingAuthorized";
            break;
        case HKAuthorizationStatusNotDetermined:
            NSLog(@"Z5LocalDataController.saveQuantityToHealthStore: HKAuthorizationStatusNotDetermined");
            quantityAuthority = @"HKAuthorizationStatusNotDetermined";
            break;
        case HKAuthorizationStatusSharingDenied:
            NSLog(@"Z5LocalDataController.saveQuantityToHealthStore: HKAuthorizationStatusSharingDenied");
            quantityAuthority = @"HKAuthorizationStatusSharingDenied";
            break;
        case HKErrorAuthorizationDenied:
            NSLog(@"Z5LocalDataController.saveQuantityToHealthStore: HKErrorAuthorizationDenied");
            quantityAuthority = @"HKErrorAuthorizationDenied";
            break;
        case HKErrorAuthorizationNotDetermined:
            NSLog(@"Z5LocalDataController.saveQuantityToHealthStore: HKErrorAuthorizationNotDetermined");
            quantityAuthority = @"HKErrorAuthorizationNotDetermined";
            break;
    }
    
    NSLog(@"Z5LocalDataController.saveQuantityToHealthStore: type: %@  authority: %@  quantitySample: %@", quantityType, quantityAuthority, quantitySample);

    switch (authStatus) {
        case HKAuthorizationStatusSharingAuthorized:
        {
            [self.healthStore saveObject:quantitySample withCompletion:^(BOOL success, NSError *error) {
                if (!success) {
                    NSLog(@"An error occured saving the quantity sample %@. In your app, try to handle this gracefully. The error was: %@.", quantitySample, error);
                    // abort();
                    NSLog(@"Z5LocalDataController.saveQuantityToHealthStore: ERR code: %ld", (long)error.code);
                    return;
                }
                NSLog(@"Z5LocalDataController.saveQuantityToHealthStore: success with %@", quantityType);
                // [healthConnectDelegate healthQuantityTypeData:quantityType success:YES];
//                dispatch_async(dispatch_get_main_queue(), ^{
//                    [healthConnectDelegate healthQuantityTypeData:quantityType success:YES];
//                });
            }];
        }
            break;
/*     case HKAuthorizationStatusNotDetermined:
            NSLog(@"Z5LocalDataController.saveQuantityToHealthStore: HKAuthorizationStatusNotDetermined");
            [healthConnectDelegate healthQuantityTypeData:quantityType success:NO];
            break;
       case HKAuthorizationStatusSharingDenied:
            NSLog(@"Z5LocalDataController.saveQuantityToHealthStore: HKAuthorizationStatusSharingDenied");
            [healthConnectDelegate healthQuantityTypeData:quantityType success:NO];
            break;
        case HKErrorAuthorizationDenied:
            NSLog(@"Z5LocalDataController.saveQuantityToHealthStore: HKErrorAuthorizationDenied");
            [healthConnectDelegate healthQuantityTypeData:quantityType success:NO];
            break;
        case HKErrorAuthorizationNotDetermined:
            NSLog(@"Z5LocalDataController.saveQuantityToHealthStore: HKErrorAuthorizationNotDetermined");
            [healthConnectDelegate healthQuantityTypeData:quantityType success:NO];
            break;
  */
    }
}

+ (HKQuantity *) hkQuantityForString: (NSString *) quantityDescript
{
    NSArray<NSString *> *pieces = [quantityDescript componentsSeparatedByString:@" "];
    HKUnit *hkUnit = nil;
    float quantityScalar = [pieces[0] floatValue];
    // NSLog(@"Z5LocalDataController.hkQuantityForString: quantityScalar: %3.2f", quantityScalar);
    
    if ([@"mcg" isEqualToString:pieces[1]]) {
        HKMetricPrefix microPrefix = HKMetricPrefixMicro;
        hkUnit = [HKUnit gramUnitWithMetricPrefix:microPrefix];
    } else if ([@"mg" isEqualToString:pieces[1]]) {
        HKMetricPrefix milliPrefix = HKMetricPrefixMilli;
        hkUnit = [HKUnit gramUnitWithMetricPrefix:milliPrefix];
    }
    HKQuantity *hkQuantity = [HKQuantity quantityWithUnit:hkUnit doubleValue:quantityScalar];
    //double quantDbl = [hkQuantity doubleValueForUnit:[HKUnit gramUnit]];
    //NSLog(@"Z5LocalDataController.hkQuantityForString: quantDbl: %f", quantDbl);
    
    return hkQuantity;
}

#pragma mark - Email Credentials / User Defaults

- (void) putCredentialsInUserDefaults
{
    NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];

//    NSString *enteredUsername = [[Z5DataController sharedInstance] remoteDataController].emailDataController.username;
//    [userDefaults setObject:enteredUsername forKey:@"username"];
//    NSString *enteredPassword = [[Z5DataController sharedInstance] remoteDataController].emailDataController.password;
//    [userDefaults setObject:enteredPassword forKey:@"password"];

    [userDefaults synchronize];

}
- (void) fetchCredentialsFromUserDefaults
{
    // NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
    
//    [[Z5DataController sharedInstance] remoteDataController].emailDataController.username = [userDefaults stringForKey:@"username"];
//    [[Z5DataController sharedInstance] remoteDataController].emailDataController.password = [userDefaults stringForKey:@"password"];
    
}

#pragma mark - EmailMessage Data
//- (EmailMessage *) findEmailMessageWithRandomkey: (NSString *)randomkey
//{
//    NSLog(@"LocalData.findEmailMessageWithRandomkey");
//    EmailMessage *ret = [EmailMessage findEmailMessageWithKey:randomkey
//                                          context:[self managedObjectContext]];
//    
//    return ret;
//}

// - (EmailMessage *) findOrCreateEmailMessageWithRandomkey: (NSString *)randomkey
// {
//     NSLog(@"LocalData.findOrCreateEmailMessageWithRandomkey");
//     EmailMessage *ret = [EmailMessage findOrCreateEmailMessageWithRandomkey:randomkey
//                                                                     context:[self managedObjectContext]];
//     
//     return ret;
// }
// - (EmailMessage *) findOrCreateEmailMessageWithUID: (NSNumber *)uidkey
// {
//     NSLog(@"LocalData.findOrCreateEmailMessageWithUID");
//     EmailMessage *ret = [EmailMessage findOrCreateEmailMessageWithUID:uidkey
//                                                         context:[self managedObjectContext]];
//     
//     return ret;
// }
- (EmailMessage *) findOrCreateEmailMessageWithFileIdentification: (NSString *)googlefileid
{
    NSLog(@"LocalData.findEmailMessageWithFileIdentification");
    EmailMessage *ret = [EmailMessage findOrCreateEmailMessageWithFileIdentification:googlefileid
                                                         context:[self managedObjectContext]];
    
    return ret;
}
- (EmailMessage *) findEmailMessageWithFileIdentification:(NSString *) googlefileid
{
    NSArray *msgs = [EmailMessage emailMessageWithFileid:googlefileid
                                                                             context:[self managedObjectContext]];
    EmailMessage *ret;
    if (nil == msgs) {
        ret = nil;
    } else {
       ret = [msgs objectAtIndex:0];
    }
    return ret;
}
- (NSArray *) retrieveAllEmailMessages
{
    
    NSManagedObjectContext *moc = [self managedObjectContext];
    NSEntityDescription *entityDescription = [NSEntityDescription
                                              entityForName:@"EmailMessage" inManagedObjectContext:moc];
    NSFetchRequest *request = [[NSFetchRequest alloc] init];
    [request setEntity:entityDescription];
    
    NSError *error;
    NSArray *objects = [self.managedObjectContext executeFetchRequest:request error:&error];
    
    return objects;
}
//- (void) removeEmailMessageWithKey:(NSString *)moleculekey fromTree:(NSDictionary *)tree
//{
//    
//    // NSString *moleculeKey; // need key from tree when molecule found
//    // this call works on the common theater list, not the local list
//    
//    
//    // --todo- [self removeEmailMessageKey:moleculekey fromTheaterList:tree];
//    
//    
//    
//    //     [self.managedObjectContext deleteObject:molecule];
//    [self saveContext];
//}

- (Boolean) deleteEmailMessageWithFileIdentification:(NSString *)googlefileid
{
    return [EmailMessage deleteEmailMessageWithFileIdentification:googlefileid
                                                         context:[self managedObjectContext]];
}
- (BOOL) fetchEmails {
    NSManagedObjectContext *context = [self managedObjectContext];
    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
    // Configure the request's entity, and optionally its predicate.
    NSSortDescriptor *sortDescriptor = [[NSSortDescriptor alloc] initWithKey:@"date" ascending:YES];
    NSArray *sortDescriptors = [[NSArray alloc] initWithObjects:sortDescriptor, nil];
    [fetchRequest setSortDescriptors:sortDescriptors];
    
    NSFetchedResultsController *controller = [[NSFetchedResultsController alloc]
                                              initWithFetchRequest:fetchRequest
                                              managedObjectContext:context
                                              sectionNameKeyPath:nil
                                              cacheName:@"TodaysMenu"];
    NSError *error;
    BOOL success = [controller performFetch:&error];
    return success;
}


#pragma mark - Write Defaults

- (void) examineDbMenuItems
{
    NSNumber *galleryChoice = [NSNumber numberWithInt:1];
    NSArray *objects = [self retrieveAllMenuItems:galleryChoice];
    for (NSManagedObject *menuItem in objects) {
        MenuItem *dbMenuItem = (MenuItem *)menuItem;
        NSLog(@"RemoteData.fillMenuItemList: menuItem into list: %@", [dbMenuItem name]);
    }
}
- (void) putMenuItemOnToday: (MenuItem *)focusMenuItem
{
    if (!focusMenuItem) {
        NSLog(@"Z5LocalData.putMenuItemOnToday: FAIL, nil input");
        return;
    }
    if (!_todaysMenuItems) {
        _todaysMenuItems = [[NSMutableArray alloc] init];
        NSLog(@"Z5LocalData.putMenuItemOnToday: todays-menu-items array created");
    }
    [_todaysMenuItems addObject:focusMenuItem];
}
- (void) putTodaysMenuInUserDefaults
{
    NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
    
    NSMutableArray *menuItemKeys = [[NSMutableArray alloc] init];
    for (NSManagedObject *menuItem in _todaysMenuItems) {
        MenuItem *dbMenuItem = (MenuItem *)menuItem;
        [menuItemKeys addObject:[dbMenuItem randomkey]];
        // NSLog(@"RemoteData.fillMenuItemList: menuItem into list: %@", [dbMenuItem name]);
    }
    [userDefaults setObject:menuItemKeys forKey:proposedMenuItemList];
    
    [userDefaults synchronize];
}
- (void) initializeTodaysMeal
{
    _todaysMeal = nil;
}
- (void) clearTodaysMenuItems
{
    NSLog(@"Z5LocalData.clearTodaysMenuItems");
    [_todaysMenuItems removeAllObjects];
}
- (NSArray<NSDictionary *> *) mealComponents: (Meal *)meal
{
    NSMutableArray<NSDictionary *> *totals = [[NSMutableArray alloc] init];
    for (MenuItem *mItem in [meal containedItem]) {
        // get a list of components for the menu item - json avail, use compiled products
        NSDictionary *currentParameters = [self jsonForUsdaNumbersInMenuItem:mItem];
        NSArray<NSDictionary *> *usdaParameterArray = [currentParameters objectForKey:@"usdaNumbers"];
        
        [totals addObjectsFromArray:usdaParameterArray];
    }               // for each item in todays menu
    return totals;
}
- (NSArray<NSDictionary *> *) todaysMenuComponents
{
    NSMutableArray<NSDictionary *> *totals = [[NSMutableArray alloc] init];
    for (MenuItem *mItem in [self todaysMenuItems]) {
        // get a list of components for the menu item - json avail, use compiled products
        NSDictionary *currentParameters = [self jsonForUsdaNumbersInMenuItem:mItem];
        
        if (currentParameters) {
            NSArray<NSDictionary *> *usdaParameterArray = [currentParameters objectForKey:@"usdaNumbers"];
            [totals addObjectsFromArray:usdaParameterArray];
        } else {
            NSLog(@"LocalData.todaysMenuComponents: no parameters for %@", mItem.name);
        }
    }               // for each item in todays menu
    
    // get authorized parameters
    NSArray<NSMutableDictionary*> *annotatedArray;
    if (0 < [totals count]) {
        annotatedArray = [[[Z5DataController sharedInstance]
                           localDataController]
                          annotateAuthority:totals];
        for (NSDictionary *entr in annotatedArray) {
            NSString *name = [entr objectForKey:[Z5LocalDataController componentNameKey]];
            NSString *quantStr = [entr objectForKey:[Z5LocalDataController componentValueKey]];
            HKQuantity *quant = [Z5LocalDataController hkQuantityForString:quantStr];
            double quantDbl = 0.0;
            if ([quant isCompatibleWithUnit:[HKUnit gramUnit]]) {
                quantDbl = [quant doubleValueForUnit:[HKUnit gramUnit]];
            } else if ([quant isCompatibleWithUnit:[HKUnit jouleUnit]]) {
                quantDbl = [quant doubleValueForUnit:[HKUnit jouleUnitWithMetricPrefix:HKMetricPrefixMicro]];
            }
            NSNumber *authority = [entr objectForKey:[Z5LocalDataController componentAuthorityKey]];
            Boolean authFlag = [ authority boolValue];
            
            if (0.0 < quantDbl) {
                if (authFlag) {
                    // NSLog(@"LocalData.todaysMenuComponents: have authority for %@", name);
                } else {
                    // NSLog(@"LocalData.todaysMenuComponents: no authority for %@, entr: %@", name, entr);
                    
                }
            } else {
                NSLog(@"LocalData.todaysMenuComponents: no quantity for %@", name);
            }
        }
    } else {
        NSLog(@"LocalData.todaysMenuComponents: no totals for todays menu");
    }
    
    return annotatedArray;
}
- (void) logEmailMessageAndMenuItemList
{
    NSArray *emObjects = [[[Z5DataController sharedInstance] localDataController] retrieveAllEmailMessages];
    for (NSManagedObject *emailMessage in emObjects) {
        EmailMessage *dbEmailMessage = (EmailMessage *)emailMessage;
        NSLog(@"LocalData.logEmailMessageAndEmailMessageList: menuItem into list: %@", [dbEmailMessage subject]);
    }
    
    NSNumber *galleryChoice = [NSNumber numberWithInt:1];
    NSArray *objects = [[[Z5DataController sharedInstance] localDataController] retrieveAllMenuItems:galleryChoice];
    for (NSManagedObject *menuItem in objects) {
        MenuItem *dbMenuItem = (MenuItem *)menuItem;
        NSLog(@"LocalData.logEmailMessageAndMenuItemList: menuItem into list: %@", [dbMenuItem name]);
    }
}


#pragma mark - Read Defaults

- (int) getBestAvailableUserDefaultMethod
{
    int ret = 0;
    
    NSUserDefaults *udef = [NSUserDefaults standardUserDefaults];
    
    NSLog(@"LocalData.getBestAvailableUserDefaultMethod: udef: %@", udef);
    
    NSArray *theaterMenuArray = [udef arrayForKey:healthDataAuthority];
    
    NSDictionary *theaterItemDictionary = [udef dictionaryForKey:showTheaterItem];
    
    NSString *theaterVersion1 = [udef stringForKey:showTheaterVersion1];
    
    if (theaterMenuArray) {
        // if healthDataAuthority is a array
        ret = 1;
    } else if (theaterItemDictionary) {
        // if showTheaterItem is a dictionary
        ret = 2;
    } else if (theaterVersion1) {
        // if showTheaterVerion1 is a string
        ret = 3;
    }
    // this is nuts
    NSLog(@"LocalData.getBestAvailableUserDefaultMethod: ret: %d", ret);
    return ret;
}

- (NSMutableArray *) createTodaysMenuFromUserDefaults
{
    NSUserDefaults *udef = [NSUserDefaults standardUserDefaults];
    NSArray *proposedMenuItemArray = [udef arrayForKey:proposedMenuItemList];
    
    if (!_todaysMenuItems) {
        _todaysMenuItems = [[NSMutableArray alloc] init];
    }

    if (proposedMenuItemArray) {
        // NSLog(@"LocalData.createTodaysMenuFromUserDefaults: %@: %@", proposedMenuItemList, proposedMenuItemArray);
        // ret = [[NSMutableArray alloc] init];
        for (NSString *menuItemRandomkey in proposedMenuItemArray) {
            MenuItem *dbMenuItem = [self findMenuItemWithRandomkey:menuItemRandomkey];
            [_todaysMenuItems addObject:dbMenuItem];
            // NSLog(@"LocalData.createTodaysMenuFromUserDefaults: adding %@", dbMenuItem.name);
        }
    }
    
    NSMutableArray *ret = nil;
    return ret;
    
}
// - (NSDictionary *) getMenuItemEntryForEmpty
// {
//     NSDictionary *ret;
//     
//     NSDictionary *theaterDictionarySingleItem = [[NSUserDefaults standardUserDefaults] dictionaryForKey:showTheaterItem];
//     if (0 < [theaterDictionarySingleItem count]) {
//         ret = [[NSMutableDictionary alloc] init];
//         
//         NSString *menuItemsList = [theaterDictionarySingleItem objectForKey:@"data"]; // 'data' works here
//         
//         NSLog(@"LocalData.getMenuItemEntryForEmpty: menuItemsList: %@", menuItemsList);
//         
//         NSDictionary *moleculeEntry = [self createMenuItemFromUserDefaults:menuItemsList];
//         
//         ret = [self generateTrivialCollection:moleculeEntry];
//     }
//     return ret;
// }
// - (NSMutableDictionary *) createMenuItemFromUserDefaults: (NSString *)menuItemsList
// {
//     NSMutableDictionary * ret;
//     
//     if (![[menuItemsList class] isSubclassOfClass:[NSString class]]) {
//         // this was necessary to get up to write
//         // new user profile. NSDictionary will in will blow up.
//         return nil;
//     }
//     
//     // get Dictionary in user devault for
//     NSArray *menuItemArray = [[NSUserDefaults standardUserDefaults] arrayForKey:menuItemsList];
//     NSLog(@"LocalData.createMenuItemFromUserDefaults: for %@ dictionary: %@", menuItemsList, menuItemArray);
//     if (menuItemArray) {
//         for (MenuItem *miTem in menuItemArray) {
//             NSLog(@"LocalData.createMenuItemFromUD: miTem: %@", miTem);
//         }
//         
//         /*
//         NSString *theatMolecRandomkey = (NSString *)[theaterMenuItemDictionary objectForKey:@"randomkey"];
//         
//         // do NOT CREATE at this point
//         MenuItem *theaterDbMenuItem = [self findMenuItemWithRandomkey:theatMolecRandomkey];
//         
//         if (theaterDbMenuItem) {
//             
//             
//             Z6Ma2ChemistryMenuItem *molec = [[Z6Ma2ChemistryMenuItem alloc] initWithDbMolec:theaterDbMenuItem];
//             [molec provideDelegate:self];  // originally 'self',anged to 'nil' - will affect textures, no dictionary - dump at GL_TRIANGLES
//             GLKMatrix4 moleculeOrientation = GLKMatrix4Identity;
//             [molec placeAtPosition:theatMolecPosit andOrientation:moleculeOrientation];
//             [molec createAtomCollection];
//             
//             // [[theaterMenuItemDictionary objectForKey:@"molecule-data"] addObject:molec];
//             ret = [[NSMutableDictionary alloc] init];
//             [ret setObject:menuItemsList forKey:@"molecule-key"];
//             [ret setObject:molec forKey:@"molecule-data"];
//             
//         } else {
//             NSLog(@"LocalData.createMenuItemFromUserDefaults: no local molecule for %@", theatMolecRandomkey);
//         }
//         
//         // determine correctness of randomkey initialization
//         //            NSLog(@"ViewAmino.viewDidLoad: theater molecule %@ randomkey: %@", menuItemsList, theatMolecRandomkey);
//         //            MenuItem *menuItemsList = [[[Z5DataController sharedInstance] localDataController] findOrCreateMenuItemWithRandomkey:theatMolecRandomkey];
//         //            if (menuItemsList) {
//         //                NSLog(@"ViewAmino.viewDidLoad: theater molecule found");
//         //            } else {
//         //                NSLog(@"ViewAmino.viewDidLoad: no theater molecule");
//         //            }
//         
//         */
//     } else {
//         NSLog(@"LocalData.createMenuItemFromUserDefaults: no user data information for %@", menuItemsList);
//     }
//     return ret;
// }

// -(NSMutableDictionary *)generateTrivialCollection:(NSDictionary *)moleculeEntry
// {
//     NSMutableDictionary *retTheaterCollectionDictionary = [[NSMutableDictionary alloc] init];
//     if (moleculeEntry) {
//         
//         /*
//         [retTheaterCollectionDictionary setObject:[Z5LocalDataController produceRandomKeyWithCaption:@"collection-key: "] forKey:@"collection-key"];
//         [retTheaterCollectionDictionary setObject:[[NSMutableArray alloc] initWithCapacity:4] forKey: @"collection-data"];
//         
//         NSMutableDictionary *retTheaterSceneDictionary = [[NSMutableDictionary alloc] init];
//         [retTheaterSceneDictionary setObject:[Z5LocalDataController produceRandomKeyWithCaption:@"scene-key"] forKey:@"scene-key"];
//         [retTheaterSceneDictionary setObject:[[NSMutableArray alloc] initWithCapacity:4] forKey: @"scene-data"];
//         [[retTheaterCollectionDictionary objectForKey:@"collection-data"] addObject:retTheaterSceneDictionary];
//         
//         //    NSMutableDictionary *retTheaterMenuItemDictionary = [[NSMutableDictionary alloc] init];
//         //    [retTheaterMenuItemDictionary setObject:[Z5LocalDataController produceRandomKey] forKey:@"molecule-key"];
//         //    [retTheaterMenuItemDictionary setObject:[[NSMutableArray alloc] init] forKey: @"molecule-data"];
//         //    [[retTheaterMenuItemDictionary objectForKey:@"molecule-data"] addObject: molec];
//         [[retTheaterSceneDictionary objectForKey:@"scene-data"] addObject:moleculeEntry];
//          */
//         
//     } else {
//         NSLog(@"LocalData.generateTrivialCollection: null input");
//     }
//     return retTheaterCollectionDictionary;
// }

#pragma mark - Application's Documents directory

- (NSURL *)applicationDocumentsDirectory
{
    return [[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] lastObject];
}


@end