Privado-macOS/macOS/Privado/Sources/View/RoundedTextField/RoundedTextField.swift

//
//  RoundedTextField.swift
//  Cyberlock
//
//  Created by Jura on 8/31/19.
//  Copyright © 2019 Omicronmedia. All rights reserved.
//

import Foundation
import AppKit

final class RoundedTextField: NSTextField, NSTextFieldDelegate {
    
    private struct Constants {
        static let cornerRadius: CGFloat = 13
        static let placeholderColor = NSColor(calibratedRed: 173 / 255, green: 179 / 255, blue: 210 / 255, alpha: 0.5)
        static let textColor = NSColor(calibratedRed: 173 / 255, green: 179 / 255, blue: 210 / 255, alpha: 1.0)
    }
    
    // MARK: - Properties
    
    var coloredPlaceHolder: String? {
        get {
            return self.placeholderAttributedString?.string
        }
        set {
            if let value = newValue
                , let font = self.font {
                let attrs = [NSAttributedString.Key.foregroundColor: Constants.placeholderColor,
                             NSAttributedString.Key.font: NSFont.systemFont(ofSize: font.pointSize)]
                self.placeholderAttributedString = NSAttributedString(string: value, attributes: attrs)
            } else {
                self.placeholderAttributedString = nil
            }
        }
    }
    
    // MARK: - Initializers
    
    override init(frame frameRect: NSRect) {
        super.init(frame: frameRect)

        self.isBezeled = false
        self.drawsBackground = false
        self.translatesAutoresizingMaskIntoConstraints = false
        self.focusRingType = .none
        self.usesSingleLineMode = true
        self.textColor = Constants.textColor
        self.delegate = self
        if let font = self.font {
            self.font = NSFont(name: font.fontName, size: 14.0)
        }
        
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    // MARK: - Methods
    
    func hightlight(with color: NSColor?) {
        
        guard let borderColor = color else {
            self.layer?.borderWidth = 0.0
            return
        }
        
        self.layer?.borderColor = borderColor.cgColor
        self.layer?.borderWidth = 1.0
        self.layer?.cornerRadius = Constants.cornerRadius
        
    }
    
    private func performEditingKeyEquivalent(with event: NSEvent) -> Bool {
        
        guard event.type == NSEvent.EventType.keyDown else { return false }

        let commandKey = NSEvent.ModifierFlags.command.rawValue
        let commandShiftKey = NSEvent.ModifierFlags.command.rawValue | NSEvent.ModifierFlags.shift.rawValue

        let key = event.modifierFlags.rawValue & NSEvent.ModifierFlags.deviceIndependentFlagsMask.rawValue
        switch key {
        case commandKey: return self.handleCommandKey(character: event.charactersIgnoringModifiers)
        case commandShiftKey: return self.handleShiftKey(character: event.charactersIgnoringModifiers)
        default:
            break
        }
        
        return false
    }
    
    private func handleCommandKey(character: String?) -> Bool {
        
        guard let character = character else { return false }
        
        switch character {
        case "x":
            if NSApp.sendAction(#selector(NSText.cut(_:)), to: nil, from: self) { return true }
        case "c":
            if NSApp.sendAction(#selector(NSText.copy(_:)), to: nil, from: self) { return true }
        case "v":
            if NSApp.sendAction(#selector(NSText.paste(_:)), to: nil, from: self) { return true }
        case "z":
            if NSApp.sendAction(Selector(("undo:")), to: nil, from: self) { return true }
        case "a":
            if NSApp.sendAction(#selector(NSResponder.selectAll(_:)), to: nil, from: self) { return true }
        default:
            break
        }
        
        return false
    }
    
    private func handleShiftKey(character: String?) -> Bool {
        if character == "Z" {
            if NSApp.sendAction(Selector(("redo:")), to: nil, from: self) { return true }
        }
        
        return false
    }

    // MARK: - Lifecycle
    
    override class var cellClass: AnyClass? {
        get {
            return RoundedTextFieldCell.self
        }
        // swiftlint:disable unused_setter_value
        set { }
        // swiftlint:enable unused_setter_value
    }
    
    override func viewDidMoveToWindow() {
        if let textView = self.window?.fieldEditor(true, for: self) as? NSTextView {
            textView.insertionPointColor = Constants.textColor
            textView.alignment = .center
        }
    }
    
    override func draw(_ dirtyRect: NSRect) {

        let size = dirtyRect.size
        let blackOutlineFrame = NSRect(x: 0, y: 0, width: size.width, height: size.height - 1.0)
        let color = NSColor(calibratedRed: 45 / 255, green: 51 / 255, blue: 82 / 255, alpha: 1.0)
        
        let gradient = NSGradient(colors: [color])
        let path = NSBezierPath(roundedRect: blackOutlineFrame, xRadius: Constants.cornerRadius, yRadius: Constants.cornerRadius)
        gradient?.draw(in: path, angle: 90)
        
        super.draw(dirtyRect)
    }
    
    override func performKeyEquivalent(with event: NSEvent) -> Bool {
        if self.performEditingKeyEquivalent(with: event) {
            return true
        }

        return super.performKeyEquivalent(with: event)
    }
    
    // MARK: - NSTextFieldDelegate
    
    func controlTextDidChange(_ obj: Notification) {
        self.hightlight(with: nil)
    }

}