PDF_Office/PDF Office/KMComponentLibrary/KMComponentLibrary/View/MenuItem/ComponentMenuItem.swift

//
//  ComponentMenuItem.swift
//  KMComponentLibrary
//
//  Created by Niehaoyu on 2024/8/30.
//

import Cocoa
import AppKit

public let ComponentMenuItemUpdatedKey = "ComponentMenuItemUpdatedKey"

public class ComponentMenuItem: ComponentBaseXibView {
    
    @IBOutlet var contendBox: NSBox!
    @IBOutlet var checkBox: ComponentCheckBox!
    @IBOutlet var leftIconImage: NSImageView!
    @IBOutlet var titleLabel: NSTextField!
    @IBOutlet var keyEquivalentLabel: NSTextField!
    @IBOutlet var righticonImage: NSImageView!
    
    @IBOutlet var separatorBox: NSBox!
    @IBOutlet var separatorDivider: ComponentDivider!
    
    @IBOutlet var headerBox: NSBox!
    @IBOutlet var headerLabel: NSTextField!
    
    @IBOutlet var titleLabelLeftConst: NSLayoutConstraint!
    
    // MARK: Private Property
    private var _properties : ComponentMenuitemProperty = ComponentMenuitemProperty()
    
    private var action: Selector?   // 点击事件
    
    private weak var target: AnyObject? // 对象目标
    
    var mouseHandle: ((_ view: ComponentMenuItem, _ mouseState: ComponentMouseState, _ event: NSEvent) -> Void)?
    
    
    // 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()
        
        NotificationCenter.default.addObserver(self, selector: #selector(propertyUpdatedNoti(_:)), name: NSNotification.Name(rawValue: ComponentMenuItemUpdatedKey), object: nil)
    }
    
    @objc func propertyUpdatedNoti(_ notification: Notification) {
        
        if let objectID = notification.object as? String, objectID == properties.identifier {
            setupUI()
            
            refreshUI()
        }
    }
    
    public var properties : ComponentMenuitemProperty {
        get {
            return _properties
        }
        set {
            _properties = newValue
            
            ComponentLibrary.shared.configMenuItemComponent(properties: _properties)
            
            setupUI()
            
            refreshUI()
        }
    }
    
    //MARK: - SetupUI
    func setupUI() {
        contendBox.isHidden = true
        separatorBox.isHidden = true
        headerBox.isHidden = true
        
        if properties.type == .normal {
            contendBox.isHidden = false
            
        } else if properties.type == .divider {
            separatorBox.isHidden = false
            separatorBox.borderWidth = 0
            separatorBox.borderColor = NSColor.clear
            separatorBox.fillColor = NSColor.clear
            
            let property: ComponentDividerProperty = ComponentDividerProperty(type: .horizontal, dash: false)
            separatorDivider.properties = property
            
        } else if properties.type == .header {
            headerBox.isHidden = false
            headerBox.fillColor = NSColor.clear
            
            headerLabel.textColor = ComponentLibrary.shared.getComponentColorFromKey("colorText/3")
            headerLabel.font = ComponentLibrary.shared.getFontFromKey("mac/body-s-medium")
            
        }
        
        let checkboxProperties: ComponentCheckBoxProperty = ComponentCheckBoxProperty.init(size: .m,
                                                                                           state: .normal,
                                                                                           isDisabled: properties.isDisabled,
                                                                                           showhelp: false,
                                                                                           text: nil,
                                                                                           checkboxType: .normal)
        
        checkBox.properties = checkboxProperties
        
        
        checkBox.properties.isDisabled = properties.isDisabled
        checkBox.setTarget(self, action: #selector(checkBoxAction(_:)))
        checkBox.reloadData()
        
        if properties.lefticon != nil {
            leftIconImage.isHidden = false
            leftIconImage.image = properties.lefticon
            titleLabelLeftConst.constant = 40
        } else {
            leftIconImage.isHidden = true
            titleLabelLeftConst.constant = 16
        }
        
        if properties.subPropertys.isEmpty == false {
            properties.righticon = ComponentLibrary.shared.image(forResource: "arrowRight")
        }
        
        if properties.righticon != nil {
            righticonImage.image = properties.righticon
            righticonImage.isHidden = false
        } else {
            righticonImage.isHidden = true
        }
        
        if properties.keyEquivalent != nil &&
            properties.keyEquivalent?.isEmpty == false {
            keyEquivalentLabel.isHidden = false
        } else {
            keyEquivalentLabel.isHidden = true
        }
        
        if properties.multipleSelect == true {
            checkBox.isHidden = false
            leftIconImage.isHidden = true
            righticonImage.isHidden = true
            titleLabelLeftConst.constant = 40
        } else {
            checkBox.isHidden = true
        }
        
        properties.propertyInfo.viewWidth = 200
        
        titleLabel.stringValue = properties.text
        headerLabel.stringValue = properties.text
    }
    
    func refreshUI() {
        
        if properties.itemSelected == true {
            checkBox.properties.checkboxType = .selected
            checkBox.refreshUI()
        } else {
            checkBox.properties.checkboxType = .normal
            checkBox.refreshUI()
        }
        
        contendBox.borderWidth = 0
        contendBox.borderColor = NSColor.clear
        
        var fillColor = properties.propertyInfo.color_nor
        var textColor = properties.propertyInfo.textColor
        
        if properties.state == .hover {
            fillColor = properties.propertyInfo.color_hov
        }
        if properties.itemSelected == true {
            fillColor = properties.propertyInfo.color_active
        }
        
        if properties.isDisabled == true {
            fillColor = properties.propertyInfo.color_dis
            textColor = properties.propertyInfo.textColor_dis
        }
        
        contendBox.fillColor = fillColor
        
        titleLabel.textColor = textColor
        
        titleLabel.font = properties.propertyInfo.textFont
        keyEquivalentLabel.font = properties.propertyInfo.textFont
        
        keyEquivalentLabel.textColor = properties.propertyInfo.keyEquivalent_textColor
        
        keyEquivalentLabel.stringValue = properties.keyEquivalent ?? ""
        
    }
    
    public func setTarget(_ target: AnyObject?, action: Selector?) {
        self.target = target!
        self.action = action!
    }
    
    //MARK: - Action
    @objc func checkBoxAction(_ sender: ComponentCheckBox) {
        if checkBox.properties.checkboxType == .selected {
            properties.itemSelected = true
        } else {
            properties.itemSelected = false
        }
        refreshUI()
        
        if let target = target, let action = action {
            _ = target.perform(action, with: self)
        }
    }
    
    //MARK: - MouseEvent
    public override func mouseEntered(with event: NSEvent) {
        super.mouseEntered(with: event)
        
        if properties.isDisabled == false &&
            properties.itemSelected == false {
            
            properties.state = .hover
            
            refreshUI()
        }
        
        guard let callBack = mouseHandle else {
            return
        }
        callBack(self, .enter, event)
    }
    
    public override func mouseMoved(with event: NSEvent) {
        super.mouseMoved(with: event)
        
        guard let callBack = mouseHandle else {
            return
        }
        callBack(self, .move, event)
    }
    
    public override func mouseExited(with event: NSEvent) {
        super.mouseExited(with: event)
        
        if properties.isDisabled == false &&
            properties.itemSelected == false  {
            properties.state = .normal
            
            refreshUI()
        }
        
        guard let callBack = mouseHandle else {
            return
        }
        callBack(self, .exit, event)
    }
    
    public override func mouseDown(with event: NSEvent) {
        super.mouseDown(with: event)
        
        var clickEnable = true
        
        if properties.type == .normal {
            let point = convert(event.locationInWindow, from: nil)
            if CGRectContainsPoint(checkBox.frame, point) {
                clickEnable = false
            }
        }
        
        if properties.isDisabled == false &&
            clickEnable == true {
            if properties.itemSelected == true {
                properties.itemSelected = false
            } else {
                properties.itemSelected = true
            }
            refreshUI()
        }
    }
    
    public override func mouseUp(with event: NSEvent) {
        super.mouseUp(with: event)
        print(self.className, "clicked", NSDate())
        if properties.isDisabled == false &&
            properties.type == .normal {
            if let target = target, let action = action {
                _ = target.perform(action, with: self)
            }
        }
    }
    
}