PDF_Office/PDF Office/PDF Master/Class/Batch/Data/KMBatchBaseParameter.swift

//
//  KMBatchBaseParameter.swift
//  PDF Master
//
//  Created by kdanmobile on 2023/10/25.
//

import Cocoa

@objcMembers class KMBatchBaseParameter: NSObject{
    var error: NSError?
    var operateFile: KMBatchOperateFile?
    var pageChoice: KMBatchOperatePageChoice? {
        willSet{
           
        }
        didSet {
            if pageChoice != oldValue {
                self.localPagesArray = nil
            }
        }
    }
    var pageRangeString: String? {
        willSet{
           
        }
        didSet {
            if pageRangeString != oldValue {
                self.localPagesArray = nil
            }
        }
    }
    var progress: Float?
    var status: KMBatchOperateStatus = .Waiting
    var savePath: String?
    var outPutPath: String?
    var pagesArray: [NSNumber]? {
        if self.localPagesArray == nil {
            self.localPagesArray = self.fetchUnlimitPagesArray()
        }
        return self.localPagesArray
    }
    private var localPagesArray: [NSNumber]?
    
    init(file:KMBatchOperateFile) {
        super.init()
        self.operateFile = file
    }
    
    func fetchUnlimitPagesArray() -> [NSNumber]? {
        let document = PDFDocument(url: URL(fileURLWithPath: self.operateFile?.filePath ?? ""))
        let pageNumber = document?.pageCount ?? 0
        if self.pageChoice == .All {
            var selectPages: [NSNumber] = []
            for i in 1...pageNumber {
                selectPages.append(NSNumber(integerLiteral: i))
            }
            return selectPages
        } else if self.pageChoice == .Odd {
            var selectPages: [NSNumber] = []
            for i in stride(from: 1, through: pageNumber, by: 2) {
                selectPages.append(NSNumber(integerLiteral: i))
            }
            return selectPages
        } else if self.pageChoice == .Even {
            var selectPages: [NSNumber] = []
            for i in stride(from: 2, through: pageNumber, by: 2) {
                selectPages.append(NSNumber(integerLiteral: i))
            }
            return selectPages
        } else {
            var pageNumbers: [NSNumber] = []
            var isInvalid = false
            for c in self.pageRangeString! {
                if c != "0" && c != "1" && c != "2" && c != "3" && c != "4" && c != "5" && c != "6" && c != "7" && c != "8" && c != "9" && c != "," && c != "-" {
                    isInvalid = true
                    break
                } else {
                    isInvalid = false
                }
            }
            if !isInvalid {
                let array = self.pageRangeString!.components(separatedBy: ",")
                for s in array {
                    if s.isEmpty {
                        isInvalid = true
                        break
                    } else {
                        let pages = s.components(separatedBy: "-")
                        if pages.count > 2 {
                            isInvalid = true
                            break
                        } else if pages.count == 1 {
                            let p = pages[0]
                            if p.isEmpty || Int(p)! > pageNumber || Int(p)! == 0 {
                                isInvalid = true
                                break
                            } else {
                                var isEqual = false
                                for pageNumber in pageNumbers {
                                    if pageNumber.intValue == Int(p)! {
                                        isEqual = true
                                        isInvalid = true
                                        break
                                    }
                                }
                                if !isEqual {
                                    pageNumbers.append(NSNumber(integerLiteral: Int(p)!))
                                }
                            }
                        } else if pages.count == 2 {
                            let p1 = pages[0]
                            let p2 = pages[1]
                            if p1.isEmpty || p2.isEmpty || Int(p1)! >= Int(p2)! || Int(p2)! > pageNumber || Int(p1)! == 0 {
                                isInvalid = true
                                break
                            } else {
                                var isEqual = false
                                for i in Int(p1)!...Int(p2)! {
                                    for pageNumber in pageNumbers {
                                        if pageNumber.intValue == i {
                                            isEqual = true
                                            isInvalid = true
                                            break
                                        }
                                    }
                                }
                                if !isEqual {
                                    for i in Int(p1)!...Int(p2)! {
                                        pageNumbers.append(NSNumber(integerLiteral: i))
                                    }
                                }
                            }
                        }
                    }
                }
            }
            if (self.pageRangeString!.isEmpty) {
                isInvalid = true
            }
            if isInvalid {
                return nil
            }
            QuickSort(list: pageNumbers as! NSMutableArray, startIndex: 0, endIndex: pageNumbers.count - 1)
            return pageNumbers
        }
    }
    
    func QuickSort(list: NSMutableArray, startIndex: NSInteger, endIndex: NSInteger) {
        if startIndex >= endIndex {
            return
        }
        let temp = list[startIndex] as! NSNumber
        var tempIndex = startIndex
        
        for i in (startIndex + 1)...endIndex {
            let t = list[i] as! NSNumber
            if temp.intValue > t.intValue {
                tempIndex = tempIndex + 1
                list.exchangeObject(at: tempIndex, withObjectAt: i)
            }
        }
        
        list.exchangeObject(at: tempIndex, withObjectAt: startIndex)
        QuickSort(list: list, startIndex: startIndex, endIndex: tempIndex-1)
        QuickSort(list: list, startIndex: tempIndex+1, endIndex: endIndex)
    }
    
    func getUniqueFilePath(filePath: String) -> String {
        var i = 0
        var isDirectory = ObjCBool(false)
        var uniqueFilePath = filePath
        let fileManager = FileManager.default
        fileManager.fileExists(atPath: uniqueFilePath, isDirectory: &isDirectory)
        if isDirectory.boolValue {
            while fileManager.fileExists(atPath: uniqueFilePath) {
                i += 1
                uniqueFilePath = "\(filePath)(\(i))"
            }
        } else {
            while fileManager.fileExists(atPath: uniqueFilePath) {
                i += 1
                let path = "\(filePath.deletingPathExtension)(\(i))"
                uniqueFilePath = path.stringByAppendingPathComponent(filePath.extension)
            }
        }
        
        return uniqueFilePath
    }
    
    func resetState() {
        status = .Waiting
        progress = 0
        error = nil
        savePath = nil
        outPutPath = nil
    }
    func fetchDestinationFilepath() -> String? {
        if self.isEqual(self.operateFile?.convertInfo) {
            // 在子类重写了这个方法，这里永远不会调用，所以不需要写
        } else if self.isEqual(self.operateFile?.addPasswordInfo) {
            if ((self.savePath?.isEmpty) == nil) && ((self.operateFile?.filePath.isEmpty) == nil) {
                var newfileName = self.operateFile!.filePath.lastPathComponent.deletingPathExtension + "_SetPassword"
                newfileName = newfileName.stringByAppendingPathExtension("pdf")
                self.outPutPath = self.getUniqueFilePath(filePath: self.savePath!.stringByAppendingPathComponent(newfileName))
                return self.outPutPath
            }
        } else if self.isEqual(self.operateFile?.removePasswordInfo) {
            if ((self.savePath?.isEmpty) == nil) && ((self.operateFile?.filePath.isEmpty) == nil) {
                var newfileName = self.operateFile!.filePath.lastPathComponent.deletingPathExtension + "_RemovePassword"
                newfileName = newfileName.stringByAppendingPathExtension("pdf")
                self.outPutPath = self.getUniqueFilePath(filePath: self.savePath!.stringByAppendingPathComponent(newfileName))
                return self.outPutPath
            }
        } else if self.isEqual(self.operateFile?.addWatermarkInfo) {
            if ((self.savePath?.isEmpty) == nil) && ((self.operateFile?.filePath.isEmpty) == nil) {
                var newfileName = self.operateFile!.filePath.lastPathComponent.deletingPathExtension + "_Watermark"
                newfileName = newfileName.stringByAppendingPathExtension("pdf")
                self.outPutPath = self.getUniqueFilePath(filePath: self.savePath!.stringByAppendingPathComponent(newfileName))
                return self.outPutPath
            }
        } else if self.isEqual(self.operateFile?.removeWatermarkInfo) {
            if ((self.savePath?.isEmpty) == nil) && ((self.operateFile?.filePath.isEmpty) == nil) {
                var newfileName = self.operateFile!.filePath.lastPathComponent.deletingPathExtension + "_RemoveWatermark"
                newfileName = newfileName.stringByAppendingPathExtension("pdf")
                self.outPutPath = self.getUniqueFilePath(filePath: self.savePath!.stringByAppendingPathComponent(newfileName))
                return self.outPutPath
            }
        } else if self.isEqual(self.operateFile?.addBackgroundInfo) {
            if ((self.savePath?.isEmpty) == nil) && ((self.operateFile?.filePath.isEmpty) == nil) {
                var newfileName = self.operateFile!.filePath.lastPathComponent.deletingPathExtension + "_AddBackground"
                newfileName = newfileName.stringByAppendingPathExtension("pdf")
                self.outPutPath = self.getUniqueFilePath(filePath: self.savePath!.stringByAppendingPathComponent(newfileName))
                return self.outPutPath
            }
        } else if self.isEqual(self.operateFile?.removeBackgroundInfo) {
            if ((self.savePath?.isEmpty) == nil) && ((self.operateFile?.filePath.isEmpty) == nil) {
                var newfileName = self.operateFile!.filePath.lastPathComponent.deletingPathExtension + "_RemoveBackground"
                newfileName = newfileName.stringByAppendingPathExtension("pdf")
                self.outPutPath = self.getUniqueFilePath(filePath: self.savePath!.stringByAppendingPathComponent(newfileName))
                return self.outPutPath
            }
        } else if self.isEqual(self.operateFile?.addHeaderFooterInfo) {
            if ((self.savePath?.isEmpty) == nil) && ((self.operateFile?.filePath.isEmpty) == nil) {
                var newfileName = self.operateFile!.filePath.lastPathComponent.deletingPathExtension + "_AddHeaderFooter"
                newfileName = newfileName.stringByAppendingPathExtension("pdf")
                self.outPutPath = self.getUniqueFilePath(filePath: self.savePath!.stringByAppendingPathComponent(newfileName))
                return self.outPutPath
            }
        } else if self.isEqual(self.operateFile?.removeHeaderFooterInfo) {
            if ((self.savePath?.isEmpty) == nil) && ((self.operateFile?.filePath.isEmpty) == nil) {
                var newfileName = self.operateFile!.filePath.lastPathComponent.deletingPathExtension + "_RemoveHeaderFooter"
                newfileName = newfileName.stringByAppendingPathExtension("pdf")
                self.outPutPath = self.getUniqueFilePath(filePath: self.savePath!.stringByAppendingPathComponent(newfileName))
                return self.outPutPath
            }
        } else if self.isEqual(self.operateFile?.addBatesInfo) {
            if ((self.savePath?.isEmpty) == nil) && ((self.operateFile?.filePath.isEmpty) == nil) {
                var newfileName = self.operateFile!.filePath.lastPathComponent.deletingPathExtension + "_AddBates"
                newfileName = newfileName.stringByAppendingPathExtension("pdf")
                self.outPutPath = self.getUniqueFilePath(filePath: self.savePath!.stringByAppendingPathComponent(newfileName))
                return self.outPutPath
            }
        } else if self.isEqual(self.operateFile?.removeBatesInfo) {
            if ((self.savePath?.isEmpty) == nil) && ((self.operateFile?.filePath.isEmpty) == nil) {
                var newfileName = self.operateFile!.filePath.lastPathComponent.deletingPathExtension + "_RemoveBates"
                newfileName = newfileName.stringByAppendingPathExtension("pdf")
                self.outPutPath = self.getUniqueFilePath(filePath: self.savePath!.stringByAppendingPathComponent(newfileName))
                return self.outPutPath
            }
        } else if self.isEqual(self.operateFile?.compressInfo) {
            if ((self.savePath?.isEmpty) == nil) && ((self.operateFile?.filePath.isEmpty) == nil) {
                var newfileName = self.operateFile!.filePath.lastPathComponent.deletingPathExtension + "_Compressed"
                newfileName = newfileName.stringByAppendingPathExtension("pdf")
                self.outPutPath = self.getUniqueFilePath(filePath: self.savePath!.stringByAppendingPathComponent(newfileName))
                return self.outPutPath
            }
        }
        return nil
    }
}