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

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

import Cocoa

typealias KMMainDocumentCloudUploadHanddler = (@escaping(Bool, String)->()) -> ()
@objcMembers class KMMainDocument: CTTabContents {
    var mainViewController: KMMainViewController?
    var homeWindowController: KMHomeWindowController?
    var homeViewController: KMHomeViewController?
    var isNewCreated: Bool = false
    var closedByUserGestureFlag: Bool = false   // 标记 closedByUserGesture 这个状态需要延后存储(如果需要)
    var cloud: Bool = false
    var cloudUploadHanddler: KMMainDocumentCloudUploadHanddler?
    var isUnlockFromKeychain: Bool = false
    private var _saveAsing = false
    
    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
        }
        
        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 currentWindowController != nil {
            if currentWindowController?.browser != nil {
//                currentWindowController?.browser.add(self, at: Int32()-1, inForeground: true)
//                self.addWindowController(currentWindowController!)
//                mainViewController.browserWindowController = currentWindowController

                let activeBrowser = (currentWindowController?.browser.activeTabContents())! as CTTabContents
                let activeIndex = Int((currentWindowController?.browser.activeTabIndex())!)
                self.addWindowController(currentWindowController!)
                self.mainViewController?.browserWindowController = currentWindowController

                let ishome = activeBrowser.isHome as Bool
                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 {
                    currentWindowController?.browser.add(self, at: Int32()-1, inForeground: true)
                }
            }
        }
    }
    
    override func showWindows() {
        super.showWindows()
        
        self.setDataFromTmpData()
    }
    
    override func windowControllerDidLoadNib(_ aController: NSWindowController) {
        super.windowControllerDidLoadNib(aController)
        
        self.setDataFromTmpData()
    }
    
    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)
            }
        }
    }
    
    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.init(rawValue: "CPDFListViewDidRemoveAnnotationNotification"), 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 currentWindowController != nil {
            if currentWindowController?.browser != nil {

                let activeBrowser = (currentWindowController?.browser.activeTabContents())! as CTTabContents
                let activeIndex = Int((currentWindowController?.browser.activeTabIndex())!)
                if self == activeBrowser {
                    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()
        }
    }
    
    // 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 {
                                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!) {
                    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, 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)
                }
                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 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 Master: \(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 Master password"
    }
}