AVRSack/AVRsack/ASSerialWin.swift

//
//  ASSerialWin.swift
//  AVRsack
//
//  Created by Matthias Neeracher on 27/12/14.
//  Copyright (c) 2014 Aere Perennius. All rights reserved.
//

import Cocoa

private var serialInstances     = [String : ASSerialWin]()
private var keyboardHandler     : ACEKeyboardHandler = .ace

class ASSerialWin: NSWindowController {
    @IBOutlet weak var inputLine : NSTextField!
    @IBOutlet weak var logView   : ACEView!
    
    var portDefaults        = [String: Any]()
    var baudRate        : Int = 9600 {
        didSet(oldRate) {
            if portHandle != nil {
                connect(self)   // Disconnect existing
                connect(self)   // Reconnect
            }
            portDefaults["BaudRate"] = baudRate
            updatePortDefaults()
        }
    }
    var sendCR              = false
    var sendLF              = true
    var scrollToBottom      : Bool = true {
        didSet(oldScroll) {
            if scrollToBottom {
                logView.gotoLine(1000000000, column: 0, animated: true)
            }
        }
    }
    var port                = ""
    var serialData          = ""
    var serialObserver      : AnyObject!
    var termination         : AnyObject!
    dynamic var portHandle  : FileHandle?
    var currentTheme        : ACETheme = .xcode
    var fontSize            : UInt = 12
    var shouldReconnect     = false
    dynamic var task        : Process?

    class func showWindowWithPort(port: String) {
        if let existing = serialInstances[port] {
            existing.showWindow(self)
        } else {
            let newInstance = ASSerialWin(port:port)
            serialInstances[port] = newInstance
            newInstance.showWindow(self)
        }
    }
    class func showWindowWithPort(port: String, task: Process, speed: Int) {
        if let existing = serialInstances[port] {
            existing.showWindowWithTask(task: task, speed:speed)
        } else {
            let newInstance = ASSerialWin(port:port)
            serialInstances[port] = newInstance
            newInstance.showWindowWithTask(task: task, speed:speed)
        }
    }
    class func portNeededForUpload(port: String) {
        if let existing = serialInstances[port] {
            existing.disconnectTemporarily()
        }
    }
    class func portAvailableAfterUpload(port: String) {
        if let existing = serialInstances[port] {
            existing.reconnect()
        }
    }
    
    convenience init(port: String) {
        self.init(windowNibName:"ASSerialWin")
        self.port       = port

        let userDefaults = UserDefaults.standard
       
        if let portDef = (userDefaults.object(forKey:"SerialDefaults") as! NSDictionary).object(forKey:port) as? [String: AnyObject] {
            portDefaults = portDef
        } else {
            portDefaults["Theme"]       = userDefaults.string(forKey:"SerialTheme")
            portDefaults["FontSize"]    = userDefaults.object(forKey:"FontSize")
            portDefaults["SendCR"]      = sendCR
            portDefaults["SendLF"]      = sendLF
            portDefaults["BaudRate"]    = 19200
        }
        if let themeId = ACEView.themeIdByName(themeName: portDefaults["Theme"] as! String) {
            currentTheme = themeId
        }
        fontSize = portDefaults["FontSize"] as! UInt
        sendCR   = portDefaults["SendCR"] as! Bool
        sendLF   = portDefaults["SendLF"] as! Bool
        baudRate = portDefaults["BaudRate"] as! Int

        if let handlerName = userDefaults.string(forKey:"Bindings") {
            if let handlerId = ACEView.handlerIdByName(handlerName: handlerName) {
                keyboardHandler = handlerId
            }
        }

        let nc          = NotificationCenter.default
        serialObserver  = nc.addObserver(forName: NSNotification.Name(kASSerialPortsChanged), object: nil, queue: nil, using: { (NSNotification) in
            self.willChangeValue(forKey: "hasValidPort")
            self.didChangeValue(forKey: "hasValidPort")

            if self.task == nil {
                if self.hasValidPort {
                    self.reconnect()
                } else {
                    self.disconnectTemporarily()
                }
            }
        })
        termination = NotificationCenter.default.addObserver(forName: Process.didTerminateNotification,
                                                                   object: nil, queue: nil, using:
            { (notification: Notification) in
                if notification.object as? Process == self.task {
                    self.task        = nil
                    self.portHandle  = nil
                }
        })
    }
    
    override func finalize() {
        if portHandle != nil {
            connect(self)
        }
        NotificationCenter.default.removeObserver(serialObserver)
        NotificationCenter.default.removeObserver(termination)
        serialInstances.removeValue(forKey: port)
    }

    func windowWillClose(notification: NSNotification) {
        if portHandle != nil {
            connect(self)
        }
    }
    
    override func windowDidLoad() {
        logView.setReadOnly(true)
        logView.setShowPrintMargin(false)
        logView.setTheme(currentTheme)
        logView.setKeyboardHandler(keyboardHandler)
        logView.setFontSize(fontSize)
        logView.setMode(.text)
        logView.alphaValue = 0.8
        window?.title   = port
        if task == nil {
            connect(self)
        }
        super.windowDidLoad()
    }

    func installReader(handle: FileHandle?) {
        if let readHandle = handle {
            serialData  = ""
            logView.setString(serialData)
            readHandle.readabilityHandler = {(handle) in
                if let newData = handle.availableDataIgnoringExceptions(),
                   let newString = String(data: newData, encoding: String.Encoding.ascii)
                {
                    self.serialData    += newString
                    DispatchQueue.main.async(execute: {
                        self.logView.setString(self.serialData)
                        if self.scrollToBottom {
                            self.logView.gotoLine(1000000000, column: 0, animated: true)
                        }
                    })
                }
            }
        }
    }

    @IBAction func sendInput(_: AnyObject) {
        let line = inputLine.stringValue + (sendCR ? "\r" : "") + (sendLF ? "\n" : "")
        let data = line.data(using: String.Encoding.ascii, allowLossyConversion: true)!
        portHandle?.write(data)
    }
    
    func showWindowWithTask(task: Process, speed:Int) {
        if portHandle != nil {
            connect(self)
        }
        baudRate        = speed
        self.task       = task
        portHandle      = (task.standardInput as! Pipe).fileHandleForWriting
        showWindow(self)
        installReader(handle: (task.standardOutput as? Pipe)?.fileHandleForReading)
    }
    
    @IBAction func connect(_: AnyObject) {
        shouldReconnect = false
        if task != nil {
            task!.interrupt()
        } else if portHandle != nil {
            let fd = portHandle!.fileDescriptor
            ASSerial.restorePort(fd)
            ASSerial.closePort(fd)
            portHandle = nil
        } else {
            portHandle = ASSerial.openPort(port, withSpeed: Int32(baudRate))
            installReader(handle: portHandle)
        }
    }
    func disconnectTemporarily() {
        if portHandle != nil {
            connect(self)           // Disconnect temporarily
            shouldReconnect  = true // But express interest to reconnect
        }
    }
    func reconnect() {
        if portHandle == nil && shouldReconnect {
            connect(self)           // Reconnect
        }
    }
    
    var connectButtonTitle : String {
        get {
            return (portHandle != nil) ? "Disconnect" : "Connect"
        }
    }
    class func keyPathsForValuesAffectingConnectButtonTitle() -> NSSet {
        return NSSet(object: "portHandle")
    }
    var hasValidPort : Bool {
        get {
            return ASSerial.ports().contains(port)
        }
    }

    // MARK: Editor configuration
    
    @IBAction func changeTheme(_ item: NSMenuItem) {
        let userDefaults = UserDefaults.standard
        currentTheme = ACETheme(rawValue: UInt(item.tag)) ?? .xcode
        logView.setTheme(currentTheme)
        let themeName = ACEThemeNames.humanName(for: currentTheme)
        userDefaults.set(themeName, forKey: "SerialTheme")
        portDefaults["Theme"] = themeName
        updatePortDefaults()
    }
    @IBAction func changeKeyboardHandler(_ item: NSMenuItem) {
        keyboardHandler = ACEKeyboardHandler(rawValue: UInt(item.tag))!
        UserDefaults.standard.set(
            ACEKeyboardHandlerNames.humanName(for: keyboardHandler), forKey: "Bindings")
        NotificationCenter.default.post(name: Notification.Name("Bindings"), object: item)
    }

    func validateUserInterfaceItem(anItem: NSValidatedUserInterfaceItem) -> Bool {
        if let menuItem = anItem as? NSMenuItem {
            if menuItem.action == #selector(ASSerialWin.changeTheme(_:)) {
                menuItem.state = (UInt(menuItem.tag) == currentTheme.rawValue ? NSOnState : NSOffState)
                return true
            } else if menuItem.action == #selector(ASSerialWin.changeKeyboardHandler(_:)) {
                menuItem.state = (menuItem.tag == Int(keyboardHandler.rawValue) ? NSOnState : NSOffState)
                return true
            }
        }
        return true
    }
    
    @IBAction func makeTextLarger(_: AnyObject) {
        fontSize += 1
        logView.setFontSize(fontSize)
        portDefaults["FontSize"] = fontSize
        updatePortDefaults()
    }
    @IBAction func makeTextSmaller(_: AnyObject) {
        if fontSize > 6 {
            fontSize -= 1
            logView.setFontSize(fontSize)
            portDefaults["FontSize"] = fontSize
            updatePortDefaults()
        }
    }
    
    func updatePortDefaults() {
        let userDefaults    = UserDefaults.standard
        let sd              = userDefaults.object(forKey:"SerialDefaults") as! [String: AnyObject]
        let serialDefaults  = NSMutableDictionary(dictionary: sd)
        serialDefaults.setValue(NSDictionary(dictionary:portDefaults), forKey:port)
        userDefaults.set(serialDefaults, forKey:"SerialDefaults")
    }

    @IBAction func saveDocument(_: AnyObject) {
        let savePanel                   = NSSavePanel()
        savePanel.allowedFileTypes      = ["log"]
        savePanel.allowsOtherFileTypes  = true
        savePanel.isExtensionHidden       = false
        savePanel.beginSheetModal(for: window!, completionHandler: { (returnCode) -> Void in
            if returnCode == NSFileHandlingPanelOKButton {
                do {
                    try self.serialData.write(to: savePanel.url!, atomically:false, encoding:String.Encoding.utf8)
                } catch _ {
                }
            }
        })
    }
}