PDF_Office/PDF Office/KMComponentLibrary/KMComponentLibrary/View/InputNumber/ComponentInputNumber.swift

//
//  ComponentInputNumber.swift
//  KMComponentLibrary
//
//  Created by Niehaoyu on 2024/8/27.
//

import Cocoa
import AppKit

@objc public protocol ComponentInputNumberDelegate: AnyObject {
    
    @objc optional func componentInputNumberDidValueChanged(inputNumber: ComponentInputNumber?)
  
}

public class ComponentInputNumber: ComponentBaseXibView {

    @IBOutlet var contendBox: NSBox!
    @IBOutlet var lefticonImage: NSImageView!
    @IBOutlet var righticonImage: NSImageView!
    @IBOutlet var inputField: ComponentTextField!
    @IBOutlet var stepperView: ComponentStepper!
    
    @IBOutlet var errorTipLabel: NSTextField!
    
    @IBOutlet var contendBoxBottomConst: NSLayoutConstraint!
    @IBOutlet var stepperHeightConst: NSLayoutConstraint!
    @IBOutlet var inputFieldLeftConst: NSLayoutConstraint!
    @IBOutlet var inputFieldRightConst: NSLayoutConstraint!
    
    // MARK: Private Property
    private var _properties : ComponentInputNumberProperty = ComponentInputNumberProperty()
    
    private let formatter = ComponentNumberFormatter()
    
    weak open var delegate: ComponentInputNumberDelegate?
    
    // MARK: 初始化
    deinit {
        NotificationCenter.default.removeObserver(self)
        
    }
    public required init?(coder decoder: NSCoder) {
        super.init(coder: decoder)
        
    }
    
    override init(frame frameRect: NSRect) {
        super.init(frame: frameRect)
    }
    
    public override func awakeFromNib() {
        super.awakeFromNib()
        
//        formatter.regexString = "^[0123456789]*$"
//        formatter.controlSize = true
//        
//        self.inputField.formatter = formatter
        self.inputField.componentDelegate = self
        self.inputField.focusRingType = .none
        
        self.stepperView.componentDelegate = self
        
        NotificationCenter.default.addObserver(self, selector: #selector(textFieldDidBeginEditingNotification(_:)), name: NSControl.textDidBeginEditingNotification, object: inputField)
        NotificationCenter.default.addObserver(self, selector: #selector(textFieldDidChangeNotification(_:)), name: NSControl.textDidChangeNotification, object: inputField)
        NotificationCenter.default.addObserver(self, selector: #selector(textFieldDidEndEditingNotification(_:)), name: NSControl.textDidEndEditingNotification, object: inputField)
    }
 
    // MARK: - Set & Get
    
    public var properties : ComponentInputNumberProperty {
        get {
           return _properties
        }
        set {
            _properties = newValue
            
            ComponentLibrary.shared.configInputNumberComponent(properties: _properties)
            
            self.reloadData()
        }
    }
    
    public func reloadData() {
        
        self.setupUI()
        
        self.refreshUI()
    }
    
    func setupUI() {
        
        if self.properties.size == .m {
            self.stepperHeightConst.constant = 28
        } else if self.properties.size == .s {
            self.stepperHeightConst.constant = 24
        }
        
        self.inputField.alignment = properties.alignment
         
        if self.properties.showPrefix == true {
            self.lefticonImage.isHidden = false
            self.inputFieldLeftConst.constant = 32
        } else {
            self.lefticonImage.isHidden = true
            self.inputFieldLeftConst.constant = 8
        }
        
        if self.properties.showSuffix == true {
            self.righticonImage.isHidden = false
            self.inputFieldRightConst.constant = 56
        } else {
            self.righticonImage.isHidden = true
            self.inputFieldRightConst.constant = 32
        }
        
        self.reloadStepperViewEnable()
        
        self.inputField.stringValue = properties.text ?? ""
        self.inputField.placeholderString = String(format: "%d~%d", self.properties.minSize, self.properties.maxSize)
        
        formatter.minSize = properties.minSize
        formatter.maxSize = properties.maxSize
         
    }
    
    func refreshUI() {
        
        if self.properties.isError == true && properties.showErrorInfo {
            self.errorTipLabel.isHidden = false
            self.contendBoxBottomConst.constant = 18
        } else {
            self.errorTipLabel.isHidden = true
            self.contendBoxBottomConst.constant = 0
        }
        
        self.contendBox.cornerRadius = self.properties.propertyInfo.cornerRadius
        self.contendBox.borderWidth = self.properties.propertyInfo.borderWidth
        
        var fillColor = NSColor.clear
        var borderColor = NSColor.clear
        if self.properties.state == .normal {
            fillColor = (self.properties.propertyInfo.color_nor)
            borderColor = (self.properties.propertyInfo.borderColor_nor)
            
        } else if self.properties.state == .hover {
            fillColor = (self.properties.propertyInfo.color_hov)
            if self.properties.isError == true {
                fillColor = (self.properties.propertyInfo.color_error_hov)
            }
            borderColor = (self.properties.propertyInfo.borderColor_hov)
            
        } else if self.properties.state == .pressed {
            fillColor = (self.properties.propertyInfo.color_active)
            borderColor = (self.properties.propertyInfo.borderColor_active)
            
        }
        
        if self.properties.isDisabled == true {
            fillColor = (self.properties.propertyInfo.color_dis)
            borderColor = (self.properties.propertyInfo.borderColor_dis)
            
        }
        
        if self.properties.isError == true {
            borderColor = (self.properties.propertyInfo.borderColor_error)
        }
        
        self.contendBox.fillColor = fillColor
        self.contendBox.borderColor = borderColor
    
        if self.properties.isDisabled == false {
            self.inputField.isEditable = true
        } else {
            self.inputField.isEditable = false
        }
        self.inputField.font = self.properties.propertyInfo.textFont
        
        self.errorTipLabel.textColor = self.properties.propertyInfo.errorTipTextColor
        self.errorTipLabel.font = self.properties.propertyInfo.errorTipTextFont
        
    }
    
    func reloadStepperViewEnable() {
        
        if self.properties.isDisabled == true {
            self.stepperView.upEnable = false
            self.stepperView.downEnable = false
        } else {
            self.stepperView.upEnable = true
            self.stepperView.downEnable = true
            
            let curValue = self.inputField.intValue
            if curValue >= self.properties.maxSize {
                self.stepperView.upEnable = false
                self.stepperView.downEnable = true
            }
            if curValue <= self.properties.minSize {
                self.stepperView.upEnable = true
                self.stepperView.downEnable = false
            }
            
        }
        self.stepperView.reloadData()
    }
    
    func inputFieldStringDidChanged() {
        
        if self.inputField.stringValue.isEmpty {
            self.properties.isError = false
        } else {
            if properties.valueType == .intType {
                let curValue = self.inputField.intValue
                if curValue > self.properties.maxSize ||
                    curValue < self.properties.minSize {
                    self.properties.isError = true
                } else {
                    self.properties.isError = false
                }
            }
        }
        self.reloadStepperViewEnable()
        
        if inputField.stringValue.isEmpty == false {
            if properties.valueType == .intType {
                let curValue: Int = Int(inputField.stringValue) ?? 0
                if curValue > properties.maxSize {
                    inputField.stringValue = properties.text ?? ""
                } else if curValue < properties.minSize {
                    inputField.stringValue = properties.text ?? ""
                }
            }
            properties.text = inputField.stringValue
        } else {
            inputField.stringValue = properties.text ?? ""
        }
        
        self.delegate?.componentInputNumberDidValueChanged?(inputNumber: self)
    }
    
    //MARK: - TextNotification
    @objc func textFieldDidBeginEditingNotification(_ notification: Notification) {
        
    }
    
    @objc func textFieldDidChangeNotification(_ notification: Notification) {
  
        self.inputFieldStringDidChanged()
        
        self.refreshUI()
        
    }
    
    @objc func textFieldDidEndEditingNotification(_ notification: Notification) {
        
        self.inputField.isResponder = false
        if self.properties.isDisabled == false {
            self.properties.state = .normal
        }
         
        self.refreshUI()
        
        self.inputFieldStringDidChanged()
    }
    
    //MARK: - MouseEvent
    public override func mouseEntered(with event: NSEvent) {
        super.mouseEntered(with: event)
         
        if self.properties.isDisabled == false &&
            self.inputField.isResponder == false {
            self.properties.state = .hover
        }
        self.refreshUI()
    }
    
    public override func mouseMoved(with event: NSEvent) {
        super.mouseMoved(with: event)
        
        
    }
     
    public override func mouseExited(with event: NSEvent) {
        super.mouseExited(with: event)
        
        if self.properties.isDisabled == false &&
            self.inputField.isResponder == false{
            self.properties.state = .normal
        }
        
        self.refreshUI()
    }
    
    public override func mouseDown(with event: NSEvent) {
        super.mouseDown(with: event)
    
    }
    
    public override func mouseUp(with event: NSEvent) {
        super.mouseUp(with: event)
        
        if self.properties.isDisabled == false &&
            self.inputField.isResponder == false {
            self.properties.state = .normal
        }
        self.refreshUI()
        
    }
}

extension ComponentInputNumber: ComponentTextFieldDelegate {
    
    func componentTextFieldDidResponderChanged(textField: NSTextField) {
        if self.properties.isDisabled == false {
            if self.inputField.isResponder {
                self.properties.state = .pressed
            } else {
                self.properties.state = .normal
            }
        }
        self.refreshUI()
        
        
    }
}

extension ComponentInputNumber: ComponentStepperDelegate {
    func componentStepperDidIncrease(stepper: ComponentStepper) {
        if properties.valueType == .intType {
            let curValue = self.inputField.intValue + 1
            self.inputField.stringValue = String(curValue)
        } else if properties.valueType == .floatType {
            let curValue = self.inputField.floatValue + 0.1
            self.inputField.stringValue = String(format: "%.1f", curValue)
        }
        
        self.inputFieldStringDidChanged()
        self.reloadStepperViewEnable()
    }
    
    func componentStepperDidDecrease(stepper: ComponentStepper) {
        if properties.valueType == .intType {
            let curValue = self.inputField.intValue
            self.inputField.stringValue = String(curValue-1)
        } else if properties.valueType == .floatType {
            let curValue = self.inputField.floatValue - 0.1
            self.inputField.stringValue = String(format: "%.1f", curValue)
        }
        
        self.inputFieldStringDidChanged()
        self.reloadStepperViewEnable()
    }
}