PDF_Office/PDF Office/PDF Master/Class/Document/KMMainDocument.swift

//
//  KMMainDocument.swift
//  PDF Reader Pro
//
//  Created by wanjun on 2022/12/6.
//

import Cocoa
import CoreFoundation

@objc enum KMArchiveMask: Int {
    case diskImage       = 1
    case email           = 2
}

typealias KMMainDocumentCloudUploadHanddler = (@escaping(Bool, String)->()) -> ()
@objcMembers class KMMainDocument: CTTabContents {
    struct MDFlags {
        var exportOption: UInt32 // assuming this is a 2-bit field, change to appropriate data type
        var exportUsingPanel: UInt32 // assuming this is a 1-bit field, change to appropriate data type
        var gettingFileType: UInt32 // assuming this is a 1-bit field, change to appropriate data type
        var convertingNotes: UInt32 // assuming this is a 1-bit field, change to appropriate data type
        var needsPasswordToConvert: UInt32 // assuming this is a 1-bit field, change to appropriate data type
    }
    
    var mainViewController: KMMainViewController?
    var homeWindowController: KMHomeWindowController?
    var homeViewController: KMHomeViewController?
    var bookmarkSheetController: KMBookmarkSheetController?
    var bookmarkController: KMBookmarkController?
    var isNewCreated: Bool = false
    var closedByUserGestureFlag: Bool = false   // 标记 closedByUserGesture 这个状态需要延后存储(如果需要)
    var cloud: Bool = false
    var cloudUploadHanddler: KMMainDocumentCloudUploadHanddler?
    var isUnlockFromKeychain: Bool = false
    private var _saveAsing = false
    var fileUpdateChecker: SKFileUpdateChecker?
    var mdFlags: MDFlags?
    var currentDocumentSetup: [String: Any] {
        get {
            var tempSetup: [String: Any] = [:]
            var tempMainSetup: [String: Any] = mainViewController?.currentSetup() ?? [:]
            let data = (fileURL != nil) ? SKAlias.init(url: fileURL).data : nil
            let filePath = fileURL?.path ?? ""
            
            tempSetup.updateValue(filePath, forKey: KMDocumentSetupFileNameKey)
            if data != nil {
                tempSetup.updateValue(data!, forKey: KMDocumentSetupAliasKey)
            }
            
            if tempSetup.count != 0 {
                tempSetup.merge(tempMainSetup) { (_, new) in new }
            }
            return tempSetup
        }
        set {
            
        }
    }
    
    private var _saveToURL: URL?
    var saveToURL: URL? {
        get {
            return self._saveToURL
        }
    }
    
    weak var watermarkSaveDelegate: AnyObject?
    private var _trackEvents = IndexSet()
    
    override func save(to url: URL, ofType typeName: String, for saveOperation: NSDocument.SaveOperationType, delegate: Any?, didSave didSaveSelector: Selector?, contextInfo: UnsafeMutableRawPointer?) {
        if (self.isNewCreated) {
//            if let data = self.mainViewController, !data.isPDFDocumentEdited && !data.needSave && !self.isDocumentEdited {
                self._km_save(to: url, ofType: typeName, for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
                return
//            }
        }
        if (!self.needSaveWatermark()) {
            self._km_save(to: url, ofType: typeName, for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
            return
        }
        
        var openAccessoryView = self.watermarkSaveDelegate != nil
        if (openAccessoryView) {
            if let _browser = self.watermarkSaveDelegate as? KMBrowser, _browser.isCloseAllTabViewItem {
                openAccessoryView = false
            }
        }
        
        self._km_saveForWatermark(openAccessoryView: openAccessoryView) { [unowned self] in
            self.trackEvents()
        } callback: { [unowned self] needSave, params in
            if (needSave) {
                self._km_save(to: url, ofType: typeName, for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
            } else { // 水印保存
                if (self.watermarkSaveDelegate == nil) {
                    if let data = params.first as? KMResult, data == .cancel {
                        if let shouldClose = params.last as? Bool, shouldClose {
                            DispatchQueue.main.async {
                                self.mainViewController?.browserWindowController?.browser.windowDidBeginToClose()
                            }
                        }
                    } else {
                        DispatchQueue.main.async {
                            self.mainViewController?.browserWindowController?.browser.windowDidBeginToClose()
                        }
                    }
                    return
                }
                if let data = params.first as? KMResult, data == .cancel {
                    if var shouldClose = params.last as? Bool {
                        if let _browser = self.watermarkSaveDelegate as? KMBrowser, _browser.isCloseAllTabViewItem {
                            shouldClose = true
                        }
                        (self.watermarkSaveDelegate as? KMBrowser)?.document(self, shouldClose: shouldClose, contextInfo: nil)
                    }
                } else {
                    (self.watermarkSaveDelegate as? KMBrowser)?.document(self, shouldClose: true, contextInfo: nil)
                }
                self.watermarkSaveDelegate = nil
            }
        }
    }
    
    override func makeWindowControllers() {
        // Returns the storyboard that contains your document window.
        
        if ((self.fileURL?.path) != nil) {
            if !self.fileURL!.path.isPDFValid() {
                let alert = NSAlert()
                alert.alertStyle = .critical
                alert.messageText = NSLocalizedString("An error occurred while opening this document. The file is damaged and could not be repaired.", comment: "")
                alert.runModal()
                return
            }
        }
        
        let mainWindow = NSApp.mainWindow
        var currentWindowController: KMBrowserWindowController?
        if mainWindow != nil {
            let windowController = mainWindow!.windowController
            if windowController is KMBrowserWindowController {
                currentWindowController = (windowController as! KMBrowserWindowController)
            } else {
                for window in NSApp.windows {
                    let windowController = window.windowController
                    if windowController is KMBrowserWindowController {
                        currentWindowController = (windowController as! KMBrowserWindowController)
                        break
                    }
                }
            }
        } else {
            for window in NSApp.windows {
                let windowController = window.windowController
                if windowController is KMBrowserWindowController {
                    currentWindowController = (windowController as! KMBrowserWindowController)
                    break
                }
            }
        }
        
        if (currentWindowController == nil) && (self.fileURL != nil) {
            let browser = KMBrowser.init() as KMBrowser
            browser.addHomeTabContents()
            browser.windowController = KMBrowserWindowController.init(browser: browser)
            currentWindowController = browser.windowController as? KMBrowserWindowController
        }
        
        if currentWindowController?.browser == nil && (self.fileURL != nil) {
            let browser: KMBrowser = KMBrowser.init()
            browser.windowController = KMBrowserWindowController.init(browser: browser)
            browser.addHomeTabContents()
            currentWindowController = browser.windowController as? KMBrowserWindowController
            browser.windowController.showWindow(self)
        }
        
        mainViewController = KMMainViewController.init()
        mainViewController?.myDocument = self
        
        if ((self.fileURL?.path) != nil) {
            let pdfDocument = CPDFDocument.init(url: URL(fileURLWithPath: self.fileURL!.path))
            mainViewController?.document = pdfDocument
        }
        
        self.view = mainViewController?.view
        
        if let currentBrowser = currentWindowController?.browser {
//                currentWindowController?.browser.add(self, at: Int32()-1, inForeground: true)
//                self.addWindowController(currentWindowController!)
//                mainViewController.browserWindowController = currentWindowController

            let activeBrowser = currentBrowser.activeTabContents()
            let activeIndex = currentBrowser.activeTabIndex()
            self.addWindowController(currentWindowController!)
            self.mainViewController?.browserWindowController = currentWindowController

            let ishome = activeBrowser?.isHome ?? false
            let isfirstTab = (activeIndex == 0)
            if ishome && !isfirstTab {
                // 替换 document
                currentWindowController?.browser.replaceTabContents(at: Int32(activeIndex), with: self)
                // 刷新标签
                currentWindowController?.browser.updateTabState(at: Int32(activeIndex))
                
                // 刷新 home icon
                if let tabStripController = currentWindowController?.tabStripController {
                    if let view = tabStripController.view(at: UInt(activeIndex)) as? CTTabView {
                        view.controller().isHome = self.isHome
                        view.controller().isNewTab = self.isNewTab
                        view.controller().updateUI()
                    }
                }
            } else {
                if currentWindowController?.browser.tabCount() ?? 0 > 1 && !IAPProductsManager.default().isAvailableAllFunction() {
                    let window = NSWindow.currentWindow()
                    if !KMDataManager.default.isTabbingWin{
                        KMDataManager.default.isTabbingWin = true
                        let tabbingWin: KMTabbingHintWindowController = KMTabbingHintWindowController()
                        tabbingWin.selectCallBack = {[weak self] continueOrNot in
                            KMDataManager.default.isTabbingWin = false
                            if continueOrNot {
                                self?.reopenDocument(forPaths: [])
                            } else {
                                
                            }
                        }
                        window.km_beginSheet(windowC: tabbingWin)
                    }
                }else {
                    currentWindowController?.browser.add(self, at: Int32()-1, inForeground: true)
                }
            }
        }
    }
    
    func reopenDocument(forPaths paths: [String]) -> Void {
        let browser = KMBrowser.init() as KMBrowser
        browser.windowController = KMBrowserWindowController.init(browser: browser)
        browser.addHomeTabContents()
        browser.windowController.showWindow(self)
    }
    
    override func showWindows() {
        super.showWindows()
        
        self.setDataFromTmpData()
    }
    
    override func windowControllerDidLoadNib(_ aController: NSWindowController) {
        super.windowControllerDidLoadNib(aController)
        
        self.setDataFromTmpData()
        
        fileUpdateChecker = SKFileUpdateChecker.init(for: self)
        
        fileUpdateChecker?.isEnabled = true
        
        
    }
    
    override func save(to url: URL, ofType typeName: String, for saveOperation: NSDocument.SaveOperationType) async throws {
        do {
            try await super.save(to: url, ofType: typeName, for: saveOperation)
        } catch let outError {
            Swift.print(outError)
        }
    }
    
    override func write(to url: URL, ofType typeName: String, for saveOperation: NSDocument.SaveOperationType, originalContentsURL absoluteOriginalContentsURL: URL?) throws {
        try self._km_write(to: url, ofType: typeName, for: saveOperation, originalContentsURL: absoluteOriginalContentsURL)
    }
    
    override func canClose(withDelegate delegate: Any, shouldClose shouldCloseSelector: Selector?, contextInfo: UnsafeMutableRawPointer?) {
        let isPrompt = KMPreferenceManager.shared.closeFileIsPrompt()
        if (isPrompt) {
            super.canClose(withDelegate: delegate, shouldClose: shouldCloseSelector, contextInfo: contextInfo)
            return
        }

        if (self.isNewCreated) {
            self.save(nil)
        } else if (self.isDocumentEdited) {
            self.save(nil)
        } else if (mainViewController != nil) {
            if self.mainViewController!.isPDFDocumentEdited || self.mainViewController!.needSave {
                self.save(nil)
            }
        }

        super.canClose(withDelegate: delegate, shouldClose: shouldCloseSelector, contextInfo: contextInfo)
    }
    
    override func saveAs(_ sender: Any?) {
        if (!self.needSaveWatermark()) {
            self._km_saveAs(sender)
            return
        }
        self._km_saveForWatermark { [unowned self] needSave, _ in
            if (needSave) {
                self._km_saveAs(sender)
            }
        }
    }
    
    override func runModalSavePanel(for saveOperation: NSDocument.SaveOperationType, delegate: Any?, didSave didSaveSelector: Selector?, contextInfo: UnsafeMutableRawPointer?) {
        if (self.isNewCreated) {
//            if let data = self.mainViewController, !data.isPDFDocumentEdited && !data.needSave && !self.isDocumentEdited {
                self._km_runModalSavePanel(for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
                return
//            }
        }
        
        if (!self.needSaveWatermark()) {
            self._km_runModalSavePanel(for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
            return
        }
        self._km_saveForWatermark { [unowned self] needSave, _ in
            if (needSave) {
                self._km_runModalSavePanel(for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
            }
        }
    }
    
    override func save(_ sender: Any?) {
        if (!self.needSaveWatermark()) {
            self._km_save(sender)
            return
        }
        self._km_saveForWatermark { [unowned self] in
            self.trackEvents()
        } callback: { [unowned self] needSave, _ in
            if (needSave) {
                self._km_save(sender)
            }
        }
    }
    
    func systemInteractionMode() -> KMInteractionMode {
        let mainWindow = NSApp.mainWindow
        if mainWindow != nil {
            let windowController = mainWindow!.windowController
            if windowController?.window?.screen?.isEqual(NSScreen.screens[0]) ?? false{
                return mainViewController?.interactionMode ?? .normal
            }
        }
        
        return .normal
    }
    
    func saveForWatermark() {
        if (!self.needSaveWatermark()) {
            self._km_save(nil)
            return
        }
        
        self._km_saveForWatermark { [unowned self] in
            self.trackEvents()
        } callback: { [unowned self] needSave, params in
            if (needSave) {
                self._km_save(nil)
            } else { // 水印保存
                if (self.watermarkSaveDelegate == nil) {
                    if let data = params.first as? KMResult, data == .cancel {
                        if let shouldClose = params.last as? Bool, shouldClose {
                            DispatchQueue.main.async {
                                self.mainViewController?.browserWindowController?.browser.windowDidBeginToClose()
                            }
                        }
                    } else {
                        DispatchQueue.main.async {
                            self.mainViewController?.browserWindowController?.browser.windowDidBeginToClose()
                        }
                    }
                    return
                }
                if let data = params.first as? KMResult, data == .cancel {
                    if var shouldClose = params.last as? Bool {
                        if let _browser = self.watermarkSaveDelegate as? KMBrowser, _browser.isCloseAllTabViewItem {
                            shouldClose = true
                        }
                        (self.watermarkSaveDelegate as? KMBrowser)?.document(self, shouldClose: shouldClose, contextInfo: nil)
                    }
                } else {
                    (self.watermarkSaveDelegate as? KMBrowser)?.document(self, shouldClose: true, contextInfo: nil)
                }
                self.watermarkSaveDelegate = nil
            }
        }
    }
    
    override func read(from absoluteURL: URL, ofType typeName: String) throws {
        do {
            try super.read(from: absoluteURL, ofType: typeName)
            updateChangeCount(.changeCleared)
        } catch let outError {
            Swift.print(outError)
        }
    }
    
    override func read(from data: Data, ofType typeName: String) throws {
        // Insert code here to read your document from the given data of the specified type, throwing an error in case of failure.
        // Alternatively, you could remove this method and override read(from:ofType:) instead.  If you do, you should also override isEntireFileLoaded to return false if the contents are lazily loaded.
        
        let pdfDocument = CPDFDocument.init(data: data)
        if pdfDocument == nil {
            throw NSError(domain: NSOSStatusErrorDomain, code: unimpErr, userInfo: nil)
        }
    }
    
    // MARK: Autosaving
    
    override func close() {
        if self.isActive {
            if browser != nil {
                var activeIndex = 0
                let dex = browser.index(of: self)
                if dex == browser.tabCount() - 1 {
                    activeIndex = Int(browser.tabCount()-2)
                } else {
                    activeIndex = Int(dex + 1)
                }
                let activeContents = browser.tabContents(at: Int32(activeIndex))
                activeContents?.addWindowController(browser.windowController)
            }
        }
        super.close()
    }
    

    // MARK: init
    override init() {
        super.init()
        // Add your subclass-specific initialization here.
        
        NotificationCenter.default.addObserver(self, selector: #selector(pdfChangedNotification(_:)), name: NSNotification.Name.init(rawValue: "CPDFListViewAnnotationsAttributeHasChangeNotification"), object: nil)
//        NotificationCenter.default.addObserver(self, selector: #selector(pdfChangedNotification(_:)), name: NSNotification.Name.init(rawValue: "CPDFViewDocumentChangedNotification"), object: nil)
//        NotificationCenter.default.addObserver(self, selector: #selector(pdfChangedNotification(_:)), name: NSNotification.Name.init(rawValue: "CPDFViewPageChangedNotification"), object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(pdfChangedNotification(_:)), name: NSNotification.Name.init(rawValue: "CPDFListViewDidAddAnnotationNotification"), object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(pdfChangedNotification(_:)), name: NSNotification.Name.CPDFViewPageChanged, object: nil)
    }

    override init?(baseTabContents baseContents: CTTabContents?) {
        super.init(baseTabContents: baseContents)
        if isHome {
            homeViewController = KMHomeViewController.init()
            homeViewController?.myDocument = self
            self.view = homeViewController?.view
        }
    }
    
    // MARK: Handling User Actions
    
    override var title: String? {
        get {
            if isHome {
                if (self.isNewTab) {
                    return NSLocalizedString("New Tab", comment: "")
                } else {
                    return NSLocalizedString("Home", comment: "")
                }
            } else {
                return fileURL?.lastPathComponent
            }
        }
        set {
            super.title = newValue
        }
    }
    
    func needSaveWatermark() -> Bool {
        if let need = self.mainViewController?.saveWatermarkFlag {
            return need
        }
        return false
    }
    
    // MARK: Private Methods

    func pdfChangedNotification(_ notification: Notification) -> Void {
        if !isHome {
            let mainViewController = mainViewController
            var document: CPDFDocument!
            
            let dic = notification.object as? NSDictionary
            if dic?["object"] is CPDFAnnotation {
                let annotation : CPDFAnnotation = dic?["object"] as? CPDFAnnotation ?? CPDFAnnotation()
                document = annotation.page.document

            } else if dic?["object"] is CPDFListView {
                let pdflistView = notification.object as? CPDFListView
                document = pdflistView?.document
            }
            
            if mainViewController != nil {
                if document == mainViewController!.document {
                    updateChangeCount(.changeDone)
                }
            }
        }
    }
    
    override func updateChangeCount(_ change: NSDocument.ChangeType) {
        let mainWindow = NSApp.mainWindow
        var currentWindowController: KMBrowserWindowController?
        if mainWindow != nil {
            let windowController = mainWindow!.windowController
            if windowController is KMBrowserWindowController {
                currentWindowController = (windowController as! KMBrowserWindowController)
            } else {
                for window in NSApp.windows {
                    let windowController = window.windowController
                    if windowController is KMBrowserWindowController {
                        currentWindowController = (windowController as! KMBrowserWindowController)
                        break
                    }
                }
            }
        } else {
            for window in NSApp.windows {
                let windowController = window.windowController
                if windowController is KMBrowserWindowController {
                    currentWindowController = (windowController as! KMBrowserWindowController)
                    break
                }
            }
        }
        if let currentBroser = currentWindowController?.browser {
            if self.isEqual(to: currentBroser.activeTabContents()) {
                super.updateChangeCount(change)
                return
            }
        }

        super.updateChangeCount(.changeCleared)
    }

    func uploadToCloud(_ callback: (@escaping(Bool, String)->())) {
        guard let handdler = self.cloudUploadHanddler else {
            return
        }
        
        handdler(callback)
    }
    
    func isPDFDocument() -> Bool {
        return true
    }
    
    func setDataFromTmpData() {
        guard let _document = self.mainViewController?.document else {
            return
        }
//        self.tryToUnlockDocument(document!)
        if (_document.permissionsStatus != .owner) {
            var password: NSString? = nil
            let fileId = self.fileId(for: _document)
            if (fileId.isEmpty) {
                return
            }
            self.getPassword(&password, fileId: fileId)
            if (password != nil) {
                self.isUnlockFromKeychain = true
//                document.unlock(withPassword: password! as String)
                self.mainViewController?.password = password as String?
            }
        }
    }
    
    func tryToUnlockDocument(_ document: CPDFDocument) {
        if (document.permissionsStatus != .owner) {
            var password: NSString? = nil
            let fileId = self.fileId(for: document)
            if (fileId.isEmpty) {
                return
            }
            self.getPassword(&password, fileId: fileId)
            if (password != nil) {
                self.isUnlockFromKeychain = true
                document.unlock(withPassword: password! as String)
            }
        }
    }
    
    func km_updateChangeCount(_ change: NSDocument.ChangeType) {
        super.updateChangeCount(change)
    }
    
    func trackEvents() {
        km_synchronized(self) {
            for i in self._trackEvents {
                if let type = KMSubscribeWaterMarkType(rawValue: i) {
                    KMTools.trackEvent(type: type)
                }
            }
        }
        
        self.clearTrackEvents()
    }
    
    func recordTrackEvent(type: KMSubscribeWaterMarkType) {
        if (type == .none) {
            return
        }
        
        km_synchronized(self) {
            self._trackEvents.insert(type.rawValue)
        }
    }
    
    func clearTrackEvents() {
        km_synchronized(self) {
            self._trackEvents.removeAll()
        }
    }
    
    @IBAction func saveArchive(_ sender: Any?) {
        guard let item = sender as? NSMenuItem else {
            NSSound.beep()
            return
        }
        guard let fileURL = self.fileURL else {
            NSSound.beep()
            return
        }
        let check = try?fileURL.checkResourceIsReachable()
        if check == false || self.isDocumentEdited {
            let msg = KMLocalizedString("You must save this file first", "Alert text when trying to create archive for unsaved document")
            let inf = KMLocalizedString("The document has unsaved changes, or has not previously been saved to disk.", "Informative text in alert dialog")
            Task {
                _ = await KMAlertTool.runModel(message: msg, informative: inf)
            }
            return
        }
//        NSString *ext = ([sender tag] | SKArchiveDiskImageMask) ? @"dmg" : @"tgz";
        let idx = item.tag
        let ext = "dmg"
        let isEmail = true
        if isEmail  {
//            if (([sender tag] | SKArchiveEmailMask)) {
            let tmpDirURL = FileManager.default.uniqueChewableItemsDirectoryURL()
            let tmpFileURL = tmpDirURL.appendingPathComponent(fileURL.lastPathComponentReplacingPathExtension(ext))
            self.newSaveArchive(to: tmpFileURL, email: true)
        } else {
            let sp = NSSavePanel()
            sp.allowedFileTypes = [ext]
            sp.canCreateDirectories = true
//                [sp setNameFieldStringValue:[fileURL lastPathComponentReplacingPathExtension:ext]];
            sp.beginSheetModal(for: self.windowForSheet!) { result in
                if result == .OK {
                    self.newSaveArchive(to: sp.url!, email: false)
                }
            }
        }
    }
    
//    func saveArchiveToURL(to fileURL: URL, email: Bool) {
//        NSTask *task = [[[NSTask alloc] init] autorelease];
//        let task = Task()
//        if fileURL.pathExtension == "dmg" {
//            [task setLaunchPath:@""];
//            task.launchPath = "/usr/bin/hdiutil"
//            [task setArguments:[NSArray arrayWithObjects:@"create", @"-srcfolder", [[self fileURL] path], @"-format", @"UDZO", @"-volname", [[fileURL lastPathComponent] stringByDeletingPathExtension], [fileURL path], nil]];
//        } else {
//            [task setLaunchPath:@"/usr/bin/tar"];
//            [task setArguments:[NSArray arrayWithObjects:@"-czf", [fileURL path], [[self fileURL] lastPathComponent], nil]];
//        }
//        [task setCurrentDirectoryPath:[[[self fileURL] URLByDeletingLastPathComponent] path]];
//        [task setStandardOutput:[NSFileHandle fileHandleWithNullDevice]];
//        [task setStandardError:[NSFileHandle fileHandleWithNullDevice]];
//
//        SKAttachmentEmailer *emailer = nil;
//        if (email)
//            emailer = [SKAttachmentEmailer attachmentEmailerWithFileURL:fileURL subject:[self displayName] waitingForTask:task];
//
//        @try {
//            [task launch];
//        }
//        @catch (id exception) {
//            [emailer taskFailed];
//        }
//    }
    
    @IBAction func readNotes(_ sender: Any?) {
        KMPrint("readNotes")
    }
    @IBAction func convertNotes(_ sender: Any?) {
        KMPrint("convertNotes")
    }
    @IBAction func batchRemovePassWord(_ sender: Any?) {
        self.mainViewController?.clickChildTool(type: .secure, index: 2)
    }
    @IBAction func batchRemovPrivatySecurity(_ sender: Any?) {
        self.mainViewController?.removeOwnerPassword()
    }
    @IBAction func printPDFDocument(_ sender: Any?) {
        KMPrintWindowController.showNewPrintWindowControll(inputDocument: self.mainViewController?.document, inputPageRange: KMPrintPageRange())
    }
    @IBAction func performFindPanelAction(_ sender: Any?) {
        self.mainViewController?.toolbarController.showFindBar()
    }
    
    @IBAction func addBookmark(_ sender: Any?) {
        guard let item = sender as? NSMenuItem else {
            return
        }
        
//        let bookmarkSheetController = SKBookmarkSheetController(windowNibName: "BookmarkSheet")
//        NSWindow.currentWindow().beginSheet(bookmarkSheetController.window!) { resoponse in
//            
//        }
//        bookmarkSheetController.textField.stringValue = self.displayName
//        bookmarkSheetController.beginSheetModal(for: self.windowForSheet) { [unowned self] result in
//            if (result == NSApplication.ModalResponse.OK.rawValue) {
//                let label = bookmarkSheetController.textField.stringValue;
//                let folder: SKBookmark = bookmarkSheetController.selectedFolder ?? SKBookmarkController.shared().bookmarkRoot
//                var bookmark = SKBookmark()
//                switch (item.tag) {
//                    case 0:
//                        let mainViewController = self.mainViewController
//                        let page = mainViewController?.listView.currentPage()
//                        bookmark = SKBookmark.bookmark(with: self.fileURL, pageIndex: (page?.pageIndex())!, label: label) as! SKBookmark
//                    case 1:
//                        let setup = self.currentDocumntSetup()
//                        bookmark = SKBookmark.bookmark(withSetup: setup, label: label) as! SKBookmark
//                    
//                    case 2:
//                        let setups = NSApp.orderedDocuments.map { $0.value(forKey: "currentDocumentSetup") }
//                        bookmark = SKBookmark.bookmarkSession(withSetups: setups as [Any], label: label) as! SKBookmark
//                    
//                    default:
//                        break;
//                }
//                folder.mutableArrayValue(forKey: "children").add(bookmark)
//            }
//        }
        
        if item.tag == 3 {
            KMPrint("Edit Bookmark")
            bookmarkController = KMBookmarkController.showBookmarkController()
        } else if item.tag == 2 {
            KMPrint("session Bookmark")
            bookmarkSheetController = KMBookmarkSheetController.showBookmarkSheetController(type: .session)
        } else if item.tag == 0 {
            KMPrint("add Bookmark")
            bookmarkSheetController = KMBookmarkSheetController.showBookmarkSheetController(type: .bookmark)
        }
        
        bookmarkSheetController?.stringValue = self.displayName
        bookmarkSheetController?.cancelAction = { [unowned self] controller, type in
            
        }
//        
        bookmarkSheetController?.doneAction = { [unowned self] controller, type, label in
            let folder = controller.selectedFolder
            var bookmark: KMBookmark?

            switch type {
            case .bookmark:
                let mainViewController = mainViewController
                
                if let page = mainViewController?.listView.currentPage() {
                    let index: UInt = page.pageIndex()
                    bookmark = KMBookmark.bookmark(url: self.fileURL!, pageIndex: index, label: label)
                }
            case .setup: break
                let setup = currentDocumentSetup
                bookmark = KMBookmark.bookmark(setup: setup, label: label)
            case .session:
                let setups = NSApp.orderedDocuments.compactMap { $0.value(forKey:"currentDocumentSetup") }
                bookmark = KMSessionBookmark.bookmarkSession(setups: setups as NSArray, label: label)
            default:
                break
            }

            if let bookmark = bookmark {
                folder?.children.append(bookmark)
            }
            KMBookmarkManager.manager.saveData()
        }
    }
    
    func currentDocumntSetup() -> [String: Any] {
        var setup: [String: Any] = [:]
        
        let data = SKAlias.init(url: fileURL).data
        if (data != nil) {
            setup.updateValue(data as Any, forKey: "_BDAlias")
        } else {
            setup.updateValue(fileURL?.path as Any, forKey: "fileName")
        }
        return setup;
    }
    
    
    
    @IBAction func showWindow(_ sender: Any?) {
        KMPrint("showWindow")
    }
    
    // MARK: - Private Methods
    
    private func _km_write(to url: URL, ofType typeName: String, for saveOperation: NSDocument.SaveOperationType, originalContentsURL absoluteOriginalContentsURL: URL?) throws {
        var success = true
        if !self.isHome {
            if mainViewController != nil {
                if mainViewController?.document != nil {
                    self.mainViewController?.commitEditingIfNeed()
                    
//                    if mainViewController!.document!.isEncrypted {
//                        success = mainViewController!.document!.write(to: url)
//                    } else {
                        if (mainViewController!.needSave) {
                            if let options = self.mainViewController?.secureOptions, !options.isEmpty {
                                self.mainViewController!.document?.setDocumentAttributes(self.mainViewController?.documentAttribute)
                                success = self.mainViewController!.document!.write(to: url, withOptions: options)
                            } else if let flag = self.mainViewController?.removeSecureFlag, flag {
                                success = self.mainViewController!.document!.writeDecrypt(to: url)
                            } else {
                                success = mainViewController!.document!.write(to: url)
                            }
                        } else {
                            success = mainViewController!.document!.write(to: url)
                        }
//                    }
                    self.mainViewController?.needSave = false
                    self.mainViewController?.clearSecureOptions()
                    self.mainViewController?.clearRemoveSecureFlag()
                }
            }
        } else {
            success = false
        }
        
        if (success && self._saveAsing) {
            if let tabView = self.browser?.windowController?.tabStripController?.activeTabView() as? CTTabView {
                tabView.controller()?.title = url.lastPathComponent
            }
            self._saveAsing = false
        }
        
        if success && isNewCreated && NSDocument.SaveOperationType.saveAsOperation == saveOperation {
            isNewCreated = false
        }
    }
    
    private func _km_saveForWatermark(openAccessoryView: Bool = true, subscribeDidClick: (()->Void)? = nil, callback:@escaping (_ needSave: Bool, _ param: Any...)->Void) {
        Task { @MainActor in
            if await (KMLightMemberManager.manager.canPayFunction() == false) {
                let _ = KMSubscribeWaterMarkWindowController.show(window: NSApp.mainWindow!, isContinue:false, type: .save) {
                    if let _callback = subscribeDidClick {
                        _callback()
                    }
                } completion: { isSubscribeSuccess, isWaterMarkExport, isClose in
                    if (isClose) {
                        callback(false, KMResult.cancel, false)
                        return
                    }
                    
                    if (isSubscribeSuccess) {
                        callback(true)
                        return
                    }
                    
                    if (isWaterMarkExport) {
                        guard let _document = self.mainViewController?.document else {
                            callback(false, KMResult.failure)
                            return
                        }
                        // 提交文本编辑的内容
                        self.mainViewController?.commitEditingIfNeed()
                        DispatchQueue.main.async {
                            NSPanel.savePanel(NSApp.mainWindow!, openAccessoryView, panel:{ panel in
                                if (!self.isNewCreated) {
                                    panel.directoryURL = _document.documentURL.deletingLastPathComponent()
                                }
                                
                                panel.nameFieldStringValue = _document.documentURL.lastPathComponent
                            }) { response, url, isOpen in
                                if (response == .cancel) {
                                    callback(false, KMResult.cancel, true)
                                    return
                                }
                                guard let _url = KMTools.saveWatermarkDocument(document: _document, to: url!, secureOptions: self.mainViewController?.secureOptions, documentAttribute: self.mainViewController?.documentAttribute,removePWD: self.mainViewController!.removeSecureFlag) else {
                                    callback(false, KMResult.failure)
                                    return
                                }
                                callback(false, KMResult.success)
                                if (isOpen) {
                                    NSDocumentController.shared.km_safe_openDocument(withContentsOf: _url, display: true) { _, _, _ in
                                        
                                    }
                                } else {
                                    NSWorkspace.shared.activateFileViewerSelecting([_url])
                                }
                            }
                        }
                        return
                    }
                    callback(false, KMResult.cancel, false)
                }
                return
            }
            callback(true)
        }
    }
    
    private func _km_save(_ sender: Any?) {
        super.save(sender)
    }
    
    private func _km_save(to url: URL, ofType typeName: String, for saveOperation: NSDocument.SaveOperationType, delegate: Any?, didSave didSaveSelector: Selector?, contextInfo: UnsafeMutableRawPointer?) {
        self._saveToURL = url
        super.save(to: url, ofType: typeName, for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
    }
    
    private func _km_saveAs(_ sender: Any?) {
        super.saveAs(sender)

        self._saveAsing = true
    }
    
    private func _km_runModalSavePanel(for saveOperation: NSDocument.SaveOperationType, delegate: Any?, didSave didSaveSelector: Selector?, contextInfo: UnsafeMutableRawPointer?) {
        super.runModalSavePanel(for: saveOperation, delegate: delegate, didSave: didSaveSelector, contextInfo: contextInfo)
    }
}

extension KMMainDocument {
    override func validateMenuItem(_ menuItem: NSMenuItem) -> Bool {
        if (menuItem.action == #selector(save(_ :))) {
            if (self.isHome) {
                return false
            }
            if (self.isDocumentEdited) {
                return self.isDocumentEdited
            }
            
            guard let mainVC = self.mainViewController else {
                return false
            }
            return mainVC.isPDFDocumentEdited || mainVC.needSave
        } else if (menuItem.action == #selector(saveAs(_ :))) {
            return !self.isHome
        } else if menuItem.action == #selector(batchRemovPrivatySecurity) {
            if self.isHome {
                return false
            }
            guard let doc = self.mainViewController?.listView?.document else {
                return false
            }
            let allowsPrinting = doc.allowsPrinting
            let allowsCopying = doc.allowsCopying
            if allowsCopying && allowsPrinting {
                return false
            }
            return true
        } else if menuItem.action == #selector(saveArchive) {
            return !self.isHome
        }
        return super.validateMenuItem(menuItem)
    }
}

extension NSDocument {
    @objc class func isDamage(url: URL) -> Bool {
        // 文件路径是否存在
        if (FileManager.default.fileExists(atPath: url.path) == false) {
            return true
        }
        
        /// PDF 格式文件
        if (url.pathExtension.lowercased() == "pdf") {
            let document = PDFDocument(url: url)
            if (document == nil) {
                return true
            }
            
            if (document!.isLocked) { // 加锁文件不在这里判断
                return false
            }
            
            if (document!.pageCount <= 0) {
                return true
            }
            return false
        }
        
        // 支持的图片格式
        let imageExts = ["jpg","cur","bmp","jpeg","gif","png","tiff","tif","ico","icns","tga","psd","eps","hdr","jp2","jpc","pict","sgi","heic"]
        let isImage = imageExts.contains(url.pathExtension.lowercased())
        if (isImage == false) { // 其他格式目前返回没损坏，后续再补充(如果有需求)
            return false
        }
        
        // 图片格式
        let image = NSImage(contentsOf: url)
        let data = image?.tiffRepresentation
        if (data == nil) {
            return true
        }
        let imageRep = NSBitmapImageRep(data: data!)
        imageRep!.size = image!.size
        var imageData: NSData?
        if (url.pathExtension.lowercased() == "png") {
            imageData = imageRep?.representation(using: .png, properties: [:]) as NSData?
        } else {
            imageData = imageRep?.representation(using: .jpeg, properties: [:]) as NSData?
        }
        if (imageData == nil) {
            return true
        }
        
        let path = NSSearchPathForDirectoriesInDomains(.applicationSupportDirectory, .userDomainMask, true).last?.stringByAppendingPathComponent(Bundle.main.bundleIdentifier!)
        if (FileManager.default.fileExists(atPath: path!) == false) {
            try?FileManager.default.createDirectory(atPath: path!, withIntermediateDirectories: false)
        }
        
        var tagString: String = ""
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = "yyMMddHHmmss"
        tagString.append(dateFormatter.string(from: Date()))
        tagString = tagString.appendingFormat("%04d", arc4random()%10000)
        let filePath = path?.appending("/\(tagString).png")
        if (imageData!.write(toFile: filePath!, atomically: true) == false) {
            return true
        }
        
        // 删除临时图片
        try?FileManager.default.removeItem(atPath: filePath!)
        
        return false
    }
    
    @objc class func isDamage(url: URL, needAlertIfDamage need: Bool) -> Bool {
        let result = self.isDamage(url: url)
        if (result == false) {
            return false
        }
        
        if (need == false) {
            return true
        }
        
        let alert = NSAlert()
        alert.messageText = NSLocalizedString("An error occurred while opening this document. The file is damaged and could not be repaired.", comment: "")
        alert.runModal()
        return true
    }
}

// MARK: -
// MARK: 保存密码
extension NSDocument {
    func savePasswordInKeychain(_ password: String, _ document: CPDFDocument) {
        if (document.isLocked || password.isEmpty) {
            return
        }
        
        let fileId = self.fileId(for: document)
        if (fileId.isEmpty) {
            return
        }
        
//        let status: SKPasswordStatus =
        let label = "PDF Reader Pro: \(self.displayName!)"
        SKKeychain.setPassword(password, item: nil, forService: self.passwordServiceName(), account: fileId, label: label, comment: self.fileURL?.path)
    }
    
    func getPassword(_ password: AutoreleasingUnsafeMutablePointer<NSString?>, fileId: String) {
        let status = SKKeychain.getPassword(password, item: nil, forService: self.passwordServiceName(), account: fileId)
//        if (status == .found) {
            
//        }
    }
    
    fileprivate func fileId(for document: CPDFDocument) -> String {
        return "\(document.documentURL.path.hash)"
    }
    
    private func passwordServiceName() -> String {
        return "PDF Reader Pro password"
    }
}

extension KMMainDocument: SKPDFSynchronizerDelegate {
    func synchronizer(_ synchronizer: SKPDFSynchronizer!, foundLine line: Int, inFile file: String!) {
        if FileManager.default.fileExists(atPath: file) {
            let defaults = UserDefaults.standard
            
            var editorPreset = defaults.string(forKey: SKTeXEditorPresetKey) ?? ""
            var editorCmd: String?
            var editorArgs: String?
            var cmdString: String?
                
            if !KMSyncPreferences.getTeXEditorCommand(command: &editorCmd, arguments: &editorArgs, forPreset: editorPreset) {
                editorCmd = defaults.string(forKey: SKTeXEditorCommandKey)
                editorArgs = defaults.string(forKey: SKTeXEditorArgumentsKey)
            }
                
            if var cmdString = editorArgs {
                if !editorCmd!.hasPrefix("/") {
                    var searchPaths = ["/usr/bin", "/usr/local/bin"]
                    var toolPath: String?
                    
                    let fm = FileManager.default
                    
                    if !(editorPreset.isEmpty) {
                        if let path = NSWorkspace.shared.fullPath(forApplication: editorPreset) {
                            if let appBundle = Bundle(path: path) {
                                if let contentsPath = appBundle.path(forResource: "Contents", ofType: nil) {
                                    searchPaths.insert(contentsPath, at: 0)
                                }
                                if editorPreset != "BBEdit", let execPath = appBundle.executablePath {
                                    searchPaths.insert(execPath, at: 0)
                                }
                                if let resourcePath = appBundle.resourcePath {
                                    searchPaths.insert(resourcePath, at: 0)
                                }
                                if let sharedSupportPath = appBundle.sharedSupportPath {
                                    searchPaths.insert(sharedSupportPath, at: 0)
                                }
                            }
                        }
                    } else {
                        let appSupportDirs = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)
                        let appSupportPaths = appSupportDirs.map { $0.path }
                        searchPaths.append(contentsOf: appSupportPaths)
                    }
                    
                    for path in searchPaths {
                        toolPath = (path as NSString).appendingPathComponent(editorCmd!)
                        if fm.isExecutableFile(atPath: toolPath!) {
                            editorCmd = toolPath
                            break
                        }
                        toolPath = ((path as NSString).appendingPathComponent("bin") as NSString).appendingPathComponent(editorCmd!)
                        if fm.isExecutableFile(atPath: toolPath!) {
                            editorCmd = toolPath
                            break
                        }
                    }
                }
                
                cmdString = cmdString.replacingOccurrences(of: "%line", with: "\(line + 1)")
                cmdString = cmdString.replacingOccurrences(of: "%file", with: file)
                cmdString = cmdString.replacingOccurrences(of: "%output", with: fileURL?.path ?? "")
                
                cmdString.insert(contentsOf: "\" ", at: cmdString.startIndex)
                cmdString.insert(contentsOf: editorCmd!, at: cmdString.startIndex)
                cmdString.insert("\"", at: cmdString.startIndex)
                
                let ws = NSWorkspace.shared
                if let theUTI = try? ws.type(ofFile: editorCmd!) {
                    if ws.type(theUTI, conformsToType: "com.apple.applescript.script") || ws.type(theUTI, conformsToType: "com.apple.applescript.text") {
                        cmdString.insert(contentsOf: "/usr/bin/osascript ", at: cmdString.startIndex)
                    }
                }
                
                let task = Process()
                task.launchPath = "/bin/sh"
                task.currentDirectoryPath = (file as NSString).deletingLastPathComponent
                task.arguments = ["-c", cmdString]
                task.standardOutput = FileHandle.nullDevice
                task.standardError = FileHandle.nullDevice
                do {
                    try task.run()
                } catch let error {
                    Swift.print("command failed: \(cmdString ?? ""): \(error)")
                }
            }
        }
    }
    
    func synchronizer(_ synchronizer: SKPDFSynchronizer!, foundLocation point: NSPoint, atPageIndex pageIndex: UInt, options: Int) {
        guard let pdfDoc = self.mainViewController?.document else { return }
        if pageIndex < pdfDoc.pageCount {
            if let page = pdfDoc.page(at: pageIndex) {
                var adjustedPoint = point
                if options & SKPDFSynchronizerFlippedMask != 0 {
                    let mediaBox = page.bounds(for: .mediaBox)
                    adjustedPoint.y = NSMaxY(mediaBox) - adjustedPoint.y
                }
                
                self.mainViewController?.listView.displayLine(at: adjustedPoint, inPageAtIndex: Int(pageIndex), showReadingBar: options & SKPDFSynchronizerShowReadingBarMask != 0)
            }
        }
    }
}

extension KMMainDocument {
    
    
}