PDF_Office/PDF Office/PDF Master/Class/PDFTools/Background/tool/KMBackgroundManager.swift

//
//  KMBackgroundManager.swift
//  PDF Reader Pro
//
//  Created by tangchao on 2022/12/23.
//

import Cocoa

class KMBackgroundManager: NSObject, NSCoding {
    let kBackgroundFolderPath = NSSearchPathForDirectoriesInDomains(FileManager.SearchPathDirectory.applicationSupportDirectory, FileManager.SearchPathDomainMask.userDomainMask, true).last?.stringByAppendingPathComponent(Bundle.main.bundleIdentifier!).stringByAppendingPathComponent("background")
    let kBackgroundPlistPath = NSSearchPathForDirectoriesInDomains(FileManager.SearchPathDirectory.applicationSupportDirectory, FileManager.SearchPathDomainMask.userDomainMask, true).last?.stringByAppendingPathComponent(Bundle.main.bundleIdentifier!).stringByAppendingPathComponent("background").stringByAppendingPathComponent("background.plist")
    
    var datas: Array<KMBackgroundModel> = []
    
    var backgroundObjects: [KMBackgroundObject] = []
    
    static let defaultManager = KMBackgroundManager()
    
    override init() {
        super.init()
        
        if let storedData = UserDefaults.standard.value(forKey: "kBackgroundInfoSaveKey") as? Data {
            NSKeyedUnarchiver.setClass(KMBackgroundObject.self, forClassName: "KMBackgroundObject")
            NSKeyedUnarchiver.setClass(KMBackgroundManager.self, forClassName: "KMBackgroundManager")
            if let man = NSKeyedUnarchiver.unarchiveObject(with: storedData) as? KMBackgroundManager {
                for object in man.backgroundObjects {
                    let model = self.parseObject(object: object)
                    self.datas.append(model)
                    self.backgroundObjects.append(object)
                }
            }
        }
        
//        if (FileManager.default.fileExists(atPath: kBackgroundPlistPath!)) {
//            let dataDict = NSDictionary(contentsOfFile: kBackgroundPlistPath!)
//            if (dataDict == nil) {
//                return
//            }
//            var deleteKeys: Array<String> = []
//            for keyIndex in 0 ..< (dataDict?.allKeys.count)! {
//                let key: String = dataDict?.allKeys[keyIndex] as! String
//                let backgroundDict: NSDictionary = dataDict?.object(forKey: key) as! NSDictionary
//
//                let model = parseDictionary(dict: backgroundDict)
//                /// 赋值id
//                model.backgroundID = key
//                if (model.type == .file) {
//                    if (model.image == nil) {
//                        deleteKeys.append(key)
//                    } else {
//                        self.datas.append(model)
//                    }
//                } else {
//                    self.datas.append(model)
//                }
//            }
//
//            if (deleteKeys.count > 0) {
//                let newDict: NSMutableDictionary = NSMutableDictionary(dictionary: dataDict!)
//                for key in deleteKeys {
//                    newDict.removeObject(forKey: key)
//                }
//                newDict.write(toFile: kBackgroundPlistPath!, atomically: true)
//            }
//        }
    }
    
    required init?(coder: NSCoder) {
        if let data = coder.decodeObject(forKey: "backgroundObjects") {
            self.backgroundObjects = data as? [KMBackgroundObject] ?? []
        }
    }
    
    func encode(with coder: NSCoder) {
        coder.encode(self.backgroundObjects, forKey: "backgroundObjects")
    }
    
    func addTemplate(model: KMBackgroundModel) -> Bool {
        if (!FileManager.default.fileExists(atPath: kBackgroundFolderPath!)) {
            let create: ()? = try?FileManager.default.createDirectory(atPath: kBackgroundFolderPath!, withIntermediateDirectories: false)
            if (create == nil) {
                return false
            }
        }
        
        if (!FileManager.default.fileExists(atPath: kBackgroundPlistPath!)) {
            let create = try?FileManager.default.createFile(atPath: kBackgroundPlistPath!, contents: nil)
            if (create == nil) {
                return false
            }
        }
        
        let dict = NSDictionary(contentsOfFile: kBackgroundPlistPath!)
        var newDict:NSMutableDictionary!
        if (dict != nil) {
            newDict = NSMutableDictionary(dictionary: dict!)
        } else {
            newDict = NSMutableDictionary()
        }
        
        let backgroundDict = self.parseModel(model: model)
        if (backgroundDict.isEmpty) {
            let alert = NSAlert()
            alert.alertStyle = .critical
            alert.messageText = NSLocalizedString("文件\(model.imagePath.lastPathComponent)已损坏", comment: "")
            alert.runModal()
            return false
        }
        
        let tag = fetchAvailableName()//tagString()
        newDict.addEntries(from: [tag : backgroundDict])
        model.backgroundID = tag
        let result = newDict.write(toFile: kBackgroundPlistPath!, atomically: true)
        if (result) {
            if (self.datas.count < 1) {
                self.datas.append(model)
            } else {
                self.datas.insert(model, at: 0)
            }
        }
        
        let obj = self.parseModeForObject(model)
        self._addBackground(obj)
        
        return result
    }
    
    func deleteTemplate(model: KMBackgroundModel) -> Bool {
        if (model.backgroundID.isEmpty) {
            return false
        }
        
        if (!FileManager.default.fileExists(atPath: kBackgroundPlistPath!)) {
            return false
        }
        
        let key: String = model.backgroundID
        
        let dictionary = NSDictionary(contentsOfFile: kBackgroundPlistPath!)
        var newDictionary: NSMutableDictionary!
        if (dictionary != nil) {
            newDictionary = NSMutableDictionary(dictionary: dictionary!)
        } else {
            newDictionary = NSMutableDictionary()
        }
        newDictionary.removeObject(forKey: key)
        
        let result = newDictionary.write(toFile: kBackgroundPlistPath!, atomically: true)
        if (result) {
            if (model.type == .file) {
                let filePath: String = model.imagePath
                try?FileManager.default.removeItem(atPath: filePath)
            }
            
            if (self.datas.contains(model)) {
                self.datas.removeObject(model)
            }
        }
        
        let obj = self.parseModeForObject(model)
        self._removeBackground(obj)
        
        return result
    }
    
    func deleteAllTemplates() -> Bool {
        if (!FileManager.default.fileExists(atPath: kBackgroundPlistPath!)) {
            return false
        }
        
        let dictionary = NSDictionary(contentsOfFile: kBackgroundPlistPath!)
        var newDictionary: NSMutableDictionary!
        if (dictionary != nil) {
            newDictionary = NSMutableDictionary(dictionary: dictionary!)
        } else {
            newDictionary = NSMutableDictionary()
        }
        
        newDictionary.removeAllObjects()
        
        let result = newDictionary.write(toFile: kBackgroundPlistPath!, atomically: true)
        if (result) {
            self.datas.removeAll()
        }
        
        self._clearStored()
        
        return result
    }
    
    func deleteAllColorTemplates() -> Bool {
        if (!FileManager.default.fileExists(atPath: kBackgroundPlistPath!)) {
            return false
        }
        
        let dictionary = NSDictionary(contentsOfFile: kBackgroundPlistPath!)
        var newDictionary: NSMutableDictionary!
        if (dictionary != nil) {
            newDictionary = NSMutableDictionary(dictionary: dictionary!)
        } else {
            newDictionary = NSMutableDictionary()
        }
        
        let count = self.datas.count-1
        var deleteArray: Array<KMBackgroundModel> = []
        for i in 0 ... count {
            let model = self.datas[i]
            if (model.type == .color) {
                newDictionary.removeObject(forKey: model.backgroundID as Any)
                deleteArray.append(model)
            }
        }
        
        let result = newDictionary.write(toFile: kBackgroundPlistPath!, atomically: true)
        if (result) {
            for model in deleteArray {
                self.datas.removeObject(model)
            }
        }
        
        self._clearStored()
        
        return result
    }
    
    func deleteAllFileTemplates() -> Bool {
        if (!FileManager.default.fileExists(atPath: kBackgroundPlistPath!)) {
            return false
        }
        
        let dictionary = NSDictionary(contentsOfFile: kBackgroundPlistPath!)
        var newDictionary: NSMutableDictionary!
        if (dictionary != nil) {
            newDictionary = NSMutableDictionary(dictionary: dictionary!)
        } else {
            newDictionary = NSMutableDictionary()
        }
        
        let count = self.datas.count-1
        var deleteArray: Array<KMBackgroundModel> = []
        for i in 0 ... count {
            let model = self.datas[i]
            if (model.type == .file) {
                newDictionary.removeObject(forKey: model.backgroundID as Any)
                deleteArray.append(model)
            }
        }
        
        let result = newDictionary.write(toFile: kBackgroundPlistPath!, atomically: true)
        if (result) {
            for model in deleteArray {
                self.datas.removeObject(model)
            }
        }
        
        self._clearStored()
        
        return result
    }
    
    func updateTemplate(model: KMBackgroundModel) -> Bool {
        if (!FileManager.default.fileExists(atPath: kBackgroundFolderPath!)) {
            let create = try?FileManager.default.createDirectory(atPath: kBackgroundFolderPath!, withIntermediateDirectories: false)
            if (create == nil) {
                return false
            }
        }
        
        if (!FileManager.default.fileExists(atPath: kBackgroundPlistPath!)) {
            let create = try?FileManager.default.createFile(atPath: kBackgroundPlistPath!, contents: nil)
            if (create == nil) {
                return false
            }
        }
        
        var flagModel: KMBackgroundModel!
        for model_ in self.datas {
            if (model_.backgroundID == model.backgroundID) {
                flagModel = model_
                break
            }
        }
        
        if (flagModel == nil) {
            return false
        }
        
        let dict = NSDictionary(contentsOfFile: kBackgroundPlistPath!)
        var newDict:NSMutableDictionary!
        if (dict != nil) {
            newDict = NSMutableDictionary(dictionary: dict!)
        } else {
            newDict = NSMutableDictionary()
        }
        
        let modelDict = self.parseModel(model: model)
        if (modelDict.isEmpty) {
            let alert = NSAlert()
            alert.alertStyle = .critical
            alert.messageText = NSLocalizedString("文件\(model.imagePath.lastPathComponent)已损坏", comment: "")
            alert.runModal()
            return false
        }
        
        newDict.setObject(modelDict, forKey: flagModel.backgroundID as NSCopying)
        let result = newDict.write(toFile: kBackgroundPlistPath!, atomically: true)
        if (result) {
            let index = self.datas.index(of: flagModel)
            self.datas[index!] = model
        }
        
        return result
    }
    
    /**
        `Private Methods`
     */
    private func parseModel(model: KMBackgroundModel) -> Dictionary<String, Any> {
        let tag = tagString()
        
        var dict: [String : Any] = [:]
        if (model.type == .color) {
            var red: CGFloat = 0.0
            var green: CGFloat = 0.0
            var blue: CGFloat = 0.0
            model.color!.usingColorSpaceName(NSColorSpaceName.calibratedRGB)?.getRed(&red, green: &green, blue: &blue, alpha: nil)
            dict["red"] = red
            dict["green"] = green
            dict["blue"] = blue
        } else {
            if (!FileManager.default.fileExists(atPath: kBackgroundFolderPath!)) {
                try?FileManager.default.createDirectory(atPath: kBackgroundFolderPath!, withIntermediateDirectories: false)
            }

            let path = kBackgroundFolderPath?.stringByAppendingPathComponent("\(tag).png")
            let image = model.image
            let data = image?.tiffRepresentation
            let imageRep = NSBitmapImageRep(data: data!)
            imageRep?.size = image!.size

            var imageData: Data!
            let pathExtension = model.imagePath.components(separatedBy: ".").last
            if (pathExtension?.lowercased() == "png") {
                imageData = imageRep?.representation(using: NSBitmapImageRep.FileType.png, properties: [:])
            } else {
                imageData = imageRep?.representation(using: NSBitmapImageRep.FileType.jpeg, properties: [:])
            }

            do {
                try imageData.write(to: URL(fileURLWithPath: path!))
                dict["imagePath"] = path?.lastPathComponent
            }
            catch {
                KMPrint("Failed to write to disk.")
                return [:]
            }
        }
        
        dict["type"] = model.type.rawValue
        dict["scale"] = model.scale
        dict["opacity"] = model.opacity
        dict["rotation"] = model.rotation
        dict["horizontalMode"] = model.horizontalMode
        dict["horizontalSpace"] = model.horizontalSpace
        dict["verticalMode"] = model.verticalMode
        dict["verticalSpace"] = model.verticalSpace

        dict["pageRangeType"] = model.pageRangeType.rawValue
        dict["pagesString"] = model.pagesString
        
        return dict
    }
    
    private func parseDictionary(dict: NSDictionary) -> KMBackgroundModel {
        let model = KMBackgroundModel()
        
        model.type = KMBackgroundType(rawValue: dict.object(forKey: "type") as! Int)!
        
        if (model.type == .file) {
            let path = kBackgroundFolderPath?.stringByAppendingPathComponent(dict.object(forKey: "imagePath") as! String)
            if (FileManager.default.fileExists(atPath: path!)) {
                model.image = NSImage(contentsOfFile: path!)
                model.imagePath = path!
            } else {
                model.image = nil
            }
        } else {
            let red: CGFloat = dict.object(forKey: "red") as! CGFloat
            let green: CGFloat = dict.object(forKey: "green") as! CGFloat
            let blue: CGFloat = dict.object(forKey: "blue") as! CGFloat
            model.color = NSColor(red: red, green: green, blue: blue, alpha: 1.0)
        }
        
        model.scale = dict.object(forKey: "scale") as! CGFloat
        model.rotation = CGFloat(Int(dict.object(forKey: "rotation") as! CGFloat))
        model.opacity = (dict.object(forKey: "opacity") as! CGFloat)
        model.verticalMode = (dict.object(forKey: "verticalMode") as! Int)
        model.verticalSpace = (dict.object(forKey: "verticalSpace") as! CGFloat)
        model.horizontalMode = (dict.object(forKey: "horizontalMode") as! Int)
        model.horizontalSpace = (dict.object(forKey: "horizontalSpace") as! CGFloat)
        model.pageRangeType =  KMWatermarkeModelPageRangeType.init(rawValue: (dict.object(forKey: "pageRangeType") as! Int))!
        model.pagesString = (dict.object(forKey: "pagesString") as! String)
        
        return model
    }
    
    private func parseObject(object: KMBackgroundObject) -> KMBackgroundModel {
        let model = KMBackgroundModel()
        
        model.type = object.type
        if (model.type == .file) {
            model.image = object.image
            model.imagePath = object.imagePath ?? ""
        } else {
            model.color = object.color
        }
        
        model.scale = object.scale
        model.rotation = object.rotation.cgFloat
        model.opacity = object.opacity
        model.verticalMode = object.verticalMode
        model.verticalSpace = object.verticalSpace.cgFloat
        model.horizontalMode = object.horizontalMode
        model.horizontalSpace = object.horizontalSpace.cgFloat
        model.pageRangeType = KMWatermarkeModelPageRangeType.init(rawValue: object.pageRangeType.rawValue) ?? .all
        model.pagesString = object.pagesString
        model.backgroundID = object.backgroundID ?? "background0"
        
        return model
    }
    
    private func parseModeForObject(_ mode: KMBackgroundModel) -> KMBackgroundObject {
        let obj = KMBackgroundObject()
        
        obj.type = mode.type
        if (obj.type == .file) {
            obj.image = mode.image
            obj.imagePath = mode.imagePath
        } else {
            obj.color = mode.color ?? .red
        }
        
        obj.scale = mode.scale
        obj.rotation = Int(mode.rotation)
        obj.opacity = mode.opacity
        obj.verticalMode = mode.verticalMode
        obj.verticalSpace = Int(mode.verticalSpace)
        obj.horizontalMode = mode.horizontalMode
        obj.horizontalSpace = Int(mode.horizontalSpace)
        obj.pageRangeType = KMBatchOperatePageChoice.init(rawValue: mode.pageRangeType.rawValue) ?? .All
        obj.pagesString = mode.pagesString
        obj.backgroundID = mode.backgroundID
        
        return obj
    }
    
    private func _addBackground(_ obj: KMBackgroundObject) {
        self.backgroundObjects.insert(obj, at: 0)
        self._store()
    }
    
    private func _removeBackground(_ obj: KMBackgroundObject) {
        self.backgroundObjects.removeObject(obj)
        self._store()
    }
    
    private func _store() {
        let encodedObject = NSKeyedArchiver.archivedData(withRootObject: self)
        let defaults = UserDefaults.standard
        defaults.set(encodedObject, forKey: "kBackgroundInfoSaveKey")
        defaults.synchronize()
    }
    
    private func _clearStored() {
        let defaults = UserDefaults.standard
        defaults.set(nil, forKey: "kBackgroundInfoSaveKey")
        defaults.synchronize()
    }
    
    private func tagString() -> String {
        var result: String = ""
        
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = "yyMMddHHmmss"
        result.append(dateFormatter.string(from: Date()))
        result = result.appendingFormat("%04d", arc4random()%10000)
        
        return result
    }
    
    func fetchAvailableName() -> String {
        var availableIndex = 0
        
        for item in datas {
            if item.backgroundID.hasPrefix("Background") {
                if let index = Int(item.backgroundID.dropFirst("Background".count)), index >= availableIndex {
                    availableIndex = index + 1
                }
            }
        }
        
        return "Background\(availableIndex)"
    }
}