import EVCloudKitDao

// Just enherit from CKDataObject so that you have access to the CloudKit metadata
class News : CKDataObject {
    var Subject : String = ""
    var Text : String = ""
}

class AppDelegate: UIResponder, UIApplicationDelegate {
    var window: UIWindow?

    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: NSDictionary?) -> Bool {
        // Make sure we receive subscription notifications
        application.registerUserNotificationSettings(UIUserNotificationSettings(forTypes: .Alert | .Badge | .Sound, categories: nil))
        application.registerForRemoteNotifications()
        return true
    }

    func application(application: UIApplication!, didReceiveRemoteNotification userInfo: [NSObject : NSObject]!) {
        EVLog("Push received")
        EVCloudData.publicDB.didReceiveRemoteNotification(userInfo, {
            EVLog("Not a CloudKit Query notification.")            
        })
    }

    func applicationDidEnterBackground(application: UIApplication) {
        // If you do a backup then this backup will be reloaded after app restart.
        EVCloudData.publicDB.backupData()        
    }
}


class LeftMenuViewController: UIViewController {
    var newsController: NewsViewController!

    override func viewDidLoad() {
        super.viewDidLoad()
        connectToNews()
        // Only already setup CloudKit connect's will receive these notifications (like the News above)
        EVCloudData.publicDB.fetchChangeNotifications()        
    }

    deinit {
        EVCloudData.publicDB.disconnect("News_All")
    }

    func connectToNews() {
        EVCloudData.publicDB.connect(News()
        , predicate: NSPredicate(value: true)
        , filterId: "News_All"
        , configureNotificationInfo: { notificationInfo in
            notificationInfo.alertBody = "New news item"
            notificationInfo.shouldSendContentAvailable = true }
        , completionHandler: { results in
            EVLog("There are \(results.count) existing news items")
            self.newsController.tableView.reloadData()
            return results.count < 200 // Continue reading if we have less than 200 records and if there are more.
        }, insertedHandler: {item in
            Helper.showStatus("New News item: '\(item.Subject)'")
            self.newsController.tableView.reloadData()
        }, updatedHandler: {item in
            Helper.showStatus("Updated News item:'\(item.Subject)'")
            self.newsController.tableView.reloadData()
        }, deletedHandler: {recordId in
            Helper.showStatus("News item was removed")
            self.newsController.tableView.reloadData()
        }, dataChangedHandler : {
            EVLog("Some News data was changed")
        }, errorHandler: {error in
            Helper.showError("Could not load news: \(error.description)")
        })
    }
}


class NewsViewController : UIViewController, UITableViewDataSource, UITableViewDelegate, RESideMenuDelegate {
	...
    func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
        var cell:UITableViewCell! = tableView.dequeueReusableCellWithIdentifier(cellIdentifier) as? UITableViewCell
        ...
        //This line all you need to get the correct data for the cell
        var news:News = EVCloudData.publicDB.data["News_All"]![indexPath.row] as News

        cell.textLabel?.text = news.Subject
        cell.detailTextLabel?.text = news.Body
        return cell;
    }
}

// Just enherit from CKDataObject so that you have access to the CloudKit metadata
class Message : CKDataObject {
    var From : String = ""
    var To : String = ""
    var Text : String = ""
}

let dao: EVCloudKitDao = EVCloudKitDao.publicDB
let dao2 = EVCloudKitDao.publicDBForContainer("iCloud.nl.evict.myapp")

var message = Message()
message.From = "[email protected]"
message.To = "[email protected]"
message.Text = "This is the message text"

dao.saveItem(message, completionHandler: {record in
        createdId = record.recordID.recordName;
        EVLog("saveItem : \(createdId)");
    }, errorHandler: {error in
        EVLog("<--- ERROR saveItem");
    })

dao.query(Message()
    , completionHandler: { results in
        EVLog("query : result count = \(results.count)")
    }, errorHandler: { error in
        EVLog("<--- ERROR query Message")
    })

var queryRunning:Int = 0
var data:[Message] = []

func searchDisplayController(controller: UISearchDisplayController!, shouldReloadTableForSearchString searchString: String!) -> Bool {
    self.filterContentForSearchText(searchString)
    return false
}

func searchDisplayController(controller: UISearchDisplayController!, shouldReloadTableForSearchScope searchOption: Int) -> Bool {
    self.filterContentForSearchText(self.searchDisplayController!.searchBar.text)
    return false
}

func filterContentForSearchText(searchText: String) {
    EVLog("Filter for \(searchText)")
    networkSpinner(1)
    EVCloudKitDao.publicDB.query(Message(), tokens: searchText, completionHandler: { results in
        EVLog("query for tokens '\(searchText)' result count = \(results.count)")
        self.data = results
        NSOperationQueue.mainQueue().addOperationWithBlock {
            self.searchDisplayController!.searchResultsTableView.reloadData()
            self.tableView.reloadData()
            self.networkSpinner(-1)
        }
    }, errorHandler: { error in
        EVLog("ERROR: query Message for words \(searchText)")
        self.networkSpinner(-1)
    })
}

func networkSpinner(adjust: Int) {
    self.queryRunning = self.queryRunning + adjust
    UIApplication.sharedApplication().networkActivityIndicatorVisible = self.queryRunning > 0
}

override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
    return data.count
}

override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
    let cellIdentifier = "Folowin_Search_Cell";
    var cell:UITableViewCell! = tableView.dequeueReusableCellWithIdentifier(cellIdentifier) as? UITableViewCell
    if cell == nil {
        cell = UITableViewCell(style: .Subtitle, reuseIdentifier: cellIdentifier)
    }

    var item:Message = data[indexPath.row]
    cell.textLabel?.text = item.Text
    return cell;
}

func initializeCommunication(retryCount: Double = 1) {
    ...
    }, errorHandler: { error in
        switch EVCloudKitDao.handleCloudKitErrorAs(error, retryAttempt: retryCount) {
            case .Retry(let timeToWait):
                Async.background(after: timeToWait) {
                    self.initializeCommunication(retryCount: retryCount + 1)
                }
            case .Fail:
                if error.code == .limitExceeded {
                    //TODO: try again with a smaller load?
                }            
                Helper.showError("Could not load messages: \(error.localizedDescription)")
            default: // For here there is no need to handle the .Success, and .RecoverableError
                break
        }
    })
}