import C8o

// In swift there is two ways to handle errors :
// We can either choose to don't care about errors using the following syntax (this may produce in case of error an "EXC_BAD_INSTRUCTION")

let c8o : C8o = try! C8o(endpoint: "https://demo.convertigo.net/cems/projects/sampleMobileCtfGallery")
	
// or we can choose to use do/catch syntax that will allow us to catch errors
do{
	let c8o : C8o = try C8o(endpoint: "https://demo.convertigo.net/cems/projects/sampleMobileCtfGallery")
}
catch let e as NSError{
	print(e.description
}
// the C8o instance is ready to interact over https with the demo.convertigo.net server, using sampleMobileUsDirectoryDemo as default project.

import C8o
// The common way
var c8o : C8o = try! C8o(endpoint: "https://demo.convertigo.net/cems/projects/sampleMobileCtfGallery", c8oSettings: C8oSettings().setDefaultDatabaseName("mydb_fullsync").setTimeout(30000))

// The verbose way
let endpoint : String = "https://demo.convertigo.net/cems/projects/sampleMobileCtfGallery"
let c8oSettings : C8oSettings = C8oSettings()
c8oSettings.setDefaultDatabaseName("mydb_fullsync")
c8oSettings.setTimeout(30000)
c8o = try! C8o(endpoint: endpoint, c8oSettings: c8oSettings)

// customize existing settings
var customSettings : C8oSettings = C8oSettings(c8oSettings: c8oSettings).setTimeout(60000);
// or from a C8o instance
customSettings = C8oSettings(c8oSettings: c8o).setTimeout(60000);
		
// all settings can be retrieve from a C8o or C8oSettings instance
let timeout : Int = c8o.timeout

import SwiftyJSON

// c8o is a C8o instance
let jObject : JSON = try! c8o.callJson(".getSimpleData").sync()!

// You now have JSON object that you can use in your app!

import AEXML

// c8o is a C8o instance
let document : AEXMLDocument = try! c8o.callXml(".getSimpleData").sync()!

// the common way with parameters
let JObject : JSON = try! c8o.callJson(".getSimpleData",
			parameters:
			"firstname", "John",
			"lastname", "Do"
)!.sync()!

// the verbose way
var parameters : Dictionary = Dictionary()
parameters["firstname"] = "John"
parameters["lastname"] = "Do"
let JSONObject : JSON = try! c8o.callJson(".getSimpleData", parameters: parameters)!.sync()!

// lock the current thread while the request is done
let JSONObject : JSON = try! c8o.callJson(".getSimpleData")!.sync()!
// the response can be used in this scope

// doesn't lock the current thread while the request is done

c8o.callJson(".getSimpleData")?.then({ (response, parameters) -> (C8oPromise?) in
	// the jObject is available, the current code is executed in an another working thread
		
	return nil // return nil for a simple call
})

// following lines are executed immediately, before the end of the request.
		
c8o.callJson(".getSimpleData")?.thenUI({ (response, parameters) -> (C8oPromise?) in
	// the jObject is available, the current code is executed in the UI thread
	self.simpleLabel.text = response.stringValue

	return nil // return nil for a simple call
})

// following lines are executed immediately, before the end of the request.

c8o.callJson(".getSimpleData", parameters: "callNumber", 1)?.then({ (response, parameters) -> (C8oPromise?) in
	// you can do stuff here and return the next C8oPromise instead of deep nested blocks
	return c8o.callJson(".getSimpleData", parameters: "callNumber", 2)
})?.thenUI({ (response, parameters) -> (C8oPromise?) in
	// you can do stuff here and even modify previous parameters
	var parameters : [String : AnyObject]? = nil
	parameters!["callNumber"] = 3
	parameters!["extraParameter"] = "ok"
	return c8o.callJson(".getSimpleData", parameters: parameters)
})?.then({ (response, parameters) -> (C8oPromise?) in
	// you can do stuff here and return nil because this is the end of the chain
	return nil
})

do{
	try c8o.callJson(".getSimpleData")!.sync()
} catch let Exception as NSError{
	// process the exception
}

c8o.callJson(".getSimpleData", parameters: "callNumber", 1)?.then({ (jObject, parameters) -> (C8oPromise?) in
	return c8o.callJson(".getSimpleData", parameters: "callNumber", 2)
})?.thenUI({ (response, parameters) -> (C8oPromise?) in
	return nil
})?.fail({ (exception, parameters) in
	// exception caught from the first or the second CallJson, can be an Exception
	// this code runs in a worker thread
	//...
})
		
c8o.callJson(".getSimpleData", parameters: "callNumber", 1)?.then({ (jObject, parameters) -> (C8oPromise?) in
	return c8o.callJson(".getSimpleData", parameters: "callNumber", 2)
})?.thenUI({ (jObject, parameters) -> (C8oPromise?) in
	return nil
})?.failUI({ (exception, parameters) in
	// exception caught from the first or the second CallJson, can be an Exception
	// this code runs in a UI thread
	//...
})

do{
    try c8o.log.info("hello world!") // the message can be a simple string
}
catch let e as C8oException{
    c8o.log.error("bye world...", exceptions: e) // the message can also take an Exception argument
}
if(c8o.log.isDebug){ // check if currents log levels are enough
    // enter here only if a log level is 'trace' or 'debug', can prevent unnecessary CPU usage
    let msg : String  = serializeData() // compute a special string, like a Document serialization
    c8o.log.debug(msg)
}

C8oSettings()
    .setLogC8o(false)   // disable log from the Convertigo Client SDK itself
    .setLogRemote(false) // disable remote logging
    .setLogLevelLocal(C8oLogLevel.TRACE)
    // or
C8oSettings().setLogOnFail { (exception, parameters) -> (Void) in
    // the exception contains the cause of the remote logging failure
}

// return the response if is already know and less than 180 sec else call the server
try! c8o.callJson(".getSimpleData",
        parameters: C8oLocalCache.PARAM, C8oLocalCache(priority: C8oLocalCache.Priority.LOCAL, ttl: 180 * 1000)
)!.sync()
        
// same sample but with parameters, also acting as cache keys
try! c8o.callJson(".getSimpleData",
        parameters: "firstname", "John",
                    "lastname", "Doe",
        C8oLocalCache.PARAM, C8oLocalCache(priority: C8oLocalCache.Priority.LOCAL, ttl: 180 * 1000)
)!.sync()
        
// make a standard network call with the server
// but in case of offline move or network failure
// return the response if is already know and less than 1 hour
try! c8o.callJson(".getSimpleData",
            parameters: C8oLocalCache.PARAM, C8oLocalCache(priority: C8oLocalCache.Priority.SERVER, ttl: 3600 * 1000)
)!.sync()

c8o.callJson("fs://base.reset")?.then({ (json, parameters) -> (C8oPromise?) in
    // json content:
    // { "ok": true }
    return c8o.callJson("fs://base.post", // creates a new document on "base", with 2 key/value pairs
        parameters: "firstname", "John",
        "lastname", "Doe"
    )
})?.then({ (json, parameters) -> (C8oPromise?) in
    // json content:
    // {
    //   "ok": true,
    //   "id": "6f1b52df",
    //   "rev": "1-b0620371"
    // }
    return c8o.callJson("fs://base.get",
        parameters: "docid", json["id"].stringValue) // retrieves the complet document from its "docid"
})?.then({ (json, parameters) -> (C8oPromise?) in
    // json content:
    // {
    //   "lastname": "Doe",
    //   "rev": "1-b0620371",
    //   "firstname": "John",
    //   "_id": "6f1b52df"
    // }
    c8o.log.info(json.stringValue) // output the document in the log
    return nil
})

// Assuming c8o is a C8o instance properly instanciated and initiated as describe above.

c8o.callJson(".login")?.then({ (json, parameters) -> (C8oPromise?) in  	if(json == "ok"){
		// replication_pull can also be sync or replication_push
		c8o.callJson("fs://base.replication_pull")?.then({ (json, parameters) -> (C8oPromise?) in  // launches a database replication from the server to the device
			// json content:
			// { "ok": true }
			// the documents are retrieved from the server and can be used
			return nil
			
		})?.progress({ (progress) in
			// this code runs after each progression event
			// progress.Total is calculated and grows up then progress.Current increases to the total
			c8o.log.info("progress: " + progress.description)
		})
	}
	return nil
})

c8o.callJson("fs://base.replication_pull", "continuous", true)?.then({ (json, parameters) -> (C8oPromise?) in  // launches a database replication from the server to the device
			// json content:
			// { "ok": true }
			// the documents are retrieved from the server and can be used
			return nil
			
		})?.progress({ (progress) in
			// this code runs after each progression event
			// progress.Total is calculated and grows up then progress.Current increases to the total
			c8o.log.info("progress: " + progress.description)
		})

c8o.callJson("fs://.view",
    parameters: "ddoc", "design",
    "view", "customers",
    C8O.FS_LIVE, "customers")?.thenUI({ (json, parameters) -> (C8oPromise?) in  // launches a live view
    // will be call now and after each database update
    updateCustomersUI(json)
  return nil
})?
…
// cancel the previous FS_LIVE request, can be on application page change for example
c8o.cancelLive("customers")	

let changeListener = C8oFullSyncChangeListener(handler: {(changes: JSON) -> () in
    checkChanges(changes)
})
…
c8o.addFullSyncChangeListener("base", changeListener) // add this listener for the database "base" ; null or "" while use the default database.
…
c8o.removeFullSyncChangeListener("base", changeListener) // remove this listener for the database "base" ; null or "" while use the default database.