PDF_Office/PDF Office/PDF Master/Class/PDFWindowController/MainWindowController/SKPresentationOptionsSheetController.swift

//
//  SKPresentationOptionsSheetController.swift
//  PDF Reader Pro
//
//  Created by liujiajie on 2024/1/17.
//

import Cocoa

typealias closePresentationControllerCallBack = (_ vc: SKPresentationOptionsSheetController) -> ()

let RIGHTARROW_CHARACTER: unichar = 0x2192

let PAGE_COLUMNID = "page" 
let IMAGE_COLUMNID = "image"
let TRANSITIONSTYLE_KEY = "transitionStyle" 
let DURATION_KEY = "duration"
let SHOULDRESTRICT_KEY = "shouldRestrict"
let PROPERTIES_KEY = "properties"
let CONTENTOBJECT_BINDINGNAME = "contentObject"
let MAX_PAGE_COLUMN_WIDTH: CGFloat = 100.0
let TABLE_OFFSET: CGFloat = 8.0
var SKTransitionPropertiesObservationContext = UnsafeMutableRawPointer(mutating: "SKTransitionPropertiesObservationContext")
var SKPDFViewTransitionsObservationContext: CChar?

class SKPresentationOptionsSheetController: NSWindowController {
    @IBOutlet var notesDocumentPopUpButton: NSPopUpButton!
    @IBOutlet var tableView: KMBotaTableView!
    @IBOutlet var separateCheckButton: NSButton!
    @IBOutlet var boxes, transitionLabels, transitionControls, buttons: NSArray!
//    @IBOutlet var arrayController: NSArrayController!
    @IBOutlet var effectPopUpButton: NSPopUpButton!
    @IBOutlet var effectLabel: NSTextField!
    @IBOutlet var durationLabel: NSTextField!
    @IBOutlet var durationSlider: NSSlider!
    @IBOutlet var durationTF: NSTextField!
    @IBOutlet var extentLabel: NSTextField!
    @IBOutlet var screeBtn: NSButtonCell!
    @IBOutlet var pageBtn: NSButtonCell!
    @IBOutlet var synchoronizBox: NSBox!
    @IBOutlet var cancelBtn: NSButton!
    @IBOutlet var okBtn: NSButton!
    @IBOutlet var pageTransitionBox: NSBox!
    
    var closeCallBack: closePresentationControllerCallBack?
    var separate = false
    var transition: KMTransitionInfo = KMTransitionInfo()
    private var transitions_: NSArray?
    var transitions: NSArray? {
        get {
            return self.transitions_
        }
        set{
            if self.transitions_ != newValue {
//                (undoRedoManager?.prepare(withInvocationTarget: self) as AnyObject).transitions = transitions
                self.transitions_ = newValue
                stopObservingTransitions(infos: transitions as! [KMTransitionInfo])
                startObservingTransitions(transitions as! [KMTransitionInfo])
            }
        }
    }
    var currentTransitions: NSArray? {
        get{
            return self.separate ? self.transitions : [transition as Any]
        }
    }
    var pageTransitions: NSArray? {
        get{
            if self.separate && self.transitions?.count ?? 0 > 0 {
                return [transitions?.value(forKey: PROPERTIES_KEY) as Any]
            }
            return nil
        }
    }
    var notesDocument: NSDocument? {
        get{
            _ = self.window
            return self.notesDocumentPopUpButton.selectedItem?.representedObject as? NSDocument
        }
    }
    var isScrolling: Bool {
        get{
            let scroller = self.tableView?.enclosingScrollView?.verticalScroller as? KMScroller
            return scroller?.isScrolling ?? false
        }
    }
    var undoRedoManager = UndoManager()
    var controller: KMMainViewController?
    var transitionController: SKTransitionController!
    
    private weak var proxyDelegate_: SKTransitionControllerDelegate?
    
    class func keyPathsForValuesAffectingCurrentTransitions() -> Set<String> { 
        return Set<String>(["separate", "transitions", "transition"])
    }
    
//    convenience init(for aController: KMMainViewController) {
//        super.init(window: window)
//        controller = aController
//        separate = false
//        transition = KMTransitionInfo()
//        transitions = nil
//    }
    
    override var windowNibName: NSNib.Name?{
        return "TransitionSheet"
    }
    
    override init(window: NSWindow?) {
        super.init(window: window)
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
    }
    
    override func windowDidLoad() {
        super.windowDidLoad()
        
        let count = SKTransitionController.transitionNames().count
        for i in 0..<count {
            self.effectPopUpButton.addItem(withTitle: SKTransitionController.localizedName(for: SKAnimationTransitionStyle(rawValue: UInt(i)) ?? .noTransition))
            self.effectPopUpButton.lastItem?.tag = i
        }
        self.notesDocumentPopUpButton.item(at: 0)?.title = NSLocalizedString("None", comment: "Menu item title")

//        creatTransitionController()
        let transitionController = self.controller?.listView.transitionController
        self.proxyDelegate_ = transitionController?.delegate
        transitionController?.delegate = self
        self.transition.transitionStyle = transitionController?.transitionStyle ?? .noTransition
        self.transition.duration = Float(transitionController?.duration ?? 0)
        self.transition.shouldRestrict = transitionController?.shouldRestrict ?? false
        self.startObservingTransitions([self.transition])

        self.separateCheckButton.sizeToFit()
//        transitionControls.lastObject.sizeToFit()

        SKAutoSizeButtons(buttons as? [Any], true)
        let dw = SKAutoSizeLabelFields(transitionLabels as? [Any], transitionControls as? [Any], false)
        if abs(dw) > 0.0 {
            SKResizeWindow(self.window, dw)
            SKShiftAndResizeViews(self.boxes as? [Any], -dw, dw)
            SKShiftAndResizeView(self.separateCheckButton, -dw, 0.0)
        }

        // collapse the table
        self.window?.setFrame(NSInsetRect(window?.frame ?? .zero, 0.5 * (NSWidth(tableView.enclosingScrollView!.frame) + TABLE_OFFSET), 0.0), display: false)

        self.tableView.registerForDraggedTypes(KMTransitionInfo.readableTypesForPasteboard(pasteboard: NSPasteboard(name: NSPasteboard.Name.drag)) as! [NSPasteboard.PasteboardType])
        self.tableView.delegate = self
        self.tableView.dataSource = self
        self.tableView.botaDelegate = self
        self.tableView.setTypeSelectHelper(SKTypeSelectHelper(matchOption: .SKFullStringMatch))
        self.tableView.hasImageToolTips = true
        self.tableView.backgroundColor = NSColor.mainSourceListBackgroundColor()

        if (transitionController?.pageTransitions != nil && transitionController?.pageTransitions.count ?? 0 > 0) {
            undoManager?.disableUndoRegistration()
            self.separate = true
            undoManager?.enableUndoRegistration()
        }

        // set the current notes document and observe changes for the popup
        self.handleDocumentsDidChangeNotification(notification: nil)
        let docIndex = self.notesDocumentPopUpButton.indexOfItem(withRepresentedObject: self.controller?.myDocument/*presentationNotesDocument*/)
        self.notesDocumentPopUpButton.selectItem(at: docIndex > 0 ? docIndex : 0)
        
        NotificationCenter.default.addObserver(self, selector: #selector(handleDocumentsDidChangeNotification(notification:)), name: NSNotification.Name("SKDocumentDidShowNotification"), object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(handleDocumentsDidChangeNotification(notification:)), name: NSNotification.Name("SKDocumentControllerDidRemoveDocumentNotification"), object: nil)
    }
    
    func stopObservingTransitions(infos: [KMTransitionInfo]) {
//        for info in infos {
//            info.removeObserver(self, forKeyPath: TRANSITIONSTYLE_KEY) 
//            info.removeObserver(self, forKeyPath: DURATION_KEY)
//            info.removeObserver(self, forKeyPath: SHOULDRESTRICT_KEY)
//        }
    }
    
//    func creatTransitionController() {
//        transitionController = SKTransitionController(for: controller?.listView)//controller?.mainViewController.listView.transitionController
//        let options: NSKeyValueObservingOptions = [.new, .old]
//        transitionController?.addObserver(self, forKeyPath: "transitionStyle", options: options, context: &SKPDFViewTransitionsObservationContext)
//        transitionController?.addObserver(self, forKeyPath: "duration", options: options, context: &SKPDFViewTransitionsObservationContext)
//        transitionController?.addObserver(self, forKeyPath: "shouldRestrict", options: options, context: &SKPDFViewTransitionsObservationContext)
//        transitionController?.addObserver(self, forKeyPath: "pageTransitions", options: options, context: &SKPDFViewTransitionsObservationContext)
//    }
    
    func startObservingTransitions(_ infos: [KMTransitionInfo]) {
//        for info in infos {
//            info.addObserver(self, forKeyPath: TRANSITIONSTYLE_KEY, options: [.new, .old], context: &SKTransitionPropertiesObservationContext)
//            info.addObserver(self, forKeyPath: DURATION_KEY, options: [.new, .old], context: &SKTransitionPropertiesObservationContext)
//            info.addObserver(self, forKeyPath: SHOULDRESTRICT_KEY, options: [.new, .old], context: &SKTransitionPropertiesObservationContext)
//        }
    }
    
    func setValue(_ value: Any?, forKey key: String, ofTransition info: KMTransitionInfo) {
        info.setValue(value, forKey: key)
    }
    override class func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
        if context == &SKTransitionPropertiesObservationContext {
            guard let info = object as? KMTransitionInfo else {
                super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
                return
            }
            let newValue = change?[.newKey]
            let oldValue = change?[.oldKey]
            
            let newNonNullValue = newValue as? NSNull == nil ? newValue : nil
            let oldNonNullValue = oldValue as? NSNull == nil ? oldValue : nil
            
//            if (newNonNullValue != nil || oldNonNullValue != nil) && newNonNullValue != oldNonNullValue {
//                (undoManager?.prepare(withInvocationTarget: self) as AnyObject).setValue(oldNonNullValue, forKey: keyPath, ofTransition: info)
//            }
            if (newNonNullValue != nil || oldNonNullValue != nil){
               
            }
        } else {
            super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
        }
    }
    
    // MARK: - Private
    
    private func makeTransitions() {
        if transitions != nil {
            return
        }
        
        let tableColumn = self.tableView?.tableColumn(withIdentifier: NSUserInterfaceItemIdentifier(rawValue: PAGE_COLUMNID))
        let cell = tableColumn?.dataCell
        var labelWidth: CGFloat = 0.0
        
        var array = [Any]()
        let dictionary: NSDictionary? = self.transition.properties
        let arr: NSArray? = transitionController.pageTransitions as NSArray?
        let ptEnum = arr?.objectEnumerator()
        var tn: KMThumbnail? = nil
        
        for next in (controller?.leftSideViewController.thumbnails)! {
            if tn != nil {
                let info = KMTransitionInfo()
                info.thumbnail = tn
                info.label = "\(tn!.label)"+"→"+"\(next.label)"
                info.properties = ((ptEnum?.nextObject()) != nil) ? ptEnum?.nextObject() as? NSDictionary : dictionary
                array.append(info)
                (cell as AnyObject).setStringValue(info.label)
                labelWidth = max(labelWidth, ceil(((cell as AnyObject).cellSize?.width)!))
            }
            tn = next
        }
        
        labelWidth = min(labelWidth, MAX_PAGE_COLUMN_WIDTH)
        tableColumn?.minWidth = labelWidth
        tableColumn?.maxWidth = labelWidth
        tableColumn?.width = labelWidth
        
        var frame: NSRect = self.tableView?.enclosingScrollView?.frame ?? .zero
        let wi: CGFloat = 61//tableColumn?.value(forKeyPath: "@sum.width") as! CGFloat
        frame.size.width = 19.0 + wi
        self.tableView?.enclosingScrollView?.frame = frame
        
        self.transitions = array as NSArray
    }
    
    private func changePageTransitionType() {
//                SKImageToolTipWindow.sharedToolTipWindow().orderOut(nil)
        let window = self.window
        let isVisible = window?.isVisible ?? false
        var frame = window?.frame ?? NSRect.zero
        let scrollView = tableView?.enclosingScrollView
        var extraWidth: CGFloat
        let firstResponder = window?.firstResponder
        var editor: NSTextView? = nil
        
        if let textView = firstResponder as? NSTextView {
            editor = textView
            if textView.isFieldEditor {
                //                        firstResponder = textView.delegate
            }
        }
        
        if let editor = editor, window?.firstResponder != editor {
            window?.makeFirstResponder(firstResponder)
        }
        
        if separate {
            makeTransitions()
            
            extraWidth = (scrollView?.frame.width ?? 0) + TABLE_OFFSET
            frame.size.width += extraWidth
            frame.origin.x -= floor(0.5 * extraWidth)
            window?.setFrame(frame, display: isVisible, animate: isVisible)
            scrollView?.isHidden = false
        } else {
            scrollView?.isHidden = true
            extraWidth = (scrollView?.frame.width ?? 0) + TABLE_OFFSET
            frame.size.width -= extraWidth
            frame.origin.x += floor(0.5 * extraWidth)
            window?.setFrame(frame, display: isVisible, animate: isVisible)
        }
        
        //                (undoRedoManager.prepare(withInvocationTarget: self) as AnyObject).separate = sparate == fasle
        
    }
    
    // Actions
    
    @IBAction func pageTransitionAction(_ sender: NSButton) {
        self.separate = sender.state == .on
       
        self.changePageTransitionType()
    }
    
    @IBAction func changeDurationSlider(_ sender: NSSlider) {
        self.durationTF.stringValue = sender.stringValue
    }
    
    @IBAction func cancelAction(_ sender: Any) {
        if let handle = self.closeCallBack {
            handle(self)
        }
    }
    
    @IBAction func okAction(_ sender: Any) {
        if let handle = self.closeCallBack {
            handle(self)
        }
        if ((undoManager?.canUndo) != nil) {
            self.transitionController?.transitionStyle = transition.transitionStyle
            self.transitionController?.duration = CGFloat(transition.duration)
            self.transitionController?.shouldRestrict = transition.shouldRestrict
            self.transitionController?.pageTransitions = pageTransitions as? [Any]
            (self.controller?.undoManager)?.setActionName(NSLocalizedString("Change Transitions", comment: "Undo action name"))
        }
        self.controller?.myDocument/*presentationNotesDocument*/ = notesDocument
    }
    
    // Noti Actions
    
    @objc private func handleDocumentsDidChangeNotification(notification: Notification?) {
        guard let currentDoc = notesDocumentPopUpButton.selectedItem?.representedObject else { return }
        while notesDocumentPopUpButton.numberOfItems > 1 {
            notesDocumentPopUpButton.removeItem(at: notesDocumentPopUpButton.numberOfItems - 1)
        }

        guard let document = controller?.document as? NSDocument,
              let pageCount = controller?.listView.document?.pageCount else { return }

        let documents = NSMutableArray()
        for doc in NSDocumentController.shared.documents {
            if let pdfDoc = doc as? CPDFDocument,
                doc != document,
                pdfDoc.pageCount == pageCount {
                documents.add(doc)
            }
        }

        let sortDescriptor = NSSortDescriptor(key: "displayName", ascending: true)
        documents.sort(using: [sortDescriptor])

        for doc in documents {
            notesDocumentPopUpButton.addItem(withTitle: (doc as AnyObject).displayName)
            notesDocumentPopUpButton.lastItem?.representedObject = doc
        }

        let docIndex = notesDocumentPopUpButton.indexOfItem(withRepresentedObject: currentDoc)
        notesDocumentPopUpButton.selectItem(at: docIndex == -1 ? 0 : docIndex)
    }
}

extension SKPresentationOptionsSheetController: NSWindowDelegate {
    func windowWillReturnUndoManager(_ window: NSWindow) -> UndoManager? {
        return self.undoRedoManager
    }
}

extension SKPresentationOptionsSheetController: SKTransitionControllerDelegate {
    func transitionController(_ controller: SKTransitionController!, valueDidChanged info: [AnyHashable : Any]!) {
        // 消息转发
        self.proxyDelegate_?.transitionController(controller, valueDidChanged: info)
    }
}

extension SKPresentationOptionsSheetController: NSTableViewDelegate, NSTableViewDataSource {
    func numberOfRows(in tableView: NSTableView) -> Int {
        return transitions?.count ?? 0
    }
//    func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? {
//        let identifier = tableColumn!.identifier
//        let info = transitions?[row]
//        if identifier.rawValue == PAGE_COLUMNID {
//
//        } else if identifier.rawValue == IMAGE_COLUMNID {
//
//        }
//        return nil
//    }
    func tableView(_ tableView: NSTableView, objectValueFor tableColumn: NSTableColumn?, row: Int) -> Any? {
        return nil
    }
    func tableView(_ tableView: NSTableView, writeRowsWith rowIndexes: IndexSet, to pboard: NSPasteboard) -> Bool {
        if rowIndexes.count == 1 {
            pboard.clearContents()
            pboard.writeObjects([transitions?[rowIndexes.first ?? 0] as! NSPasteboardWriting])
            return true
        } else {
            return false
        }
    }
    
    func tableView(_ tableView: NSTableView, validateDrop info: NSDraggingInfo, proposedRow row: Int, proposedDropOperation dropOperation: NSTableView.DropOperation) -> NSDragOperation {
        if info.draggingPasteboard.canReadObject(forClasses: [KMTransitionInfo.self], options: [:]) {
            if dropOperation == .above {
                tableView.setDropRow(-1, dropOperation: .on)
            }
            return .every
        }
        return []
    }
   
    func tableView(_ tableView: NSTableView, acceptDrop info: NSDraggingInfo, row: Int, dropOperation: NSTableView.DropOperation) -> Bool {
        let pboard = info.draggingPasteboard
        if dropOperation == .on {
            guard let infos = pboard.readObjects(forClasses: [KMTransitionInfo.self], options: [:]) as? [KMTransitionInfo], infos.count > 0 else {
                return false
            }
            let propertie: NSDictionary? = infos[0].properties
            
            if row == -1 {
                transitions?.setValue(propertie, forKey: PROPERTIES_KEY)
            } else {
                let transit: KMTransitionInfo = transitions?[row] as! KMTransitionInfo
                transit.properties = propertie
            }
            return true
        }
        return false
    }
}

extension SKPresentationOptionsSheetController: KMBotaTableViewDelegate {
    func tableView(_ aTableView: NSTableView, imageContextForRow rowIndex: Int) -> AnyObject? {
        return controller?.document?.page(at: UInt(rowIndex))
    }
    
    func tableView(_ aTableView: NSTableView, copyRowsWithIndexes rowIndexes: IndexSet) {
        let pboard = NSPasteboard.general
        pboard.clearContents()
        pboard.writeObjects([transitions?[rowIndexes.first ?? 0] as! NSPasteboardWriting])
    }
    func tableView(_ aTableView: NSTableView, canCopyRowsWithIndexes rowIndexes: IndexSet) -> Bool {
        return true
    }
    func tableView(_ aTableView: NSTableView, pasteFromPasteboard pboard: NSPasteboard) {
        guard let infos = pboard.readObjects(forClasses: [KMTransitionInfo.self], options: [:]) as? [KMTransitionInfo], infos.count > 0 else { return }
        let arr: NSArray = transitions?.objects(at: tableView.selectedRowIndexes) as! NSArray
        arr.setValue(infos[0].properties, forKey: PROPERTIES_KEY)
    }
    func tableView(_ aTableView: NSTableView, canPasteFromPasteboard pboard: NSPasteboard) -> Bool {
        return (tableView.selectedRow != -1 && pboard.canReadObject(forClasses: [KMTransitionInfo.self], options: [:]))
    }
    func tableView(_ aTableView: NSTableView, typeSelectHelperSelectionStrings aTypeSelectHelper: SKTypeSelectHelper) -> NSArray {
        return transitions?.value(forKeyPath: "thumbnail.label") as! NSArray
    }
}