// I suggest initializing this variable in the global instance
let log = Atlantis.Logger()

// Let's log some stuff
log.verbose("Hello, World!")
log.info("Hello, World!")
log.warning("Hello, World!")
log.debug("Hello, World!")
log.error("Hello, World!")

let doIExist: String? = nil

log.warning(doIExist)

// prints 'nil'

let emptyString: String = ""

log.warning(emptyString)

// prints ""

let string = "Hello, World"
let int = 123
let double = 12.3
let float = 12.3
let bool = true

// you can either log one value
log.debug(string)

// or all of them like so,
log.debug(string, int, double, float, bool)

// prints
"Hello, World" // first one

"Hello, World" // prints each with a new line
123
12.3
12.3
true

// array of ints
let numbers = [123, 1234, 12345]

log.debug(numbers)

// prints
[
    123,
    1234,
    12345
]

// lets try arrays of arrays
let numberArray = [[1, 2, 3], [4, 5]]

log.debug(numberArray)

// prints
[
    [
        1,
        2,
        3
    ],
    [
        4,
        5
    ]
]

// on to dictionaries...
let dictionary: [String: AnyObject] = [
    "quote": "It is better to have loved, than to have never loved at all?"
] 

log.debug(dictionary)

// prints
[
    "quote": "It is better to have loved, than to have never loved at all?"
]

// how about NSDictionary types?
var dictionary = NSDictionary()
dictionary.updateValue("will this work?", key: "question")

log.debug(dictionary)

// prints
[
    "question": "will  this work?"
]

// say we got two response objects from the server,
// now both objects are the same but one of them has missing data...

responses.map { log.debug($0) }

// prints
{
    "response": "Here is some data!",
    "success" 200
},
{
    "response": null,
    "success" 200
}

// Atlantis will print all of the object's keys regardless of missing
// or empty values and will print null if need be.

// now let's get to the fun part,

// native Foundation (ex: UIView, UIColor, etc.)

log.debug(UIColor())

// prints
<UIPlaceholderColor: 0x7ff1fb517ab0>

// native NSObjects

public class Dog: NSObject {
  var name = "Doug"
}

let dog = Dog()

log.debug(dog)

// prints 
{
    "name": "Doug"
} 

// But what about objects you created with no native subclasses?

public class CustomObject {
    var id: Int = 123
    var name: String = "Ben"
}

let customObject = CustomObject()

log.debug(customObject)

// prints
{
    "id": 123,
    "name": "Doug"
} 

// Haha, no way?

// Alright, well how about custom objects with custom objects in them?

public class ParentObject {
    var id: Int = 456
    var name: String = "Tammy"
    var customObject: CustomObject = CustomObject()
}

let parentObject = ParentObject()

log.debug(parentObject)

// prints
{
    "id": 456,
    "name": "Tammy"
    "customObject": {
        "id": 123,
        "name": "Doug"
    }
} 

// That's right.

// Okay, custom objects with an array of custom objects. ;)

public class ParentObject {
    var id: Int = 456
    var name: String = "Tammy"
    var customObjects: [CustomObject] = [CustomObject(), CustomObject()]
}

let parentObject = ParentObject()

log.debug(parentObject)

// prints
{
    "id": 456,
    "name": "Tammy"
    "customObjects": [
        {
            "id": 123,
            "name": "Doug"
        },
        {
            "id": 123,
            "name": "Doug"
        }
    ]
} 

// Not impressed? 

let parentObject1 = ParentObject()
let parentObject2 = ParentObject() // one of its child has a dictionary 

let parents: [ParentObject] = [parentObject1, parentObject2]

log.debug(parents)

// prints
[
    {
        "id": 456,
        "name": "Tammy"
        "customObjects": [
            {
                "id": 123,
                "name": "Doug"
            },
            {
                "id": 123,
                "name": "Doug"
            }
        ]
    },
    {
        "id": 456,
        "name": "Tammy"
        "customObjects": [
            {
                "id": 123,
                "name": "Doug"
            },
            {
                "id": 123,
                "name": "Doug"
                "dictionary": [
                    "likes": "baseball",
                    "dislikes": "pad thai"
                ]
            }
        ]
    }
]

// Atlantis' logging is infinitely and ambiguously recursive,
// it supports almost all data types including arrays, dictionaries, 
// and any objects within any objects. 👍🏼

// Great!! Now on to some more stand-alone but much needed types.

struct Struct {
  var name: String = "Bob the Builder"
  var skills: [String] = ["structures, buildings"]
}

log.debug(Struct())
    
// prints
{
  "skills" : [
    "structures, buildings"
  ],
  "name" : "Bob the Builder"
}

enum ErrorType {
    case Severe
    case Moderate
    case Casual
}

let type: ErrorType = .Severe

log.debug(type)

// prints
Severe

// one more example.

log.debug(ErrorType.Moderate)
log.debug(ErrorType.Casual)

// prints
Moderate
Casual

Error: [ViewController.swift/viewDidLoad()/line:98] 
{
  "code" : 404,
  "localizedDescription" : "The operation couldn’t be completed. (Hello, World! error 404.)",
  "domain" : "Hello, World!",
  "userInfo" : {
    "error": "found"
    "note": "syntax"
  }
}

Atlantis.Configuration.highlightsErrors // default false

Atlantis.Configuration.filteredErrorCodes

Atlantis.Configuration.filteredErrorCodes.append(-1099)

// let's call a method that throws errors, however one of the 
// errors is something we want to filter out.
method() { error in 
    log.error(error) // can either be error 404 or -1099?
}

// will only print the error if the error code is 404

func add(x: Int, _ y: Int) -> Int { return x + y }

let addXY = log.tap.debug(add(3, 5))

// prints 8 and assigns the value to addXY

func promise() -> Promise<String> {
  return Promise { fulfill, reject in
    // blah blah
    fulfill("Hello from server!")
  }
}

promise()
.then { log.tap($0) }
.then { reply in
  // blah blah
}
.catch { log.error($0) }

// prints "Hello from server!" while completing the promise.

Atlantis.Configuration.logLevel // default .Verbose

Atlantis.Configuration.showExtraInfo // default true

// colors
Atlantis.Configuration.hasColoredLogs // default false
Atlantis.Configuration.hasWhiteBackground // default false
Atlantis.Configuration.coloredLogLevels // default [.Verbose, .Info, .Warning, .Debug, .Error] 

// using a Tuple initializer

Atlantis.Configuration.logColors.info = Atlantis.XCodeColor(fg: (Int, Int, Int)>, bg: <(Int, Int, Int)>)

// using UIColor setting only the foreground

Atlantis.Configuration.logColors.info = Atlantis.XCodeColor(fg: UIColor)

// or using UIColor setting both the foreground and background

Atlantis.Configuration.logColors.debug = Atlantis.XCodeColor(fg: UIColor, bg: UIColor)