PDF_Office/PDF Office/PDF Master/KMClass/NewBatch/View/Setting/Watermark/KMBatchWatermarkView.swift

//
//  KMBatchWatermarkView.swift
//  PDF Master
//
//  Created by lizhe on 2023/1/16.
//

import Cocoa
import KMComponentLibrary

class KMBatchWatermarkModel: KMBatchSettingItemViewModel {
    var watermarkModel: KMWatermarkModel?
}

class KMBatchWatermarkView: KMBatchSettingItemView {
    @IBOutlet weak var waterContentView: NSView!
    
    @IBOutlet var saveTemplateButton: ComponentButton!
    @IBOutlet var applyButton: ComponentButton!
    @IBOutlet var applyBtnLeftConst: NSLayoutConstraint!
    
    var propertyController: KMNWatermarkPropertyController = KMNWatermarkPropertyController.init()
    var templatesController: KMNWatermarkTemplateController = KMNWatermarkTemplateController()
    
    var saveTemplateMessage: ComponentMessage = ComponentMessage()
    
    var pdfDocument: CPDFDocument?
    
    var currentWatermarkData: KMWatermarkModel?
    
    weak open var delegate: KMWatermarkControllerDelegate?
    
    var editSubType: KMPDFEditSubModeType = .none {
        didSet {
            resetUI()
        }
    }
    
    var data: KMBatchWatermarkModel = KMBatchWatermarkModel()
    
    //MARK: - func
    override func setup() {
        super.setup()
         
        propertyController.view.frame = waterContentView.bounds
        propertyController.view.autoresizingMask = [.width, .height]
        propertyController.delegate = self
        propertyController.view.isHidden = true
        propertyController.isInBatchMode = true
        waterContentView.addSubview(propertyController.view)
        
        templatesController.view.frame = waterContentView.bounds
        templatesController.view.autoresizingMask = [.width, .height]
        templatesController.delegate = self
        templatesController.view.isHidden = true
        waterContentView.addSubview(templatesController.view)
        
        setupProperty()
        
        reloadInfoView()
    }
    
    override func reloadData() {
        super.reloadData()
        
        var applyEnable = true
        if let model = self.currentWatermarkData {
            if model.watermarkType == .text {
                if model.text == nil || model.text?.count == 0 {
                    applyEnable = false
                }
            } else if model.watermarkType == .image {
                if model.imagePath == nil {
                    applyEnable = false
                }
            }
        } else {
            applyEnable = false
        }
        
        saveTemplateButton.properties.isDisabled = !applyEnable
        saveTemplateButton.reloadData()
        
        if self.filesData.count == 0 {
            applyEnable = false
        }
        applyButton.properties.isDisabled = !applyEnable
        applyButton.reloadData()
        
    }
    
    func reloadInfoView() {
        if editSubType == .template {
            templatesController.reloadData()
        } else if editSubType == .add {
            propertyController.editSubType = editSubType
            propertyController.watermarkData = KMWatermarkManager.defaultManager.defaultWatermarkData
            propertyController.watermarkData.cPDFWatermark = CPDFWatermark(document: pdfDocument, type: .text)
            propertyController.reloadData()
            
            currentWatermarkData = propertyController.watermarkData
        } else if editSubType == .edit {
            propertyController.editSubType = editSubType
            propertyController.reloadData()
        }
    }
    
    func setupProperty() {
        saveTemplateMessage.properties = ComponentMessageProperty(messageType: .success, title: KMLocalizedString("Saved Template"))
        
        saveTemplateButton.properties = ComponentButtonProperty(type: .default_tertiary,
                                                                size: .m,
                                                                state: .normal,
                                                                onlyIcon: true,
                                                                icon: NSImage(named: "icon_wm_template_save"),
                                                                keepPressState: false)
        saveTemplateButton.setTarget(self, action: #selector(saveTemplateButtonAction(_:)))
        saveTemplateButton.reloadData()
        
        applyButton.properties = ComponentButtonProperty(type: .primary,
                                                         size: .m,
                                                         state: .normal,
                                                         buttonText: KMLocalizedString("Apply"),
                                                         keepPressState: false)
        applyButton.setTarget(self, action: #selector(applyButtonAction(_:)))
        applyButton.reloadData()
    }
    
    func resetUI() {
        propertyController.view.isHidden = true
        templatesController.view.isHidden = true
 
        if editSubType == .template {
            templatesController.view.isHidden = false
            
            applyBtnLeftConst.constant = 16
            saveTemplateButton.isHidden = true
        } else if editSubType == .add {
            propertyController.view.isHidden = false
            propertyController.editSubType = editSubType
            
            applyBtnLeftConst.constant = 68
            saveTemplateButton.isHidden = false
        } else if editSubType == .edit {
            propertyController.view.isHidden = false
            propertyController.editSubType = editSubType
            
            applyBtnLeftConst.constant = 16
            saveTemplateButton.isHidden = true
        }
    }
    
    //MARK: - Action
    @objc func saveTemplateButtonAction(_ sender: NSButton) {
        propertyController.saveButtonClicked(propertyController.saveButton)
        
    }
    
    @objc func applyButtonAction(_ sender: NSButton) {
        if KMMemberInfo.shared.isLogin == false {
            KMLoginWindowsController.shared.showWindow(nil)
            return
        }
        
        self.data.watermarkModel = self.currentWatermarkData
         
        if self.batchExport != nil {
            self.batchExport!(self, self.data)
        }
    }
    
}

//MARK: - KMNWatermarkPropertyControllerDelegate
extension KMBatchWatermarkView: KMNWatermarkPropertyControllerDelegate {
    func watermarkPropertyControllerDidRemoveWatermark(_ controller: KMNWatermarkPropertyController, _ type: CPDFWatermarkType) {
        if type == .text {
            controller.watermarkData.cPDFWatermark = nil
            controller.watermarkData.cPDFWatermark = CPDFWatermark(document: pdfDocument, type: .text)
        } else if type == .image {
            controller.watermarkData.cPDFWatermark = nil
            controller.watermarkData.cPDFWatermark = CPDFWatermark(document: pdfDocument, type: .image)
        }
    }
    
    func watermarkPropertyControllerDidUpdate(_ controller: KMNWatermarkPropertyController) {
        currentWatermarkData = controller.watermarkData
        
        reloadData()
        
    }
    
    func watermarkPropertyControllerDidChangetoTemplate(_ controller: KMNWatermarkPropertyController) {
        editSubType = .template
        
        currentWatermarkData = nil
        
    }
    
    func watermarkPropertyControllerSaveTemplateSuccess(_ controller: KMNWatermarkPropertyController, _ data: KMWatermarkModel) {
        saveTemplateMessage.frame = CGRectMake((CGRectGetWidth(self.frame) - saveTemplateMessage.properties.propertyInfo.viewWidth)/2,
                                               CGRectGetHeight(self.frame) - saveTemplateMessage.properties.propertyInfo.viewHeight - 8,
                                               saveTemplateMessage.properties.propertyInfo.viewWidth,
                                               saveTemplateMessage.properties.propertyInfo.viewHeight)
        saveTemplateMessage.reloadData()
        saveTemplateMessage.show(inView: self, autoHideSeconde: 2)
        
        editSubType = .template
         
        templatesController.selectedWatermark = data
        templatesController.reloadData()
         
        currentWatermarkData = templatesController.selectedWatermark
        
        reloadData()
        
    }
    
    func watermarkPropertyControllerCancelTemplateEdit(_ controller: KMNWatermarkPropertyController) {
 
        currentWatermarkData = nil
        reloadData()
        
        editSubType = .template
         
        templatesController.reloadData()
        
    }
    
}

//MARK: - KMNWatermarkTemplateControllerDelegate
extension KMBatchWatermarkView: KMNWatermarkTemplateControllerDelegate {
    func templateControllerDidAddWatermarkData(_ controller: KMNWatermarkTemplateController) {
        editSubType = .add
        
        propertyController.watermarkData = KMWatermarkManager.defaultManager.defaultWatermarkData
        if let value = propertyController.watermarkData.imagePath {
            propertyController.watermarkData.cPDFWatermark = CPDFWatermark(document: pdfDocument, type: .image)
        } else {
            propertyController.watermarkData.cPDFWatermark = CPDFWatermark(document: pdfDocument, type: .text)
        }
        propertyController.reloadData()
        
        currentWatermarkData = propertyController.watermarkData
        
        reloadData()
        
    }
    
    func templateControllerDidEditWatermarkData(_ controller: KMNWatermarkTemplateController, _ watermark: KMWatermarkModel) {
        editSubType = .edit
        
        propertyController.watermarkData = watermark
        propertyController.originalDataDict = KMWatermarkManager.defaultManager.parseWaterMark(model: watermark)
        propertyController.reloadData()
        
        currentWatermarkData = propertyController.watermarkData
        reloadData()
        
        templatesController.selectedWatermark = nil
    }
    
    func templateControllerDidSelectedChanged(_ controller: KMNWatermarkTemplateController) {
        currentWatermarkData = controller.selectedWatermark

        reloadData()
        
    }
}