PDF_Office/PDF Office/PDF Master/Class/PDFTools/Merge/MergeNew/KMMergeWindowController.swift

//
//  KMMergeWindowController.swift
//  PDF Reader Pro
//
//  Created by lizhe on 2023/11/8.
//

import Cocoa

typealias KMMergeWindowControllerCancelAction = (_ controller: KMMergeWindowController) -> Void
typealias KMMergeWindowControllerAddFilesAction = (_ controller: KMMergeWindowController) -> Void
typealias KMMergeWindowControllerMergeAction = (_ controller: KMMergeWindowController, _ filePath: String) -> Void
typealias KMMergeWindowControllerClearAction = (_ controller: KMMergeWindowController) -> Void

class KMMergeWindowController: KMNBaseWindowController {
    
    @IBOutlet weak var mergeView: KMMergeView!
     
    var cancelAction: KMCommonBlock?
    var oldPDFDocument: PDFDocument = PDFDocument()
    var password: String = ""
    
    var oriDucumentUrl: URL? {
        didSet {
            oldPDFDocument = PDFDocument(url: oriDucumentUrl!)!
            oldPDFDocument.unlock(withPassword: self.password)
        }
    }
    
    var type: KMMergeViewType = .add
    
    var pageIndex: Int?
    
    var files: [KMFileAttribute] = [] {
        didSet {
            self.mergeView.files = files
        }
    }
    
    var mergeAction: KMMergeWindowControllerMergeAction?
    
    override func windowDidLoad() {
        super.windowDidLoad()
        
        self.window!.title = NSLocalizedString("Merge PDF Files", comment: "");
        // Implement this method to handle any initialization after your window controller's window has been loaded from its nib file.
        self.mergeView.type = self.type
        mergeView.addFilesAction = { [weak self] view in
            guard let self = self else { return }
            self.addFile()
        }
        
        mergeView.clearAction = { view in
            
        }
        
        mergeView.mergeAction = { [weak self] view, files, size in
            guard let self = self else { return }
            self.mergeFiles(files: files, size: size)
        }
        
        mergeView.cancelAction = { [weak self] view in
            guard let self = self else { return }
            
            self._clearImageData()
            self.cancelAction?(self)
        }
        
        //原始数据加载
        if oriDucumentUrl != nil && oriDucumentUrl?.path.count != 0 {
            let file = KMFileAttribute()
            file.filePath = oriDucumentUrl?.path ?? ""
            file.password = self.password
            
            self.mergeView.files = [file]
        }
    }
}

extension KMMergeWindowController {
    func addFile() {
        var size = 0.0
        let files = self.mergeView.files
        for file in files {
            size = size + file.fileSize
        }
        
        if KMMemberInfo.shared.isLogin == false && (files.count >= 2 || size > 20 * 1024 * 1024) {
            KMLoginWindowsController.shared.showWindow(nil)
            return
        }
        
        let openPanel = NSOpenPanel()
        openPanel.allowedFileTypes = KMTools.imageExtensions + KMTools.pdfExtensions
        openPanel.allowsMultipleSelection = true
        openPanel.message = NSLocalizedString("Select files to merge. To select multiple files press cmd ⌘ button on keyboard and click on the target files one by one.", comment: "")
        
        openPanel.beginSheetModal(for: self.window!) { (result) in
            if result == NSApplication.ModalResponse.OK {
                var array: [URL] = []
                for fileURL in openPanel.urls {
                    if KMTools.isImageType(fileURL.pathExtension) {
                        if let image = NSImage(contentsOf: fileURL) {
                            if let page = PDFPage(image: image) {
                                let document = PDFDocument()
                                document.insert(page, at: 0)
                                
                                var path = self._saveImagePath() + "/" + fileURL.deletingPathExtension().lastPathComponent + ".pdf"
                                path = KMTools.getUniqueFilePath(filePath: path)
                                let result = document.write(toFile: path)
                                if result {
                                    let file = KMFileAttribute()
                                    file.filePath = path
                                    file.oriFilePath = fileURL.path
                                    file.myPDFDocument = document
                                    
                                    let attribe = try?FileManager.default.attributesOfItem(atPath: fileURL.path)
                                    let fileSize = attribe?[FileAttributeKey.size] as? CGFloat ?? 0
                                    size = fileSize + size
                                    
                                    if KMMemberInfo.shared.isLogin == false && (files.count >= 2 || size > 20 * 1024 * 1024) {
                                        KMLoginWindowsController.shared.showWindow(nil)
                                        return
                                    }
                                    
                                    self.mergeView.files.append(file)
                                }
                            }
                        } else {
                            Task {
                                _ = await KMAlertTool.runModel(message: NSLocalizedString("An error occurred while opening this document. The file is damaged and could not be repaired.", comment: ""))
                            }
                        }
                    } else {
                        array.append(fileURL)
                    }
                }
                
                let attribe = try?FileManager.default.attributesOfItem(atPath: openPanel.urls.first!.path)
                let fileSize = attribe?[FileAttributeKey.size] as? CGFloat ?? 0
                size = fileSize + size
                
                if KMMemberInfo.shared.isLogin == false && (files.count >= 2 || size > 20 * 1024 * 1024) {
                    KMLoginWindowsController.shared.showWindow(nil)
                    return
                }
                
                self.mergeView.addFilePaths(urls: array)
            }
        }
        
    }
    
    private func _saveImagePath() -> String {
        let rootPath = KMDataManager.fetchAppSupportOfBundleIdentifierDirectory()
        let path = rootPath.appendingPathComponent("Merge").path
        if FileManager.default.fileExists(atPath: path) == false {
            try?FileManager.default.createDirectory(atPath: path, withIntermediateDirectories: false)
        }
        return path
    }
    
    private func _clearImageData() {
        let path = self._saveImagePath()
        if FileManager.default.fileExists(atPath: path) {
            try?FileManager.default.removeItem(atPath: path)
        }
    }
    
    func mergeFiles(files: [KMFileAttribute], size: CGSize = .zero) {
        var size = 0.0
        for file in files {
            size = size + file.fileSize
        }
        
        if KMMemberInfo.shared.isLogin == false && (files.count >= 2 || size > 20 * 1024 * 1024) {
            KMLoginWindowsController.shared.showWindow(nil)
            return
        }
        
        
        var filesCount = 1
        if self.oriDucumentUrl != nil {
            filesCount = 0
        }
        if files.count <= filesCount {
            let alert = NSAlert.init()
            alert.alertStyle = .critical
            alert.messageText = NSLocalizedString("To start merging, please select at least 2 files.", comment: "")
            alert.runModal()
            return
        }
        
        var rootPDFOutlineArray: [PDFOutline] = []
        var allPage = true //只有是全部才支持大纲的合并
        for file in files {
            if file.fetchSelectPages().count == 0 {
                let alert = NSAlert.init()
                alert.alertStyle = .critical
                alert.messageText = "\(file.filePath.lastPathComponent) + \(NSLocalizedString("Invalid page range or the page number is out of range. Please try again.", comment: ""))"
                alert.runModal()
                return
            }
            
            allPage = file.bAllPage
            
            /*防止文件被地址变换后crash*/
            guard let tDocument = PDFDocument(url: NSURL(fileURLWithPath: file.filePath) as URL) else {
                print("文件不存在")
                let alert = NSAlert.init()
                alert.alertStyle = .critical
                alert.messageText = "\(file.filePath.lastPathComponent) + \(NSLocalizedString("File Not Exist", comment: ""))"
                alert.runModal()
                return
            }
            
            var outlineArray: [PDFOutline] = []
            
            tDocument.unlock(withPassword: file.password)
            
            if tDocument.outlineRoot != nil {
                rootPDFOutlineArray.append((tDocument.outlineRoot)!)
                self.fetchAllOfChildren((tDocument.outlineRoot)!, containerArray: &outlineArray)
                outlineArray.removeObject((tDocument.outlineRoot)!)
            } else {
                let rootOutline = PDFOutline.init()
                tDocument.outlineRoot = rootOutline
                if tDocument.outlineRoot != nil {
                    rootPDFOutlineArray.append(tDocument.outlineRoot!)
                }
            }
            
            for number in file.fetchSelectPages() {
                let page = tDocument.page(at: number - 1)
                
                self.oldPDFDocument.insert(page!, at: self.oldPDFDocument.pageCount)
            }
        }
        
        var theFilepath = files.first?.filePath
        if let filepath = files.first?.oriFilePath {
            theFilepath = filepath
        }
        let fileName = (theFilepath?.deletingPathExtension.lastPathComponent ?? "") + "_Merged"
        DispatchQueue.main.async {
            if self.oldPDFDocument.outlineRoot == nil {
                self.oldPDFDocument.outlineRoot = PDFOutline.init()
            }
            var insertIndex = 0
            for i in 0..<rootPDFOutlineArray.count {
                let rootOutline = rootPDFOutlineArray[i]
                for j in 0..<rootOutline.numberOfChildren {
                    self.oldPDFDocument.outlineRoot?.insertChild(rootOutline.child(at: j)!, at: insertIndex)
                    insertIndex = insertIndex + 1
                }
            }
            
            self.handleReDraw()
            
            if self.oriDucumentUrl != nil {
                
                let newPath = self.oldPDFDocument.documentURL!.path
                var options: [PDFDocumentWriteOption : Any] = [:]
                var success = false
                let password = self.password
                let pdf = self.oldPDFDocument
                
                let savePanelAccessoryViewController = KMSavePanelAccessoryController.init()
                let savePanel = NSSavePanel()
                savePanel.nameFieldStringValue = fileName
                savePanel.allowedFileTypes = ["pdf"]
                savePanel.accessoryView = savePanelAccessoryViewController.view
                savePanel.beginSheetModal(for: self.window!) { result in
                    if result == .OK {
                        self._clearImageData()
                        self.cancelAction?()
                        var outputSavePanel = savePanel.url?.path ?? ""
                        DispatchQueue.main.async {
                            var success = false
                            if pdf.isEncrypted {
                                options.updateValue(password, forKey: .userPasswordOption)
                                options.updateValue(password, forKey: .ownerPasswordOption)
                                success = pdf.write(toFile: outputSavePanel, withOptions: options)
                            } else {
                                success = pdf.write(toFile: outputSavePanel)
                            }
                            
                            if success {
                                if savePanelAccessoryViewController.needOpen {
                                    NSDocumentController.shared.openDocument(withContentsOf: savePanel.url!, display: true) { document, open, error in
                                        
                                    }
                                } else {
                                    NSWorkspace.shared.activateFileViewerSelecting([NSURL(fileURLWithPath: outputSavePanel) as URL])
                                }
                            } else {
                                let alert = NSAlert.init()
                                alert.alertStyle = .critical
                                alert.messageText = "\(String(describing: files.first?.filePath.lastPathComponent)) + \(NSLocalizedString("Failed to merge!", comment: ""))"
                                alert.runModal()
                            }
                        }
                    }
                }
            } else {
                let savePanelAccessoryViewController = KMSavePanelAccessoryController.init()
                let savePanel = NSSavePanel()
                savePanel.nameFieldStringValue = fileName
                savePanel.allowedFileTypes = ["pdf"]
                savePanel.accessoryView = savePanelAccessoryViewController.view
                savePanel.beginSheetModal(for: self.window!) { result in
                    if result == .OK {
                        self._clearImageData()
                        self.cancelAction?()
                        var outputSavePanel = savePanel.url?.path
                        DispatchQueue.main.async {
                            var success = self.oldPDFDocument.write(toFile: outputSavePanel!)
                            if !success {
                                success = ((try?self.oldPDFDocument.dataRepresentation()?.write(to: URL(string: outputSavePanel!)!)) != nil)
                            }
                            
                            if success {
                                if savePanelAccessoryViewController.needOpen {
                                    NSDocumentController.shared.openDocument(withContentsOf: savePanel.url!, display: true) { document, open, error in
                                        
                                    }
                                } else {
                                    NSWorkspace.shared.activateFileViewerSelecting([NSURL(fileURLWithPath: outputSavePanel!) as URL])
                                }
                            } else {
                                let alert = NSAlert.init()
                                alert.alertStyle = .critical
                                alert.messageText = "\(String(describing: files.first?.filePath.lastPathComponent)) + \(NSLocalizedString("Failed to merge!", comment: ""))"
                                alert.runModal()
                            }
                        }
                    }
                }
            }
        }
    }
    
    func fetchAllOfChildren(_ aOutline: PDFOutline, containerArray aMArray: inout [PDFOutline]) {
        if !aMArray.contains(aOutline) {
            aMArray.append(aOutline)
        }
        
        for i in 0..<aOutline.numberOfChildren {
            if let childOutline = aOutline.child(at: i) {
                aMArray.append(childOutline)
                fetchAllOfChildren(childOutline, containerArray: &aMArray)
            }
        }
    }
    
    func handleReDraw() {
        if mergeView.originalSizeButton.state == .on {
            
        } else {
            let size = self.mergeView.newPageSize
            if size.width < 0 {
                return
            }
            
            var pagesArray: [PDFPage] = []
            let pageCount = self.oldPDFDocument.pageCount
            for i in 0..<pageCount {
                pagesArray.append(self.oldPDFDocument.page(at: 0)!)
                self.oldPDFDocument.removePage(at: 0)
            }
            
            for i in 0..<pageCount {
                let page: KMMergePDFPage = KMMergePDFPage.init()
                page.setBounds(NSMakeRect(0, 0, size.width, size.height), for: .mediaBox)
                page.drawingPage = pagesArray[i]
                self.oldPDFDocument.insert(page, at: i)
            }
            
            if self.oldPDFDocument.outlineRoot != nil {
                let childCount = self.oldPDFDocument.outlineRoot?.numberOfChildren
                var outlineArray: [PDFOutline] = []
                
                for i in 0..<childCount! {
                    outlineArray.append((self.oldPDFDocument.outlineRoot?.child(at: i))!)
                }
                
                for outline in outlineArray {
                    outline.removeFromParent()
                }
            }
        }
    }
}

class KMMergePDFPage: PDFPage {
    var drawingPage: PDFPage?
    
    override func draw(with box: PDFDisplayBox, to context: CGContext) {
        super.draw(with: box, to: context)
        
        let pageSize = self.bounds(for: .cropBox).size
        self.drawPage(with: context, page: self.drawingPage!, pageSize: pageSize)
    }
    
    func drawPage(with context: CGContext, page: PDFPage, pageSize: CGSize) {
        var originalSize = page.bounds(for: .cropBox).size
        
        // 如果页面的旋转角度为90或者270，宽高交换
        if page.rotation % 180 != 0 {
            originalSize = CGSize(width: originalSize.height, height: originalSize.width)
        }
        
        let wRatio = pageSize.width / originalSize.width
        let hRatio = pageSize.height / originalSize.height
        let ratio = min(wRatio, hRatio)
        
        context.saveGState()
        let xTransform = (pageSize.width - originalSize.width * ratio) / 2
        let yTransform = (pageSize.height - originalSize.height * ratio) / 2
        context.translateBy(x: xTransform, y: yTransform)
        context.scaleBy(x: ratio, y: ratio)
        
        if #available(macOS 10.12, *) {
            page.draw(with: .cropBox, to: context)
            page.transformContext(for: .cropBox)
        } else {
            NSGraphicsContext.saveGraphicsState()
            NSGraphicsContext.current = NSGraphicsContext(cgContext: context, flipped: false)
            page.draw(with: .cropBox)
            NSGraphicsContext.restoreGraphicsState()
            page.transformContext(for: .cropBox)
        }
        
        context.restoreGState()
    }
}