PDF_Office/PDF Office/PDF Master/KMClass/KMPDFViewController/RightSideController/Views/Highlight/KMHighlightController.swift

//
//  KMHighlightController.swift
//  PDF Reader Pro
//
//  Created by Niehaoyu on 2024/11/26.
//

import Cocoa
import KMComponentLibrary

class KMHighlightController: KMNBaseViewController {
    
    @IBOutlet var colorBGView: NSView!
    @IBOutlet var colorLabel: NSTextField!
    @IBOutlet var colorGroup: ComponentCColorGroup!
    @IBOutlet var colorSlider: ComponentSlider!
    @IBOutlet var colorOpacitySelect: ComponentSelect!
    
    private var colorAProperty = ComponentCColorProperty(colorType: .color, state: .normal, isCustom: false, color: NSColor.clear)
    private var colorBProperty = ComponentCColorProperty(colorType: .color, state: .normal, isCustom: false, color: NSColor.clear)
    private var colorCProperty = ComponentCColorProperty(colorType: .color, state: .normal, isCustom: false, color: NSColor.clear)
    private var colorDProperty = ComponentCColorProperty(colorType: .color, state: .normal, isCustom: false, color: NSColor.clear)
    private var colorEProperty = ComponentCColorProperty(colorType: .color, state: .normal, isCustom: true, color: NSColor.clear)
    
    private var annotations: [CPDFMarkupAnnotation] = []
    
    private var colorsSavedKey: String?
    
    var pdfView: CPDFListView?
    var viewManager: KMPDFViewManager?
    
    //MARK: - func
    override func viewDidAppear() {
        super.viewDidAppear()
        
        colorSlider.reloadData()
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // Do view setup here.
        
        setupProperty()
    }
    
    override func updateUILanguage() {
        super.updateUILanguage()
        
        colorLabel.stringValue = KMLocalizedString("Color")
    }
    
    override func updateUIThemeColor() {
        super.updateUIThemeColor()
        
        colorLabel.textColor = ComponentLibrary.shared.getComponentColorFromKey("colorText/2")
        colorLabel.font = ComponentLibrary.shared.getFontFromKey("mac/body-s-medium")
         
    }
    
    func getValidAnnotations() -> [CPDFMarkupAnnotation] {
        return annotations
    }
    
    func setupProperty() {
        
        colorGroup.delegate = self
        
        colorSlider.properties = ComponentSliderProperty(size: .m, percent: 1)
        colorSlider.delegate = self
        
        colorOpacitySelect.properties = ComponentSelectProperties(size: .s,
                                                                  state: .normal,
                                                                  creatable: true,
                                                                  text: "100%",
                                                                  textUnit: "%",
                                                                  regexString: "0123456789%")
        if true {
            var opacityItems: [ComponentMenuitemProperty] = []
            for string in ["25%", "50%", "75%", "100%"] {
                let item = ComponentMenuitemProperty(type: .normal, text: string)
                opacityItems.append(item)
            }
            colorOpacitySelect.updateMenuItemsArr(opacityItems)
        }
        colorOpacitySelect.delegate = self
        
    }
    
    func reloadData() {
        //未选中，单选，多选
        guard let pdfView = self.pdfView else {
            return
        }
        let manager = KMAnnotationPropertiesColorManager.manager
        
        self.annotations.removeAll()
        let allAnnotations: [CPDFAnnotation] = pdfView.activeAnnotations as? [CPDFAnnotation] ?? []
        for annotation in allAnnotations {
            if annotation is CPDFMarkupAnnotation {
                annotations.append((annotation as! CPDFMarkupAnnotation))
            }
        }
        
        var firstAnnotation: CPDFMarkupAnnotation? = nil
        if annotations.count > 0 {
            firstAnnotation = annotations.first
        }
        if true {
            var colors: [NSColor] = []
            if let annotation = firstAnnotation {
                if annotation.markupType() == .highlight {
                    colors = manager.markHighlightColors
                    colorsSavedKey = KMMarkupTypeHighlightColorsKey
                } else if annotation.markupType() == .underline {
                    colors = manager.markHighlight_Underline_Colors
                    colorsSavedKey = KMMarkupTypeUnderlineColorsKey
                } else if annotation.markupType() == .squiggly {
                    colors = manager.markHighlight_Wavyline_Colors
                    colorsSavedKey = KMMarkupTypeWavylineColorsKey
                } else if annotation.markupType() == .strikeOut {
                    colors = manager.markHighlight_StrikeThrough_Colors
                    colorsSavedKey = KMMarkupTypeStrikeThroughColorsKey
                } else {
                    colors = manager.markOtherColors
                    colorsSavedKey = KMMarkupTypeOtherColorsKey
                }
            } else {
                if viewManager?.subToolMode == .Highlight {
                    colors = manager.markHighlightColors
                    colorsSavedKey = KMMarkupTypeHighlightColorsKey
                } else if viewManager?.subToolMode == .Underline {
                    colors = manager.markHighlight_Underline_Colors
                    colorsSavedKey = KMMarkupTypeUnderlineColorsKey
                } else if viewManager?.subToolMode == .Waveline {
                    colors = manager.markHighlight_Wavyline_Colors
                    colorsSavedKey = KMMarkupTypeWavylineColorsKey
                } else if viewManager?.subToolMode == .Strikethrough {
                    colors = manager.markHighlight_StrikeThrough_Colors
                    colorsSavedKey = KMMarkupTypeStrikeThroughColorsKey
                } else {
                    colors = manager.markOtherColors
                    colorsSavedKey = KMMarkupTypeOtherColorsKey
                }
            }
            if colors.count > 4 {
                colorAProperty.color = colors[0]
                colorBProperty.color = colors[1]
                colorCProperty.color = colors[2]
                colorDProperty.color = colors[3]
                colorEProperty.color = colors[4]
            }
            colorGroup.setUpWithColorPropertys([colorAProperty, colorBProperty, colorCProperty, colorDProperty], customItemProperty: colorEProperty)
        }
        
        if annotations.count == 0 {
            
            var curColor: NSColor = NSColor.clear
            var opacity: CGFloat = 0
            
            if viewManager?.subToolMode == .Highlight {
                curColor = CPDFMarkupAnnotation.defaultColor(.highlight)
                opacity = CPDFMarkupAnnotation.defaultOpacity(.highlight)
            } else if viewManager?.subToolMode == .Underline {
                curColor = CPDFMarkupAnnotation.defaultColor(.underline)
                opacity = CPDFMarkupAnnotation.defaultOpacity(.underline)
            } else if viewManager?.subToolMode == .Waveline {
                curColor = CPDFMarkupAnnotation.defaultColor(.squiggly)
                opacity = CPDFMarkupAnnotation.defaultOpacity(.squiggly)
            } else if viewManager?.subToolMode == .Strikethrough {
                curColor = CPDFMarkupAnnotation.defaultColor(.strikeOut)
                opacity = CPDFMarkupAnnotation.defaultOpacity(.strikeOut)
            }
            
            colorGroup.currentColor = curColor
            colorGroup.refreshUI()
            
            colorSlider.properties.percent = opacity
            colorSlider.reloadData()
            
            colorOpacitySelect.properties.text = String(format: "%.0f%@", opacity*100, "%")
            colorOpacitySelect.reloadData()
            
        } else if annotations.count == 1 {
            colorGroup.currentColor = firstAnnotation?.color
            colorGroup.refreshUI()
            
            let opacity = firstAnnotation?.opacity ?? 0
            colorSlider.properties.percent = opacity
            colorSlider.reloadData()
            
            colorOpacitySelect.properties.text = String(format: "%.0f%@", opacity*100, "%")
            colorOpacitySelect.reloadData()
        } else {
            let multiColor: Bool = CPDFListView.isAnnotationsContainMultiType(annotations, withType: .color)
            if multiColor == true {
                colorGroup.currentColor = nil
            } else {
                colorGroup.currentColor = firstAnnotation?.color
            }
            colorGroup.refreshUI()
            
            let multiOpacity: Bool = CPDFListView.isAnnotationsContainMultiType(annotations, withType: .opacity)
            if multiOpacity {
                colorSlider.properties.percent = 0
                colorSlider.reloadData()
                
                colorOpacitySelect.resetText("-")
            } else {
                let opacity = firstAnnotation?.opacity ?? 0
                
                colorSlider.properties.percent = opacity
                colorSlider.reloadData()
                
                colorOpacitySelect.properties.text = String(format: "%.0f%@", opacity*100, "%")
                colorOpacitySelect.reloadData()
            }
        }
    }
    
    //MARK: - Mouse
    override func mouseDown(with event: NSEvent) {
        super.mouseDown(with: event)
        
        view.window?.makeFirstResponder(nil)
    }
    
    
}

//MARK: - ComponentCColorDelegate
extension KMHighlightController: ComponentCColorDelegate {
    func componentCColorDidChooseColor(_ view: NSView, _ color: NSColor?) {
        self.componentCColorDidChooseColor(view, color, true)
    }
    
    func componentCColorDidChooseColor(_ view: NSView, _ color: NSColor?, _ refresh: Bool) {
        CPDFAnnotation.updateAnnotations(annotations, newColor: color, withPDFView: pdfView)
        
        if annotations.count == 0 {
            CPDFMarkupAnnotation.updateMarkupAnnotationDefaultColor(KMPDFViewManager.getValidPDFAnnotationType(viewManager?.subToolMode), color)
        } else {
            for annotation in annotations {
                CPDFMarkupAnnotation.updateMarkupAnnotationDefaultColor(annotation.exchangeToAnnotationType(annotation.markupType()), color)
            }
        }
        
        NotificationCenter.default.post(name: toolbarImageColorChangedNotificationName, object: nil)
        
        if refresh == true {
            reloadData()
        }
    }
    
    func componentCColorDidRightMouseUpWithStrings(_ view: NSView) -> [String] {
        return [KMLocalizedString("Change Color"), KMLocalizedString("Restore default color")]
    }
    
    func componentCColorDidRightMenuItemClicked(_ view: NSView, menuItemProperty: ComponentMenuitemProperty?) {
        if menuItemProperty?.text == KMLocalizedString("Change Color") {
            if NSColorPanel.sharedColorPanelExists {
                NSColorPanel.shared.setTarget(nil)
                NSColorPanel.shared.setAction(nil)
            }
            NSColorPanel.shared.setTarget(self)
            NSColorPanel.shared.setAction(#selector(colorChoose(_:)))
            if let colorItem = view as? ComponentCColorItem, let color = colorItem.properties?.color {
                NSColorPanel.shared.color = color
            }
            
            let viewRect = view.superview?.convert(view.frame, to: nil) ?? CGRectZero
            var rect = NSColorPanel.shared.frame
            rect.origin.x = viewRect.minX
            rect.origin.y = viewRect.minY - 30
            NSColorPanel.shared.setFrame(rect, display: true)
            
            NSColorPanel.shared.orderFront(nil)
        } else if menuItemProperty?.text == KMLocalizedString("Restore default color") {
            if let colorItem = colorGroup.rightClickedItem, let key = colorsSavedKey {
                let colors: [NSColor] = KMAnnotationPropertiesColorManager.manager.defaultColors(key: key)
                if colors.count > 4, colorItem.itemIndex >= 0, colorItem.itemIndex < colors.count {
                    colorItem.properties?.color = colors[colorItem.itemIndex]
                    colorItem.reloadData()
                    colorGroup.componentCColorDidChoosePanelColor(colorGroup, nil)
                     
                    self.componentCColorDidChooseColor(colorGroup, colorItem.properties?.color, false)
                }
            }
        }
    }
    
    @objc func colorChoose(_ sender: Any) {
        if let colorItem = colorGroup.rightClickedItem {
            let color = NSColorPanel.shared.color
            colorItem.properties?.color = color
            
            colorItem.reloadData()
            
            colorGroup.componentCColorDidChoosePanelColor(colorGroup, nil)
            
            self.componentCColorDidChooseColor(colorGroup, color, false)
        }
    }
    
    func componentCColorGroupColorsUpdates(_ view: NSView, _ colors: [NSColor]) {
        if annotations.count == 0 {
            if viewManager?.subToolMode == .Highlight {
                KMAnnotationPropertiesColorManager.manager.updateDefaultColors(colors, forKey: KMMarkupTypeHighlightColorsKey)
            } else if viewManager?.subToolMode == .Underline {
                KMAnnotationPropertiesColorManager.manager.updateDefaultColors(colors, forKey: KMMarkupTypeUnderlineColorsKey)
            } else if viewManager?.subToolMode == .Waveline {
                KMAnnotationPropertiesColorManager.manager.updateDefaultColors(colors, forKey: KMMarkupTypeWavylineColorsKey)
            } else if viewManager?.subToolMode == .Strikethrough {
                KMAnnotationPropertiesColorManager.manager.updateDefaultColors(colors, forKey: KMMarkupTypeStrikeThroughColorsKey)
            }
        } else {
            for annotation in annotations {
                if annotation.markupType() == .highlight {
                    KMAnnotationPropertiesColorManager.manager.updateDefaultColors(colors, forKey: KMMarkupTypeHighlightColorsKey)
                } else if annotation.markupType() == .underline {
                    KMAnnotationPropertiesColorManager.manager.updateDefaultColors(colors, forKey: KMMarkupTypeUnderlineColorsKey)
                } else if annotation.markupType() == .squiggly {
                    KMAnnotationPropertiesColorManager.manager.updateDefaultColors(colors, forKey: KMMarkupTypeWavylineColorsKey)
                } else if annotation.markupType() == .strikeOut {
                    KMAnnotationPropertiesColorManager.manager.updateDefaultColors(colors, forKey: KMMarkupTypeStrikeThroughColorsKey)
                }
            }
        }
    }
}

//MARK: - ComponentSliderDelegate
extension KMHighlightController: ComponentSliderDelegate {
    func componentSliderDidUpdate(_ view: ComponentSlider) {
        let opacity = view.properties.percent
        
        CPDFAnnotation.updateAnnotations(annotations, newOpacity: opacity, withPDFView: pdfView)
        
        if annotations.count == 0 {
            CPDFMarkupAnnotation.updateMarkupAnnotationDefaultOpacity(KMPDFViewManager.getValidPDFAnnotationType(viewManager?.subToolMode), opacity)
        } else {
            for annotation in annotations {
                CPDFMarkupAnnotation.updateMarkupAnnotationDefaultOpacity(annotation.exchangeToAnnotationType(annotation.markupType()), opacity)
            }
        }
        
        reloadData()
        
    }
}

//MARK: - ComponentSelectDelegate
extension KMHighlightController: ComponentSelectDelegate {
    func componentSelectDidSelect(view: ComponentSelect?, menuItemProperty: ComponentMenuitemProperty?) {
        if var result = menuItemProperty?.text {
            if let textUnit = view?.properties.textUnit {
                result = result.stringByDeleteCharString(textUnit)
            }
            let opacity = max(0, min(1, result.stringToCGFloat()/100))
            CPDFAnnotation.updateAnnotations(annotations, newOpacity: opacity, withPDFView: pdfView)
            
            if annotations.count == 0 {
                CPDFMarkupAnnotation.updateMarkupAnnotationDefaultOpacity(KMPDFViewManager.getValidPDFAnnotationType(viewManager?.subToolMode), opacity)
            } else {
                for annotation in annotations {
                    CPDFMarkupAnnotation.updateMarkupAnnotationDefaultOpacity(annotation.exchangeToAnnotationType(annotation.markupType()), opacity)
                }
            }
            
            reloadData()
        }
    }
    
    func componentSelectTextDidEndEditing(_ view: ComponentSelect, removeUnit text: String?) {
        if let result = text {
            let opacity = max(0, min(1, result.stringToCGFloat()/100))
            CPDFAnnotation.updateAnnotations(annotations, newOpacity: opacity, withPDFView: pdfView)
            
            if annotations.count == 0 {
                CPDFMarkupAnnotation.updateMarkupAnnotationDefaultOpacity(KMPDFViewManager.getValidPDFAnnotationType(viewManager?.subToolMode), opacity)
            } else {
                for annotation in annotations {
                    CPDFMarkupAnnotation.updateMarkupAnnotationDefaultOpacity(annotation.exchangeToAnnotationType(annotation.markupType()), opacity)
                }
            }
            
            reloadData()
            
        }
    }
}