//

//  AppDelegate.swift

//  USB Meter

//

//  Created by Bogdan Timofte on 01/03/2020.

//  Copyright © 2020 Bogdan Timofte. All rights reserved.

//

import UIKit

import CoreData

//let btSerial = BluetoothSerial(delegate: BSD())

let appData = AppData()

enum Constants {

    static let chartUnderscan: CGFloat = 0.5

    static let chartOverscan: CGFloat = 1 - chartUnderscan

}

// MARK: Clock

// MARK: Debug

public func track(_ message: String = "", file: String = #file, function: String = #function, line: Int = #line ) {

    let date = Date()

    let calendar = Calendar.current

    let hour = calendar.component(.hour, from: date)

    let minutes = calendar.component(.minute, from: date)

    let seconds = calendar.component(.second, from: date)

    print("\(hour):\(minutes):\(seconds) - \(file):\(line) - \(function) \(message)")

}

@UIApplicationMain

class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

        // Override point for customization after application launch.

    }

        let container = CKContainer(identifier: cloudKitContainerIdentifier)

        container.accountStatus { status, error in

            if let error {

                track("CloudKit account status error: \(error.localizedDescription)")

                return

            }

            let statusDescription: String

            switch status {

            case .available:

                statusDescription = "available"

            case .noAccount:

                statusDescription = "noAccount"

            case .restricted:

                statusDescription = "restricted"

            case .couldNotDetermine:

                statusDescription = "couldNotDetermine"

            case .temporarilyUnavailable:

                statusDescription = "temporarilyUnavailable"

            @unknown default:

                statusDescription = "unknown"

            }

            track("CloudKit account status for \(self.cloudKitContainerIdentifier): \(statusDescription)")

        }

    }

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {

        // Called when a new scene session is being created.

        // Use this method to select a configuration to create the new scene with.

        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)

    }

    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {

        // Called when the user discards a scene session.

        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.

        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.

    }

    // MARK: - Core Data stack

    lazy var persistentContainer: NSPersistentCloudKitContainer = {

        /*

         The persistent container for the application. This implementation

         creates and returns a container, having loaded the store for the

         application to it. This property is optional since there are legitimate

         error conditions that could cause the creation of the store to fail.

        */

        let container = NSPersistentCloudKitContainer(name: "CKModel")

            description.cloudKitContainerOptions = NSPersistentCloudKitContainerOptions(containerIdentifier: "iCloud.ro.xdev.USB-Meter")

            description.setOption(true as NSNumber, forKey: NSPersistentHistoryTrackingKey)

            description.setOption(true as NSNumber, forKey: NSPersistentStoreRemoteChangeNotificationPostOptionKey)

        }

            if let error = error as NSError? {

                NSLog("Core Data store load failed: %s", error.localizedDescription)

                // Attempt lightweight migration and fallback by resetting the store when migration fails.

                if let storeURL = storeDescription.url {

                    let coordinator = container.persistentStoreCoordinator

                    let storeType = storeDescription.type

                    do {

                        try coordinator.destroyPersistentStore(at: storeURL, ofType: storeType, options: nil)

                        try coordinator.addPersistentStore(ofType: storeType, configurationName: nil, at: storeURL, options: storeDescription.options)

                        NSLog("Core Data store recovered by destroying and recreating store at %@", storeURL.path)

                        return

                    } catch {

                        NSLog("Core Data recovery attempt failed: %s", (error as NSError).localizedDescription)

                    }

                }

                // As a last resort, keep running but note that persistent store is unavailable.

                // In debug environment this should be investigated further.

                #if DEBUG

        })

        container.viewContext.mergePolicy = NSMergeByPropertyStoreTrumpMergePolicy

    }()

    // MARK: - Core Data Saving support

    func saveContext () {

        let context = persistentContainer.viewContext

        if context.hasChanges {

            do {

                try context.save()

            } catch {

                let nserror = error as NSError

                #if DEBUG

        }

    }

}