//
//  P4ConnectionSettings.swift
//  DocHub
//
//  Created by Tristan Juricek on 6/11/14.
//  Copyright (c) 2014 Perforce. All rights reserved.
//

import Foundation

struct P4ConnectionSettings {
    var hostname: String
    var port: Int
    var login: String
    var token: String
    var charset: String?
    
    static let p4ConnectionSettingsDirName = "P4ConnectionSettings"
    
    // Deletes connection settings
    static func delete(settings:P4ConnectionSettings) {
        var settingsDir = initSettingsDir()
        var fileURL = NSURL(string: "\(settingsDir)/\(fileName(settings))")

        let manager = NSFileManager.defaultManager()
        if manager.fileExistsAtPath(fileURL.path) {
            var err:NSError? = nil
            manager.removeItemAtPath(fileURL.path, error: &err)
            if err {
                NSException(name: "P4ConnectionSettings.deleteFailed",
                    reason: err!.localizedDescription, userInfo: nil).raise()
            }
        }
    }

    // Stores connection settings, so they will be returned by the next loadAll()
    // method.
    //
    // Note: if the hostname or port changes, you should delete the old settings
    // file separately, first.
    static func save(settings:P4ConnectionSettings) {
        var settingsDir = initSettingsDir()
        var filePath = "\(settingsDir)/\(fileName(settings))"
     
        var err: NSError? = nil
        
        println("writing to \(filePath)")
        
        let outputStream = NSOutputStream(toFileAtPath: filePath, append: false)
        
        outputStream.open()
        
        NSJSONSerialization.writeJSONObject(toMap(settings),
            toStream: outputStream,
            options: NSJSONWritingOptions(),
            error: &err)

        outputStream.close()
        
        if err {
           NSException(name: "P4ConnectionSettings.saveFailed",
            reason: err!.localizedDescription, userInfo: nil).raise()
        }
        
    }
    
    // Returns all stored connection settings, does not validate any of them.
    // Use P4Library for creating connections and validating them.
    static func loadAll() -> P4ConnectionSettings[] {
        var settingsDir = initSettingsDir()

        let manager = NSFileManager.defaultManager()

        var dirs:P4ConnectionSettings[] = []
        
        let items:AnyObject[]? = manager.contentsOfDirectoryAtPath(settingsDir,
            error: nil)
        
        if items {
            let dicts = items!.map({$0 as NSURL})
                .map({
                    (url:NSURL) -> Dictionary<String, String> in
                    
                    var err:NSError? = nil
                    
                    let stream = NSInputStream(URL: url)
                    
                    stream.open()
                    
                    var anyObj : AnyObject! = NSJSONSerialization.JSONObjectWithStream(
                        stream,
                        options: NSJSONReadingOptions.MutableContainers,
                        error: &err)
                    
                    stream.close()
                    
                    if err {
                        NSException(name: "P4ConnectionSettings.invalidJSON",
                            reason: err!.localizedDescription, userInfo: nil).raise()
                    }
                    
                    return anyObj as Dictionary<String, String>
                })
            
            for dict:Dictionary<String, String> in dicts {
                dirs.append(fromMap(dict))
            }
        }
        
        return dirs
    }

    static func initSettingsDir() -> String {
        var appDir = FileHandling.initApplicationSupportDir()
        var settingsDir = "\(appDir)/\(p4ConnectionSettingsDirName)"
        FileHandling.initDir(settingsDir)
        return settingsDir
    }
    
    // We generate
    static func fileName(settings:P4ConnectionSettings) -> String {
        return "\(settings.hostname)-\(settings.port)"
    }
    
    static func toMap(settings:P4ConnectionSettings) -> Dictionary<String, String> {
        var map = [
            "hostname": settings.hostname,
            "port": String(settings.port),
            "login": settings.login,
            "token": settings.token
        ]
        if settings.charset {
            map["charset"] = settings.charset!
        }
        return map
    }
    
    static func fromMap(dict:Dictionary<String, String>) -> P4ConnectionSettings {
        return P4ConnectionSettings(hostname: dict["hostname"]!,
            port: dict["port"]!.toInt()!,
            login: dict["login"]!,
            token: dict["token"]!,
            charset: dict["charset"])
    }
}