PDF_Office/PDF Office/PDF Office/Class/Preference/Tools/KMPreferenceManager.swift

//
//  KMPreferenceManager.swift
//  PDF Office
//
//  Created by tangchao on 2023/2/3.
//

import Cocoa

enum KMPreferenceGroup: String {
case general, display, markup, infomation, other
}

let KMPreferenceInfoKey: String = "KMPreferenceInfoKey"

typealias KMPreferenceKey = String
/// general
/// files
let KMOpenLastUnclosedDocumentWhenAppStartKey: KMPreferenceKey = "KMOpenLastUnclosedDocumentWhenAppStartKey"
let KMOpenLastUnlockedDocumentWhenAppStartKey: KMPreferenceKey = "KMOpenLastUnlockedDocumentWhenAppStartKey"
let KMDocumentMaximunDisplayNumberKey: KMPreferenceKey = "KMDocumentMaximunDisplayNumberKey"
let KMAutoSaveKey: KMPreferenceKey = "KMAutoSaveKey"
let KMAutoSavePerNumberMinuteKey: KMPreferenceKey = "KMAutoSavePerNumberMinuteKey"
let KMCloseFilePromptTypeKey: KMPreferenceKey = "KMCloseFilePromptTypeKey"
/// open image file
let KMOpenImageFileTypeKey: KMPreferenceKey = "KMOpenImageFileTypeKey"
let KMSetDefaultPDFReaderKey: KMPreferenceKey = "KMSetDefaultPDFReaderKey"
/// save password
let KMSavePasswordTypeKey: KMPreferenceKey = "KMSavePasswordTypeKey"
let KMGeneralAuthorNameKey: KMPreferenceKey = "KMGeneralAuthorNameKey"

/// display
let KMViewPageDisplayTypeKey: KMPreferenceKey = "KMViewPageDisplayTypeKey"
let KMViewZoomScaleTypeKey: KMPreferenceKey = "KMViewZoomScaleTypeKey"
let KMLeftSideDisplayTypeKey: KMPreferenceKey = "KMLeftSideDisplayTypeKey"
let KMShowOutlineListKey: KMPreferenceKey = "KMShowOutlineListKey"
let KMLeftSideExpandTypeKey: KMPreferenceKey = "KMLeftSideExpandTypeKey"
let KMPropertyPanelExpandTypeKey: KMPreferenceKey = "KMPropertyPanelExpandTypeKey"
let KMDisplayBackgroundNormalColorKey: KMPreferenceKey = "KMDisplayBackgroundNormalColorKey"
let KMDisplayBackgroundFullScreenColorKey: KMPreferenceKey = "KMDisplayBackgroundFullScreenColorKey"
let KMHighlightFormsKey: KMPreferenceKey = "KMHighlightFormsKey"
let KMDisplayFieldHighlightingColorKey: KMPreferenceKey = "KMDisplayFieldHighlightingColorKey"
let KMDisplayRequiredFieldHighlightingColorKey: KMPreferenceKey = "KMDisplayRequiredFieldHighlightingColorKey"
let KMPageIndicatorTypeKey: KMPreferenceKey = "KMPageIndicatorTypeKey"
let KMHighlightLinksKey: KMPreferenceKey = "KMHighlightLinksKey"

/// markup
let KMMarkupColorHighlightKey: KMPreferenceKey = "KMMarkupColorHighlightKey"
let KMMarkupColorStrikthroughKey: KMPreferenceKey = "KMMarkupColorStrikthroughKey"
let KMMarkupColorUnderlineKey: KMPreferenceKey = "KMMarkupColorUnderlineKey"
let KMMarkupColorPenKey: KMPreferenceKey = "KMMarkupColorPenKey"
let KMMarkupColorTextKey: KMPreferenceKey = "KMMarkupColorTextKey"
let KMMarkupColorNoteKey: KMPreferenceKey = "KMMarkupColorNoteKey"
let KMMarkupColorRectangleFillKey: KMPreferenceKey = "KMMarkupColorRectangleFillKey"
let KMMarkupColorRectangleBorderKey: KMPreferenceKey = "KMMarkupColorRectangleBorderKey"
let KMMarkupColorCircleFillKey: KMPreferenceKey = "KMMarkupColorCircleFillKey"
let KMMarkupColorCircleBorderKey: KMPreferenceKey = "KMMarkupColorCircleBorderKey"
let KMMarkupColorLineKey: KMPreferenceKey = "KMMarkupColorLineKey"
let KMMarkupFontTextTypeKey: KMPreferenceKey = "KMMarkupFontTextTypeKey"
let KMMarkupFontTextAligmentTypeKey: KMPreferenceKey = "KMMarkupFontTextAligmentTypeKey"
let KMMarkupFontNoteTypeKey: KMPreferenceKey = "KMMarkupFontNoteTypeKey"

/// 偏好设置已改变
let KMPreferenceDidChangeNotificationName = "KMPreferenceDidChangeNotificationName"

class KMPreferenceManager: NSObject {
    static let shared = KMPreferenceManager()
    
    private var generalGroupKeys: Array<KMPreferenceKey> = []
    private var displayGroupKeys: Array<KMPreferenceKey> = []
    private var markupGroupKeys: Array<KMPreferenceKey> = []
    
    override init() {
        super.init()
        
        /// 初始化
        generalGroupKeys = self.getDefaultKeys(for: .general)
        displayGroupKeys = self.getDefaultKeys(for: .display)
        markupGroupKeys = self.getDefaultKeys(for: .markup)
        let info = UserDefaults.standard.value(forKey: KMPreferenceInfoKey)
        if (info == nil) {
            let info = self.getDefaultInfo()
            UserDefaults.standard.set(info, forKey: KMPreferenceInfoKey)
            UserDefaults.standard.synchronize()
        }
    }
    
    // MARK: 保存/获取数据
    public func setData(data: Any,forKey key: KMPreferenceKey) -> Bool {
        return self.setData(data: data, forKey: key, in: findGroup(forKey: key))
    }
    
    public func setData(data: Any,forKey key: KMPreferenceKey, in group: KMPreferenceGroup) -> Bool {
        var info: [String : Any]?
        if (UserDefaults.standard.value(forKey: KMPreferenceInfoKey) == nil) {
            info = self.getDefaultInfo()
        } else {
            info = (UserDefaults.standard.value(forKey: KMPreferenceInfoKey) as! [String : Any])
        }
        
        var groupInfo: [String : Any] = info![group.rawValue] as! [String : Any]
        groupInfo.updateValue(data, forKey: key)
        
        info?.updateValue(groupInfo, forKey: group.rawValue)
        UserDefaults.standard.set(info, forKey: KMPreferenceInfoKey)
        UserDefaults.standard.synchronize()
        
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
            NotificationCenter.default.post(name: NSNotification.Name(rawValue: KMPreferenceDidChangeNotificationName), object: [group], userInfo: [key : data])
        }
        
        return true
    }
    
    public func getData(forKey key: KMPreferenceKey) -> Any {
        var info: [String : Any]?
        if (UserDefaults.standard.value(forKey: KMPreferenceInfoKey) == nil) {
            info = self.getDefaultInfo()
        } else {
            info = (UserDefaults.standard.value(forKey: KMPreferenceInfoKey) as! [String : Any])
        }
        
        let groupInfo: [String : Any] = info![findGroup(forKey: key).rawValue] as! [String : Any]
        return groupInfo[key] as Any
    }
    
    // MarkUp
    public func getMarkData(forKey key:KMPreferenceKey) -> NSColor {
        var red: CGFloat = 0.0
        var green: CGFloat = 0.0
        var blue: CGFloat = 0.0
        var alpha: CGFloat = 0.0
        let color : NSColor = UserDefaults.standard.pdfListViewColor(forKey: key) ?? NSColor.white
        if color != nil {
            color.usingColorSpaceName(.calibratedRGB)?.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
        }
        return color
    }
    
    public func setMarkData(color:NSColor,forKey key:KMPreferenceKey) {
        UserDefaults.standard.setPDFListViewColor(color, forKey: key)
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
            NotificationCenter.default.post(name: NSNotification.Name(rawValue: KMPreferenceDidChangeNotificationName), object: [], userInfo: [key : color])
        }
    }
    
    public func setAlignment(alignment:Int,forKey key:KMPreferenceKey) {
        UserDefaults.standard.set(alignment, forKey: key)
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
            NotificationCenter.default.post(name: NSNotification.Name(rawValue: KMPreferenceDidChangeNotificationName), object: [], userInfo: [key : alignment])
        }
    }
    
    public func getAlignment(for key:KMPreferenceKey) -> Int{
        let type : Int = UserDefaults.standard.object(forKey: key) as? Int ?? 1
        return type
    }
    
    private func dataToColor(colors:[Double]) -> NSColor {
        NSColor(red: colors[0], green: colors[1], blue: colors[2], alpha: colors[3])
    }
    
    /// Reset
    
    public func resetMarkUpData() {
        self.markupHighlightColor = self.dataToColor(colors: self.markupHighlightColorValues)
        self.markupStrikthroughColor = self.dataToColor(colors: self.markupStrikthroughColorValues)
        self.markupUnderlineColor = self.dataToColor(colors: self.markupUnderlineColorValues)
        self.markupPenColor = self.dataToColor(colors: self.markupPenColorValues)
        self.markupTextColor = self.dataToColor(colors: self.markupTextColorValues)
        self.markupNoteColor = self.dataToColor(colors: self.markupNoteColorValues)
        self.markupRectangleFillColor = self.dataToColor(colors: self.markupRectangleFillColorValues)
        self.markupRectangleBorderColor = self.dataToColor(colors: self.markupRectangleBorderColorValues)
        self.markupCircleFillColor = self.dataToColor(colors: self.markupCircleFillColorValues)
        self.markupCircleBorderColor = self.dataToColor(colors: self.markupCircleBorderColorValues)
        self.markupLineColor = self.dataToColor(colors: self.markupLineColorValues)
    }
    
    public func resetData(_ group: KMPreferenceGroup) {
        var info: [String : Any]?
        if (UserDefaults.standard.value(forKey: KMPreferenceInfoKey) == nil) {
            info = self.getDefaultInfo()
        } else {
            info = (UserDefaults.standard.value(forKey: KMPreferenceInfoKey) as! [String : Any])
        }
        if(group == .markup) {
            self.resetMarkUpData()
        } else {
            let groupInfo = self.getDefaultInfo()[group.rawValue]
            info?.updateValue(groupInfo as Any, forKey: group.rawValue)
            UserDefaults.standard.set(info, forKey: KMPreferenceInfoKey)
            UserDefaults.standard.synchronize()
            
        }
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
            let info: [String : Any]? = UserDefaults.standard.value(forKey: KMPreferenceInfoKey) as? [String : Any]
            var groupInfo: [KMPreferenceKey : Any]?
            if (info != nil) {
                groupInfo = info![group.rawValue] as? [KMPreferenceKey : Any]
            }
            NotificationCenter.default.post(name: NSNotification.Name(rawValue: KMPreferenceDidChangeNotificationName), object: [group], userInfo: groupInfo != nil ? groupInfo : [:])
        }
    }
    
    public func resetAllData() {
        let info = self.getDefaultInfo()
        UserDefaults.standard.set(info, forKey: KMPreferenceInfoKey)
        UserDefaults.standard.synchronize()
        
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
            var groppInfos: [KMPreferenceKey : Any] = [:]
            for groupInfo in info.values {
                for (key, value) in groupInfo {
                    groppInfos.updateValue(value, forKey: key)
                }
            }
            
            NotificationCenter.default.post(name: NSNotification.Name(rawValue: KMPreferenceDidChangeNotificationName), object: [KMPreferenceGroup.general, KMPreferenceGroup.display, KMPreferenceGroup.markup, KMPreferenceGroup.infomation, KMPreferenceGroup.other], userInfo: groppInfos)
        }
    }
    
    // MARK: 注册 key
    public func register(_ key: KMPreferenceKey, to group: KMPreferenceGroup) -> Bool {
        if (group == .general) {
            if (self.generalGroupKeys.contains(key)) {
                return false
            }
            self.generalGroupKeys.append(key)
        }
        return true
    }
    
    // MARK: 获取信息
    private func findGroup(forKey key: KMPreferenceKey) -> KMPreferenceGroup {
        if (self.generalGroupKeys.contains(key)) {
            return .general
        } else if (self.displayGroupKeys.contains(key)) {
            return .display
        } else if (self.markupGroupKeys.contains(key)) {
            return .markup
        }
        return .other
    }

    private func getDefaultKeys(for group: KMPreferenceGroup) -> Array<KMPreferenceKey> {
        if (group == .general) {
            return [KMOpenLastUnclosedDocumentWhenAppStartKey,
                    KMOpenLastUnlockedDocumentWhenAppStartKey,
                    KMDocumentMaximunDisplayNumberKey,
                    KMAutoSaveKey,
                    KMAutoSavePerNumberMinuteKey,
                    KMCloseFilePromptTypeKey,
                    KMOpenImageFileTypeKey,
                    KMSetDefaultPDFReaderKey,
                    KMSavePasswordTypeKey,
                    KMGeneralAuthorNameKey]
        } else if (group == .display) {
            return [KMViewPageDisplayTypeKey,
                    KMViewZoomScaleTypeKey,
                    KMLeftSideDisplayTypeKey,
                    KMShowOutlineListKey,
                    KMLeftSideExpandTypeKey,
                    KMPropertyPanelExpandTypeKey,
                    KMDisplayBackgroundNormalColorKey,
                    KMDisplayBackgroundFullScreenColorKey,
                    KMHighlightFormsKey,
                    KMDisplayFieldHighlightingColorKey,
                    KMDisplayRequiredFieldHighlightingColorKey,
                    KMPageIndicatorTypeKey,
                    KMHighlightLinksKey]
        } else if (group == .markup) {
            return [CHighlightNoteColorKey,
                    CUnderlineNoteColorKey,
                    CStrikeOutNoteColorKey,
                    CInkNoteColorKey,
                    CFreeTextNoteFontColorKey,
                    CAnchoredNoteColorKey,
                    CSquareNoteInteriorColorKey,
                    CSquareNoteColorKey,
                    CCircleNoteInteriorColorKey,
                    CCircleNoteColorKey,
                    CAnnotationSelfSignLineColorKey,
                    KMMarkupFontTextTypeKey,
                    CFreeTextNoteAlignmentKey,
                    KMMarkupFontNoteTypeKey]
        }
        return []
    }
    
    private func getDefaultInfo() -> Dictionary<String, Dictionary<String, Any>> {
        return [KMPreferenceGroup.general.rawValue : [KMOpenLastUnclosedDocumentWhenAppStartKey : false,
                                                      KMOpenLastUnlockedDocumentWhenAppStartKey : false,
                                                              KMDocumentMaximunDisplayNumberKey : 10,
                                                                                  KMAutoSaveKey : true,
                                                                   KMAutoSavePerNumberMinuteKey : 5,
                                                                       KMCloseFilePromptTypeKey : 0,
                                                                         KMOpenImageFileTypeKey : 0,
                                                                       KMSetDefaultPDFReaderKey : true,
                                                                          KMSavePasswordTypeKey : 2,
                                                                         KMGeneralAuthorNameKey : NSFullUserName()],
                KMPreferenceGroup.display.rawValue : [KMViewPageDisplayTypeKey : 1,
                                                        KMViewZoomScaleTypeKey : 0,
                                                      KMLeftSideDisplayTypeKey : 0,
                                                           KMShowOutlineListKey: true,
                                                       KMLeftSideExpandTypeKey : 0,
                                                  KMPropertyPanelExpandTypeKey : 0,
                                             KMDisplayBackgroundNormalColorKey : self.displayBackgroundNormalColorValues,
                                         KMDisplayBackgroundFullScreenColorKey : self.displayBackgroundFullScreenColorValues,
                                                           KMHighlightFormsKey : true,
                                            KMDisplayFieldHighlightingColorKey : self.displayFieldHighlightingColorValues,
                                    KMDisplayRequiredFieldHighlightingColorKey : self.displayRequiredFieldHighlightingColorValues,
                                                        KMPageIndicatorTypeKey : 2,
                                                           KMHighlightLinksKey : true],
                KMPreferenceGroup.markup.rawValue : [KMMarkupColorHighlightKey : self.markupHighlightColorValues,
                                                  KMMarkupColorStrikthroughKey : self.markupStrikthroughColorValues,
                                                     KMMarkupColorUnderlineKey : self.markupUnderlineColorValues,
                                                           KMMarkupColorPenKey : self.markupPenColorValues,
                                                          KMMarkupColorTextKey : self.markupTextColorValues,
                                                          KMMarkupColorNoteKey : self.markupNoteColorValues,
                                                 KMMarkupColorRectangleFillKey : self.markupRectangleFillColorValues,
                                               KMMarkupColorRectangleBorderKey : self.markupRectangleBorderColorValues,
                                                    KMMarkupColorCircleFillKey : self.markupCircleFillColorValues,
                                                  KMMarkupColorCircleBorderKey : self.markupCircleBorderColorValues,
                                                          KMMarkupColorLineKey : self.markupLineColorValues,
                                                       KMMarkupFontTextTypeKey : 1,
                                               KMMarkupFontTextAligmentTypeKey : 0,
                                                       KMMarkupFontNoteTypeKey : 1],
                KMPreferenceGroup.infomation.rawValue : [:],
                KMPreferenceGroup.other.rawValue : [:]]
    }
    
}

//protocol KMPreferenceManagerColorPart: NSObjectProtocol {
//    var markupHighlightColorValues: [Double] { get }
//}
// MARK: 扩展 颜色
extension KMPreferenceManager {
    fileprivate var displayBackgroundNormalColorValues: [Double] {
        get {
            return [206/255.0, 208/255.0, 212/255.0, 1.0]
        }
    }
    fileprivate var displayBackgroundFullScreenColorValues: [Double] {
        get {
            return [54/255.0, 56/255.0, 59/255.0, 1.0]
        }
    }
    fileprivate var displayFieldHighlightingColorValues: [Double] {
        get {
            return [189/255.0, 223/255.0, 253/255.0, 1.0]
        }
    }
    fileprivate var displayRequiredFieldHighlightingColorValues: [Double] {
        get {
            return [23/255.0, 112/255.0, 224/255.0, 1.0]
        }
    }
    fileprivate var markupHighlightColorValues: [Double] {
        get {
            return [255/255.0, 175/255.0, 37/255.0, 1.0]
        }
    }
    fileprivate var markupStrikthroughColorValues: [Double] {
        get {
            return [243/255.0, 70/255.0, 91/255.0, 1.0]
        }
    }
    fileprivate var markupUnderlineColorValues: [Double] {
        get {
            self.markupStrikthroughColorValues
        }
    }
    fileprivate var markupPenColorValues: [Double] {
        get {
            self.markupStrikthroughColorValues
        }
    }
    fileprivate var markupTextColorValues: [Double] {
        get {
            return [0/255.0, 0/255.0, 0/255.0, 0.0]
        }
    }
    fileprivate var markupNoteColorValues: [Double] {
        get {
            return [255/255.0, 213/255.0, 115/255.0, 1.0]
        }
    }
    fileprivate var markupRectangleFillColorValues: [Double] {
        get {
            return self.markupHighlightColorValues
        }
    }
    fileprivate var markupRectangleBorderColorValues: [Double] {
        get {
            self.markupStrikthroughColorValues
        }
    }
    fileprivate var markupCircleFillColorValues: [Double] {
        get {
            self.markupStrikthroughColorValues
        }
    }
    fileprivate var markupCircleBorderColorValues: [Double] {
        get {
            return self.markupHighlightColorValues
        }
    }
    fileprivate var markupLineColorValues: [Double] {
        get {
            self.markupStrikthroughColorValues
        }
    }
    
    private func setColor(_ color: NSColor, forKey key: KMPreferenceKey) -> Bool {
        var red: CGFloat = 0.0
        var green: CGFloat = 0.0
        var blue: CGFloat = 0.0
        var alpha: CGFloat = 0.0
        color.usingColorSpaceName(.calibratedRGB)?.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
        return KMPreferenceManager.shared.setData(data: [red, green, blue, alpha], forKey: key)
    }
    
    private func getColor(forKey key: KMPreferenceKey) -> NSColor {
        let colors: [Double] = self.getData(forKey: key) as! [Double]
        return NSColor(red: colors[0], green: colors[1], blue: colors[2], alpha: colors[3])
    }
}

// MARK: 扩展 General
extension KMPreferenceManager {
    var openLastUnclosedDocumentWhenAppStart: Bool {
        get {
            return self.getData(forKey: KMOpenLastUnclosedDocumentWhenAppStartKey) as! Bool
        }
        set {
            let _ = self.setData(data: newValue, forKey: KMOpenLastUnclosedDocumentWhenAppStartKey)
        }
    }
    
    var openLastUnlockedDocumentWhenAppStart: Bool {
        get {
            return self.getData(forKey: KMOpenLastUnlockedDocumentWhenAppStartKey) as! Bool
        }
        set {
            let _ = self.setData(data: newValue, forKey: KMOpenLastUnlockedDocumentWhenAppStartKey)
        }
    }
    
    var documentMaximunDisplayNumber: Int {
        get {
            return self.getData(forKey: KMDocumentMaximunDisplayNumberKey) as! Int
        }
        set {
            let _ = self.setData(data: newValue, forKey: KMDocumentMaximunDisplayNumberKey)
        }
    }
    
    var autoSave: Bool {
        get {
            return self.getData(forKey: KMAutoSaveKey) as! Bool
        }
        set {
            let _ = self.setData(data: newValue, forKey: KMAutoSaveKey)
        }
    }
    
    var autoSavePerNumberMinute: Int {
        get {
            return self.getData(forKey: KMAutoSavePerNumberMinuteKey) as! Int
        }
        set {
            let _ = self.setData(data: newValue, forKey: KMAutoSavePerNumberMinuteKey)
        }
    }
    
    var closeFilePromptType: KMPreferenceCloseFilePromptType {
        get {
            let type: Int? = self.getData(forKey: KMCloseFilePromptTypeKey) as? Int
            if (type != nil && type! == 1) { // 无提示,直接保存
                return .noPromp
            }
            
            return .promp
        }
        set {
            if (newValue == .promp || newValue == .noPromp) {
                let _ = self.setData(data: newValue.rawValue, forKey: KMCloseFilePromptTypeKey)
            }
        }
    }
    
    var openImageFileType: Int {
        get {
            return self.getData(forKey: KMOpenImageFileTypeKey) as! Int
        }
        set {
            let _ = self.setData(data: newValue, forKey: KMOpenImageFileTypeKey)
        }
    }
    
    var author: String {
        get {
            return self.getData(forKey: KMGeneralAuthorNameKey) as! String
        }
        set {
            let _ = self.setData(data: newValue, forKey: KMGeneralAuthorNameKey)
        }
    }
    
    var setDefaultPDFReader: Bool {
        get {
            return self.getData(forKey: KMSetDefaultPDFReaderKey) as! Bool
        }
        set {
            let result = KMTools.setDefaultPDFReader(newValue)
            if (result) {
                let _ = self.setData(data: newValue, forKey: KMSetDefaultPDFReaderKey)
            }
        }
    }
    
    var savePasswordType: KMPreferenceSavePasswordType {
        get {
            let type: Int? = self.getData(forKey: KMSavePasswordTypeKey) as? Int
            if (type == nil || type! == 2) {
                return .ask
            }
            if (type! == 0) {
                return .always
            } else if (type! == 1) {
                return .never
            }
            
            return .ask
        }
        set {
            if (newValue == .always || newValue == .never || newValue == .ask) {
                let _ = self.setData(data: newValue.rawValue, forKey: KMSavePasswordTypeKey)
            }
        }
    }
}

// MARK: 扩展 Display
extension KMPreferenceManager {
    var viewPageDisplayType: KMPDFDisplayType {
        get {
            let type: Int? = self.getData(forKey: KMViewPageDisplayTypeKey) as? Int
            if (type == nil || type == 1) {
                return .singlePageContinuous
            }
            if (type! == 0) {
                return .singlePage
            } else if (type! == 2) {
                return .twoUp
            } else if (type! == 3) {
                return .twoUpContinuous
            } else if (type! == 4) {
                return .bookMode
            } else if (type! == 5) {
                return .bookContinuous
            }
            
            return .singlePageContinuous
        }
        set {
            if (newValue == .singlePage || newValue == .singlePageContinuous || newValue == .twoUp ||
                newValue == .twoUpContinuous || newValue == .bookMode || newValue == .bookContinuous) {
                let _ = self.setData(data: newValue.rawValue, forKey: KMViewPageDisplayTypeKey)
            }
        }
    }
    
    var viewZoomScaleType: KMPDFZoomType {
        get {
            let type: Int? = self.getData(forKey: KMViewZoomScaleTypeKey) as? Int
            if (type == nil || type! == 0) {
                return .width
            } else if (type! == 1) {
                return .fit
            } else if (type! == 2) {
                return .actualSize
            }
            return .width
        }
        set {
            if (newValue == .width || newValue == .fit || newValue == .actualSize) {
                let _ = self.setData(data: newValue.rawValue, forKey: KMViewZoomScaleTypeKey)
            }
        }
    }
    
    var leftSideDisplayType: KMPreferenceLeftSideDisplayType {
        get {
            let type: Int? = self.getData(forKey: KMLeftSideDisplayTypeKey) as? Int
            if (type == nil || type! == 0) {
                return .closeWhenOpenFile
            } else if (type! == 1) {
                return .openAppSaveLastSelect
            }
            return .closeWhenOpenFile
        }
        set {
            if (newValue == .closeWhenOpenFile || newValue == .openAppSaveLastSelect) {
                let _ = self.setData(data: newValue.rawValue, forKey: KMLeftSideDisplayTypeKey)
            }
        }
    }
    
    var showOutlineList: Bool {
        get {
            return self.getData(forKey: KMShowOutlineListKey) as! Bool
        }
        set {
            let _ = self.setData(data: newValue, forKey: KMShowOutlineListKey)
        }
    }
    
//    var leftSideExpandType: Int {
//        get {
//            return self.getData(forKey: KMLeftSideExpandTypeKey) as! Int
//        }
//        set {
//            let _ = self.setData(data: newValue, forKey: KMLeftSideExpandTypeKey)
//        }
//    }
    
    var propertyPanelExpandType: KMPreferencePropertyPanelExpandType {
        get {
            let type: Int? = self.getData(forKey: KMPropertyPanelExpandTypeKey) as? Int
            if (type == nil || type! == 0) {
                return .auto
            } else if (type! == 1) {
                return .manual
            }
            return .auto
        }
        set {
            if (newValue == .auto || newValue == .manual) {
                let _ = self.setData(data: newValue.rawValue, forKey: KMPropertyPanelExpandTypeKey)
            }
        }
    }
    
    var highlightForms: Bool {
        get {
            return self.getData(forKey: KMHighlightFormsKey) as! Bool
        }
        set {
            let _ = self.setData(data: newValue, forKey: KMHighlightFormsKey)
        }
    }

    var pageIndicatorType: KMPreferencePageIndicatorDisplayType {
        get {
            let type: Int? = self.getData(forKey: KMPageIndicatorTypeKey) as? Int
            if (type == nil || type! == 2) {
                return .never
            } else if (type! == 0) {
                return .automatic
            } else if (type! == 1) {
                return .always
            }
            return .never
        }
        set {
            if (newValue == .automatic || newValue == .always || newValue == .never) {
                let _ = self.setData(data: newValue.rawValue, forKey: KMPageIndicatorTypeKey)
            }
        }
    }
    
    var highlightLinks: Bool {
        get {
            return self.getData(forKey: KMHighlightLinksKey) as! Bool
        }
        set {
            let _ = self.setData(data: newValue, forKey: KMHighlightLinksKey)
        }
    }
    
    var displayBackgroundNormalColor: NSColor {
        get {
            return self.getColor(forKey: KMDisplayBackgroundNormalColorKey)
        }
        set {
            let _ = self.setColor(newValue, forKey: KMDisplayBackgroundNormalColorKey)
        }
    }
    
    var displayBackgroundFullScreenColor: NSColor {
        get {
            return self.getColor(forKey: KMDisplayBackgroundFullScreenColorKey)
        }
        set {
            let _ = self.setColor(newValue, forKey: KMDisplayBackgroundFullScreenColorKey)
        }
    }
    
    var displayFieldHighlightingColor: NSColor {
        get {
            return self.getColor(forKey: KMDisplayFieldHighlightingColorKey)
        }
        set {
            let _ = self.setColor(newValue, forKey: KMDisplayFieldHighlightingColorKey)
        }
    }
    
    var displayRequiredFieldHighlightingColor: NSColor {
        get {
            return self.getColor(forKey: KMDisplayRequiredFieldHighlightingColorKey)
        }
        set {
            let _ = self.setColor(newValue, forKey: KMDisplayRequiredFieldHighlightingColorKey)
        }
    }
}

// MARK: 扩展 Markup
extension KMPreferenceManager {
    var markupHighlightColor: NSColor {
        get {
            return self.getMarkData(forKey: CHighlightNoteColorKey)
        }
        set {
            let _ = self.setMarkData(color: newValue, forKey: CHighlightNoteColorKey)
        }
    }
    var markupStrikthroughColor: NSColor {
        get {
            return self.getMarkData(forKey: CStrikeOutNoteColorKey)
        }
        set {
            let _ = self.setMarkData(color:newValue, forKey: CStrikeOutNoteColorKey)
        }
    }
    var markupUnderlineColor: NSColor {
        get {
            return self.getMarkData(forKey: CUnderlineNoteColorKey)
        }
        set {
            let _ = self.setMarkData(color:newValue, forKey: CUnderlineNoteColorKey)
        }
    }
    var markupPenColor: NSColor {
        get {
            return self.getMarkData(forKey: CInkNoteColorKey)
        }
        set {
            let _ = self.setMarkData(color:newValue, forKey: CInkNoteColorKey)
        }
    }
    var markupTextColor: NSColor {
        get {
            return self.getMarkData(forKey: CFreeTextNoteFontColorKey)
        }
        set {
            let _ = self.setMarkData(color:newValue, forKey: CFreeTextNoteFontColorKey)
        }
    }
    var markupNoteColor: NSColor {
        get {
            return self.getMarkData(forKey: CAnchoredNoteColorKey)
        }
        set {
            let _ = self.setMarkData(color:newValue, forKey: CAnchoredNoteColorKey)
        }
    }
    var markupRectangleFillColor: NSColor {
        get {
            return self.getMarkData(forKey: CSquareNoteInteriorColorKey)
        }
        set {
            let _ = self.setMarkData(color:newValue, forKey: CSquareNoteInteriorColorKey)
        }
    }
    var markupRectangleBorderColor: NSColor {
        get {
            return self.getMarkData(forKey: CSquareNoteColorKey)
        }
        set {
            let _ = self.setMarkData(color:newValue, forKey: CSquareNoteColorKey)
        }
    }
    var markupCircleFillColor: NSColor {
        get {
            return self.getMarkData(forKey: CCircleNoteInteriorColorKey)
        }
        set {
            let _ = self.setMarkData(color:newValue, forKey: CCircleNoteInteriorColorKey)
        }
    }
    var markupCircleBorderColor: NSColor {
        get {
            return self.getMarkData(forKey: CCircleNoteColorKey)
        }
        set {
            let _ = self.setMarkData(color:newValue, forKey: CCircleNoteColorKey)
        }
    }
    var markupLineColor: NSColor {
        get {
            return self.getMarkData(forKey: CAnnotationSelfSignLineColorKey)
        }
        set {
            let _ = self.setMarkData(color:newValue, forKey: CAnnotationSelfSignLineColorKey)
        }
    }
    
    var markupFontTextType: Int {
        get {
            return self.getData(forKey: KMMarkupFontTextTypeKey) as! Int
        }
        set {
            let _ = self.setData(data: newValue, forKey: KMMarkupFontTextTypeKey)
        }
    }
    
    var markupFontTextAligmentType: Int {
        get {
            return self.getAlignment(for: CFreeTextNoteAlignmentKey)
        }
        set {
            let _ = self.setAlignment(alignment: newValue, forKey: CFreeTextNoteAlignmentKey)
        }
    }

    var markupFontNoteType: Int {
        get {
            return self.getData(forKey: KMMarkupFontNoteTypeKey) as! Int
        }
        set {
            let _ = self.setData(data: newValue, forKey: KMMarkupFontNoteTypeKey)
        }
    }
}

// MARK: -
// MARK: UserDefaults

internal let kKMLastOpenFilepathKey = "lastOpenFilepath"
internal let kKMViewSettingKey = "viewSetting"
internal let kKMPageNumberKey = "pageNumber"
extension KMPreferenceManager {
    var lastOpenFilepath: String? {
        get {
            return UserDefaults.standard.value(forKey: kKMLastOpenFilepathKey) as? String
        }
        set {
            UserDefaults.standard.set(newValue, forKey: kKMLastOpenFilepathKey)
            UserDefaults.standard.synchronize()
        }
    }
    
    var viewSetting: [KMPreferenceViewSetting : Any]? {
        get {
            return UserDefaults.standard.value(forKey: kKMViewSettingKey) as? [KMPreferenceViewSetting : Any]
        }
        set {
            if (newValue == nil) {
                UserDefaults.standard.set(newValue, forKey: kKMViewSettingKey)
                UserDefaults.standard.synchronize()
                return
            }
            
            var viewSetting: [String : Any]? = UserDefaults.standard.value(forKey: kKMViewSettingKey) as? [String : Any]
            var info: [String : Any] = [:]
            if (viewSetting != nil) {
                for (key, value) in viewSetting! {
                    info.updateValue(value, forKey: key)
                }
            }
            for (key, value) in newValue! {
                if (key == .pageNumber) { // 只处理 枚举
                    info.updateValue(value, forKey: key.rawValue)
                }
            }
            
            UserDefaults.standard.set(info, forKey: kKMViewSettingKey)
            UserDefaults.standard.synchronize()
        }
    }
    
    func setPageNumber(_ number: Int, forKey key: String) {
        UserDefaults.standard.set(number, forKey: "\(key)+\(kKMPageNumberKey)")
        UserDefaults.standard.synchronize()
    }
    
    func getPageNumber(forKey key: String) -> Int? {
        return UserDefaults.standard.value(forKey: "\(key)+\(kKMPageNumberKey)") as? Int
    }
}

// MARK: -
// MARK: Qiuck

extension KMPreferenceManager {
    internal func closeFileIsPrompt() -> Bool {
        return self.closeFilePromptType == .promp
    }
    
    func leftSideNeedCloseWhenOpenFile() -> Bool {
        return KMPreferenceManager.shared.leftSideDisplayType == .closeWhenOpenFile
    }
    
    var autoExpandPropertyPanel: Bool {
        get {
            return KMPreferenceManager.shared.propertyPanelExpandType == .auto
        }
    }
    
    var pageIndicatorIsShow: Bool {
        get {
            return KMPreferenceManager.shared.pageIndicatorType != .never
        }
    }
}