PDF_Office/PDF Office/PDF Master/Class/PDFWindowController/Side/LeftSide/KMLeftSideViewController+Note.swift

//
//  KMLeftSideViewController+Note.swift
//  PDF Reader Pro
//
//  Created by tangchao on 2023/12/23.
//

import Foundation

extension KMLeftSideViewController.Key {
    static let noteAscendSortKey = "KMLeftSideViewAscendSortBoolKey"
    static let noteSortTypeKey = "KMLeftSideViewNoteSortTypeKey"
    
    static let noteTableColumn = "KMNoteOutlineViewTableColumnKey"
    static let noteFilterPage = "kKMNoteFilterAnnotationPageKey"
    static let noteFilterTime = "kKMNoteFilterAnnotationTimeKey"
    static let noteFilterAuther = "kKMNoteFilterAnnotationAutherKey"
}

// MARK: - Menu

extension KMLeftSideViewController {
    func note_initSubViews() {
        self.noteSearchField.backgroundColor = KMAppearance.Layout.l_1Color()
        self.noteSearchField.wantsLayer = true
        self.noteSearchField.layer?.backgroundColor = KMAppearance.Layout.l_1Color().cgColor
        self.noteSearchField.layer?.borderWidth = 1.0
        
        self.noteMoreButton.target = self
        self.noteMoreButton.tag = 304
        self.noteMoreButton.action = #selector(leftSideViewMoreButtonAction)
        self.moreButtonLayer = KMButtonLayer()
        self.noteMoreButton.layer?.addSublayer(self.moreButtonLayer!)
        self.moreButtonLayer?.frame = CGRectMake(0, 0, CGRectGetWidth(self.noteMoreButton.bounds), CGRectGetHeight(self.noteMoreButton.bounds))
        
        self.noteFilterButton.target = self
        self.noteFilterButton.action = #selector(noteFilterAction)
        
        self.filterButtonLayer = NSView()
        self.noteFilterButton.addSubview(self.filterButtonLayer!)
        self.filterButtonLayer?.frame = CGRectMake(14, 2, 8, 8)

        self.noteDoneButton.action = #selector(leftSideViewDoneButtonAction)
        self.noteDoneButton.target = self
        self.noteDoneButton.tag = 311
        self.noteDoneButton.isHidden = true        
        
        self.noteSearchField.delegate = self
        self.noteSearchField.isHidden = true
        self.noteSearchField.endEditCallBack = { [unowned self] isEndEdit in
            if (isEndEdit) {
                self.noteSearchField.isHidden = true
                self.noteSearchButton.isHidden = false
                self.noteTitleLabel.isHidden = false
            }
        }

        self.sortTypeBox.downCallback = { [unowned self] downEntered, mouseBox, _ in
            if (downEntered) {
                let menu = NSMenu()
                let timeItem = menu.addItem(title: KMLocalizedString("Time", nil), action: #selector(sortTypeAction), target: self)
                timeItem?.representedObject = self
                timeItem?.tag = 0
                let pageItem = menu.addItem(title: KMLocalizedString("Page", nil), action: #selector(sortTypeAction), target: self)
                pageItem?.representedObject = self
                timeItem?.tag = 1
                if (self.noteSortType == .time) {
                    timeItem?.state = .on
                    pageItem?.state = .off
                } else if (self.noteSortType == .page) {
                    timeItem?.state = .off
                    pageItem?.state = .on
                }
                menu.popUp(positioning: nil, at: CGPointMake(-10, 0), in: self.sortTypeBox)
            }
        }
 
        self.noteOutlineView.delegate = self
        self.noteOutlineView.dataSource = self
        self.noteOutlineView.botaDelegate = self
        self.noteOutlineView.botaDataSource = self
        self.noteOutlineView.noteDelegate = self
        self.noteOutlineView.menu = NSMenu()
        self.noteOutlineView.menu?.delegate = self
        self.noteOutlineView.typeSelectHelper = SKTypeSelectHelper(matchOption: .SKSubstringMatch)
        
        self.noteOutlineView.registerForDraggedTypes(NSColor.readableTypes(for: NSPasteboard(name: .drag)))
        self.noteOutlineView.target = self
        self.noteOutlineView.doubleAction = #selector(selectSelectedNote)
    }
    
    func note_initDefalutValue() {
        self.noteView.wantsLayer = true
        self.noteView.layer?.backgroundColor = KMAppearance.Layout.l0Color().cgColor
        
        let sud = UserDefaults.standard
        if let dict = sud.dictionary(forKey: Self.Key.noteTableColumn) {
            self.noteTypeDict = dict
        } else {
            self.noteTypeDict = [Self.Key.noteFilterPage : false,
                                 Self.Key.noteFilterTime : false,
                                 Self.Key.noteFilterAuther : false]
            sud.sync_setValue(self.noteTypeDict, forKey: Self.Key.noteTableColumn)
        }
        self.caseInsensitiveNoteSearch = sud.bool(forKey: SKCaseInsensitiveNoteSearchKey)
        self.isAscendSort = KMDataManager.ud_bool(forKey: Self.Key.noteAscendSortKey)
        
        self.noteTitleLabel.stringValue = KMLocalizedString("Notes", nil);
        self.noteTitleLabel.textColor = KMAppearance.Layout.h0Color()
        
        self.noteSearchField.layer?.borderColor = KMAppearance.Interactive.a0Color().cgColor
        
        self.noteMoreButton.wantsLayer = true
        self.moreButtonLayer?.layerType = .none
        self.moreButtonLayer?.isHidden = true
        
        self.noteFilterButton.toolTip = KMLocalizedString("Sort", nil)
        self.noteFilterButton.wantsLayer = true
        self.filterButtonLayer?.isHidden = true
        self.filterButtonLayer?.wantsLayer = true
        self.filterButtonLayer?.layer?.backgroundColor = KMAppearance.Interactive.a0Color().cgColor
        self.filterButtonLayer?.layer?.cornerRadius = 4.0
        
        if (self.isAscendSort) {
            self.noteSortButton.image = NSImage(named: KMImageNameBtnSidebarRankReverse)
            self.noteSortButton.toolTip = KMLocalizedString("ascending sort", nil)
        } else {
            self.noteSortButton.image = NSImage(named: KMImageNameBtnSidebarRankPositive)
            self.noteSortButton.toolTip = KMLocalizedString("descending sort", nil)
        }
        
        self.noteSearchButton.toolTip = KMLocalizedString("Search", nil)
        
        self.noteDoneButton.title = KMLocalizedString("Done", nil)
        self.noteDoneButton.toolTip = KMLocalizedString("Done", nil)
        self.noteDoneButton.setTitleColor(KMAppearance.Layout.w0Color())
        self.noteDoneButton.wantsLayer = true
        self.noteDoneButton.layer?.backgroundColor = KMAppearance.Interactive.a0Color().cgColor
        self.noteDoneButton.layer?.cornerRadius = 4.0
        
        self.noteHeaderView.wantsLayer = true
        self.noteHeaderView.layer?.backgroundColor = KMAppearance.Else.textTagColor().cgColor
        self.noteHeaderView.layer?.cornerRadius = 1.0
        let sortType = KMDataManager.ud_integer(forKey: Self.Key.noteSortTypeKey)
        if (sortType == 1) {
            self.noteSortType = KMNoteSortType(rawValue: sortType) ?? .none
            if (self.noteSortType == .time) {
                self.sortTypeLabel.stringValue = KMLocalizedString("Time", nil)
                self.sortTypeBox.toolTip = KMLocalizedString("Time", nil)
            } else if (self.noteSortType == .page) {
                self.sortTypeLabel.stringValue = KMLocalizedString("Page", nil)
                self.sortTypeBox.toolTip = KMLocalizedString("Page", nil)
            }
        } else {
            self.noteSortType = .time
            self.sortTypeLabel.stringValue = KMLocalizedString("Time", nil)
        }
        self.sortTypeLabel.textColor = KMAppearance.Layout.h1Color()
         
        self.noteOutlineView.backgroundColor = KMAppearance.Layout.l0Color()
        self.noteOutlineView.autoresizesOutlineColumn = false
        self.noteOutlineView.indentationPerLevel = 0
    }
    
    @IBAction func note_expandAllComments(_ sender: AnyObject?) {
        if (self.foldType == .unfold) { // 已全部展开
            return
        }
        // 设置全部展开的标识
        self.foldType = .unfold
        // 加载数据
        self.loadUnfoldDate(.none)
        // 刷新UI
        self.noteOutlineView.reloadData()
    }
    
    @IBAction func note_foldAllComments(_ sender: AnyObject?) {
        if (self.foldType == .fold) {
            return
        }
        self.foldType = .fold
        self.loadUnfoldDate(.none)
        
        self.noteOutlineView.reloadData()
    }
    
    @IBAction func noteShowNoteAction(_ sender: AnyObject?) {
        let item = sender as? NSMenuItem
        let tag = item?.tag ?? 0
        if (tag == 100) {
        } else if (tag == 101) {
            let isPage = self.noteTypeDict[Self.Key.noteFilterPage] as? Bool ?? false
            self.noteTypeDict[Self.Key.noteFilterPage] = !isPage
        } else if (tag == 102) {
            let isTime = self.noteTypeDict[Self.Key.noteFilterTime] as? Bool ?? false
            self.noteTypeDict[Self.Key.noteFilterTime] = !isTime
        } else if (tag == 103) {
            let isAuther = self.noteTypeDict[Self.Key.noteFilterAuther] as? Bool ?? false
            self.noteTypeDict[Self.Key.noteFilterAuther] = !isAuther
        }
        UserDefaults.standard.sync_setValue(self.noteTypeDict, forKey: Self.Key.noteTableColumn)
            
        let selectRow = self.noteOutlineView.selectedRow
        self.noteOutlineView.reloadData()
        self.noteOutlineView.selectRowIndexes(IndexSet(integer: selectRow), byExtendingSelection: false)
    }
    
    @objc func exportAnnotationNotes(_ sender: AnyObject?) {
        let doc = self.view.window?.windowController?.document as? NSDocument
        doc?.saveTo(sender)
    }
    
    @objc func leftSideEmptyAnnotationClick_DeleteAnnotation(_ sender: AnyObject?) {
        guard let doc = self.listView.document else {
            return
        }
        Task {
            let response = await KMAlertTool.runModel(message: KMLocalizedString("This will permanently remove all annotations. Are you sure to continue?", nil), buttons: [KMLocalizedString("Yes", nil), KMLocalizedString("No", nil)])
            if response == .alertFirstButtonReturn {
                var annos: [CPDFAnnotation] = []
                for i in 0 ..< doc.pageCount {
                    let page = self.listView.document.page(at: i)
                    for anno in page?.annotations ?? [] {
                        if anno is CPDFTextWidgetAnnotation || anno is CPDFButtonWidgetAnnotation || anno is CPDFChoiceWidgetAnnotation {
                            continue
                        }
                        //                        if ([annotation.widgetFieldType isEqualToString:PDFAnnotationWidgetSubtypeSignature]) {
                        //                            continue;
                        //                        }
                        annos.append(anno)
                    }
                }
                for anno in annos {
                    self.listView.remove(anno)
                }
                
                self.reloadAnnotation()
            }
        }
    }
    
    @objc func unfoldNoteAction(_ sender: NSMenuItem) {
        if sender.state == .on {
            return
        }
        let row = self.noteOutlineView.clickedRow
        guard let foldNote = self.fetchNote(for: row) else {
            return
        }
        if self.allFoldNotes.contains(foldNote) == false {
            self.allFoldNotes.append(foldNote)
        }

        if self.allFoldNotes.count == self.canFoldNotes.count {
            self.foldType = .unfold
        } else {
            self.foldType = .none
        }
        
        let viewS = self.noteOutlineView.view(atColumn: 0, row: row, makeIfNecessary: true)
        (viewS as? KMNoteTableViewCell)?.isFold = false
    }
    
    @objc func foldNoteAction(_ sender: NSMenuItem) {
//        if sender.state == .on {
//            return
//        }
        
        let row = self.noteOutlineView.clickedRow
        guard let foldNote = self.fetchNote(for: row) else {
            return
        }
        
        if self.allFoldNotes.contains(foldNote) == false {
            self.allFoldNotes.append(foldNote)
        }
        
        if (self.allFoldNotes.count == 0) {
            self.foldType = .fold
        } else {
            self.foldType = .none
        }

        let viewS = self.noteOutlineView.view(atColumn: 0, row: row, makeIfNecessary: true)
        (viewS as? KMNoteTableViewCell)?.isFold = true
    }
    
    @objc func deleteNotes(_ sender: NSMenuItem) {
        self.outlineView(self.noteOutlineView, deleteItems: sender.representedObject as? [Any] ?? [])
    }
    
    @objc func removeAllAnnotations(_ sender: AnyObject?) {
        self.leftSideEmptyAnnotationClick_DeleteAnnotation(nil)
    }
    
    @objc func editNoteTextFromTable(_ sender: NSMenuItem) {
//        PDFAnnotation *annotation = [sender representedObject];
        guard let annotation = sender.representedObject as? CPDFAnnotation else {
            return
        }
        self.listView.scrollAnnotationToVisible(annotation)
//        self.listView.activeAnnotation = annotation
//        [self showNote:annotation];
//        SKNoteWindowController *noteController = (SKNoteWindowController *)[self windowControllerForNote:annotation];
//        [[noteController window] makeFirstResponder:[noteController textView]];
//        [[noteController textView] selectAll:nil];
    }
    
    @objc func editThisAnnotation(_ sender: AnyObject?) {
        KMPrint("editThisAnnotation ...")
    }
    
    @objc func editNoteFromTable(_ sender: AnyObject?) {
        KMPrint("editNoteFromTable ...")
    }
    
    @IBAction func noteSortAction(_ sender: AnyObject?) {
        if (self.isAscendSort) {
            self.isAscendSort = false
            self.noteSortButton.image = NSImage(named: KMImageNameBtnSidebarRankPositive)
            self.noteSortButton.toolTip = KMLocalizedString("descending sort", nil)
        } else {
            self.isAscendSort = true
            self.noteSortButton.image = NSImage(named: KMImageNameBtnSidebarRankReverse)
            self.noteSortButton.toolTip = KMLocalizedString("ascending sort", nil)
        }
        KMDataManager.ud_set(self.isAscendSort, forKey: Self.Key.noteAscendSortKey)
        
//        self.annotationSort(sortArray: [])
        self.reloadAnnotation()
    }
    
    @IBAction func noteSearchAction(_ sender: NSButton) {
        self.noteSearchField.isHidden = false
        self.noteTitleLabel.isHidden = true
        self.noteSearchButton.isHidden = true
        self.noteDoneButton.isHidden = false
        self.noteFilterButton.isHidden = true
        self.noteMoreButton.isHidden = true
        
        self.noteSearchField.becomeFirstResponder()
    }
    
    @IBAction func noteFilterAction(_ sender: AnyObject?) {
        let button = sender as? NSButton
        
        let menu = NSMenu()
        let filterViewController = KMNoteOutlineFilterViewController()
        filterViewController.listView = self.listView
        filterViewController.view.layer?.backgroundColor = .clear

        var notes = NSMutableArray()
//        for section in self._annotations {
//            if section.annotations?.count != 0 {
//                for item in section.annotations! {
//                    notes.add(item.annotation!)
//                }
//            }
//        }
        filterViewController.setNotesArray(self.allAnnotations as NSArray)
        filterViewController.applyFilterCallback = { [weak self] typeArr, colorArr, authorArr, isEmpty in
            menu.cancelTracking()
            if (isEmpty) {
                self?.filterButtonLayer?.isHidden = true
            } else {
                self?.filterButtonLayer?.isHidden = false
            }

            self?.reloadAnnotation()
        }
        filterViewController.cancelCallback = { isCancel in
            if (isCancel) {
                menu.cancelTracking()
            }
        }
        let item = menu.addItem(withTitle: "", action: nil, keyEquivalent: "")
        item.target = self
        item.representedObject = filterViewController
        item.view = filterViewController.view

        menu.popUp(positioning: nil, at: CGPointMake(-130, 30), in: button)
    }
    
    func fetchNote(for index: Int) -> CPDFAnnotation? {
        if self.noteSearchMode { // 搜索模式
            return self.noteSearchArray.safe_element(for: index) as? CPDFAnnotation
        } else { // 常规模式(非搜索)
            let section = self.annotations.safe_element(for: index) as? KMBOTAAnnotationSection
            return section?.annotations?.first?.annotation
        }
    }
    
    @IBAction @objc  func sortTypeAction(_ sender: NSMenuItem) {
        let item = sender
        let tag = item.tag
        
        if (item.state == .on) {
            item.state = .off
        } else {
            item.state = .on
        }
        if (tag == 0) {
            self.noteSortType = .page
            self.sortTypeLabel.stringValue = KMLocalizedString("Page", nil)
            self.sortTypeBox.toolTip = KMLocalizedString("Page", nil)
        } else if (tag == 1) {
            self.noteSortType = .time
            self.sortTypeLabel.stringValue = KMLocalizedString("Time", nil)
            self.sortTypeBox.toolTip = KMLocalizedString("Time", nil)
        }
        KMDataManager.ud_set(self.noteSortType.rawValue, forKey: Self.Key.noteSortTypeKey)
        
//        self.annotationSort(sortArray: [])
        self.reloadAnnotation()
    }
}

// MARK: - Note

extension KMLeftSideViewController {
//    func loadAnnotationSortData(_ morePredicates: NSArray) {
//        var isLink = false
//        var typeMutableArr = NSMutableArray()
//        if self.allAnnotations.count > 0 {
//            for annotation in self.allAnnotations {
//                if annotation is CPDFLinkAnnotation || annotation is CPDFTextWidgetAnnotation || annotation is CPDFButtonWidgetAnnotation || annotation is CPDFChoiceWidgetAnnotation {
////                    [annotation.widgetFieldType isEqualToString:PDFAnnotationWidgetSubtypeSignature] ||
////                    [annotation.widgetFieldType isEqualToString:PDFAnnotationWidgetSubtypeText] ||
////                    [annotation.widgetFieldType isEqualToString:PDFAnnotationWidgetSubtypeButton] ||
////                    [annotation.widgetFieldType isEqualToString:PDFAnnotationWidgetSubtypeChoice]) {
//                    isLink = true
//                } else {
//                    if typeMutableArr.contains(annotation.type) == false {
//                        typeMutableArr.add(annotation.type)
//                    }
//                }
//            }
//        }
//
//        var colorMutableArray = NSMutableArray()
//        var typeMutableArray = NSMutableArray()
//        var authorMutableArray = NSMutableArray()
//        for annotation in self.allAnnotations {
//            if annotation is CPDFLinkAnnotation || annotation is CPDFTextWidgetAnnotation || annotation is CPDFButtonWidgetAnnotation || annotation is CPDFChoiceWidgetAnnotation {
////                    [annotation.widgetFieldType isEqualToString:PDFAnnotationWidgetSubtypeSignature] ||
////                    [annotation.widgetFieldType isEqualToString:PDFAnnotationWidgetSubtypeText] ||
////                    [annotation.widgetFieldType isEqualToString:PDFAnnotationWidgetSubtypeButton] ||
////                    [annotation.widgetFieldType isEqualToString:PDFAnnotationWidgetSubtypeChoice]) {
//                let noteColor = annotation.color ?? .clear
//                let noteType = annotation.type ?? ""
//                let authorString = annotation.userName() ?? ""
//                if (noteColor != nil) {
//                    if (colorMutableArray.count > 0) {
//                        if colorMutableArray.contains(noteColor) == false {
//                            colorMutableArray.add(noteColor)
//                        }
//                    } else {
//                        colorMutableArray.add(noteColor)
//                    }
//                }
//                if noteType.isEmpty == false {
//                    if typeMutableArray.count > 0 {
//                        if typeMutableArray.contains(noteType) == false {
//                            typeMutableArray.add(noteType)
//                        }
//                    } else {
//                        typeMutableArray.add(noteType)
//                    }
//                }
//                if authorString.isEmpty == false {
//                    if authorString.count > 0 {
//                        if authorMutableArray.contains(authorString) == false {
//                            authorMutableArray.add(authorString)
//                        }
//                    } else {
//                        authorMutableArray.add(authorString)
//                    }
//                }
//            } else {
//                if typeMutableArr.contains(annotation.type) == false {
//                    typeMutableArr.add(annotation.type)
//                }
//            }
//        }
//
//        let sud = UserDefaults.standard
//        var typeArr = NSMutableArray()
//
//        if let typeData = KMDataManager.ud_object(forKey: NoteFilterVC.filterSelectTypeKey) as? Data {
//            if let data = NSKeyedUnarchiver.unarchiveObject(with: typeData) as? NSArray {
//                typeArr = NSMutableArray(array: data)
//            }
//        }
//        var colorArr = NSMutableArray()
//        if let colorData = sud.object(forKey: NoteFilterVC.filterSelectColorKey) as? Data {
//            if let data = NSKeyedUnarchiver.unarchiveObject(with: colorData) as? NSArray {
//                colorArr = NSMutableArray(array: data)
//            }
//        }
//        var authorArr = NSMutableArray()
//        if let authorData = sud.object(forKey: NoteFilterVC.filterSelectAuthorKey) as? Data {
//            if let data = NSKeyedUnarchiver.unarchiveObject(with: authorData) as? NSArray {
//                authorArr = NSMutableArray(array: data)
//            }
//        }
//
//        var temporaryArr1 = NSMutableArray()
//        var temporaryArr2 = NSMutableArray()
//        var temporaryArr3 = NSMutableArray()
//        if (typeArr.count > 0) {
//            for type in typeArr {
//                if typeMutableArray.contains(type) == false {
//                    temporaryArr1.add(type)
//                }
//            }
//        }
//        if (colorArr.count > 0) {
//            for color in colorArr {
//                if colorMutableArray.contains(color) == false {
//                    temporaryArr2.add(color)
//                }
//            }
//        }
//        if (authorArr.count > 0) {
//            for author in authorArr {
//                if authorMutableArray.contains(author) == false {
//                    temporaryArr3.add(author)
//                }
//            }
//        }
//
//        if (temporaryArr1.count > 0) {
//            for type in temporaryArr1 {
//                typeArr.remove(type)
//            }
//        }
//        if (temporaryArr2.count > 0) {
//            for color in temporaryArr2 {
//                colorArr.remove(color)
//            }
//        }
//        if (temporaryArr3.count > 0) {
//            for author in temporaryArr3 {
//                authorArr.remove(author)
//            }
//        }
//
//        var predicateMutableArr = NSMutableArray()
//    }
    
    func note_refrshUIIfNeed() {
        if self.type.methodType != .Annotation {
            return
        }
        Task { @MainActor in
            self.noteOutlineView.reloadData()
        }
    }
    
    func note_reloadDataIfNeed() {
        if self.type.methodType != .Annotation {
            return
        }
        self.reloadAnnotation()
    }
    
    func note_reloadDataForAnnoIfNeed(anno: CPDFAnnotation) {
        if self.type.methodType != .Annotation {
            return
        }
        if anno is CPDFLineAnnotation || anno is CPDFSquareAnnotation || anno is CPDFCircleAnnotation || anno is CPDFInkAnnotation {
            // 形状注释 + Ink 需要显示框住的内容【刷新】
            for item in self.annotations {
                if let data = item.annotations?.first?.annotation, data.isEqual(to: anno) {
                    self.noteOutlineView.reloadItem(item.annotations?.first)
                    break
                }
            }
        }
    }
    
    func reloadAnnotation() {
        if self.listView != nil {
            let filterKey = self.listView?.document?.documentURL.path ?? ""
            var typeArr: [Any] = KMBotaTools.noteFilterAnnoTypes(key: filterKey)
            var colorArr: [Any] = KMBotaTools.noteFilterColors(key: filterKey)
            var authorArr: [Any] = KMBotaTools.noteFilterAuthors(key: filterKey)
            if typeArr.count == 0 && colorArr.count == 0 && authorArr.count == 0 {
//                self.filtrateButton.image = NSImage(named: "KMImageNameAnnotationsFiltrate")
                self.filterButtonLayer?.isHidden = true
            } else {
//                self.filtrateButton.image = NSImage(named: "icon_annotation_screening_select")self.filterButtonLayer?.isHidden = true
                self.filterButtonLayer?.isHidden = false
            }
            
            var dataArray: [KMBOTAAnnotationSection] = []
            var annotationArray: [CPDFAnnotation] = []
            var allAnnotation: [CPDFAnnotation] = []
            for i in 0 ..< self.listView.document.pageCount {
                var items: [KMBOTAAnnotationItem] = []
                let page = self.listView.document.page(at: i)
                var annos: [CPDFAnnotation] = []
                // 处理过滤
                if typeArr.count == 0 && colorArr.count == 0 && authorArr.count == 0 {
                    let types = ["Highlight","Underline","Strikeout","Freehand","FreeText","Note","Square","Circle","Line","Stamp","Arrow","Image","Redact","Sign"]
                    annos = KMOCToolClass.filterAnnotation(annotations: page?.annotations ?? [],types: types) as? [CPDFAnnotation] ?? []
                } else {
                    var filterAnnos: [CPDFAnnotation] = page?.annotations ?? []
                    if typeArr.count > 0 {
                        filterAnnos = (KMOCToolClass.filterAnnotation(annotations: filterAnnos, types: typeArr) as? [CPDFAnnotation]) ?? []
                    }
                    if (colorArr.count > 0) {
                        filterAnnos = (KMOCToolClass.filterAnnotation(annotations: filterAnnos,colors: colorArr) as? [CPDFAnnotation]) ?? []
                    }
                    if (authorArr.count > 0) {
                        filterAnnos = (KMOCToolClass.filterAnnotation(annotations: filterAnnos,authors: authorArr) as? [CPDFAnnotation]) ?? []
                    }
                    annos = filterAnnos
                }
                //添加签名注释
                for annotation in page?.annotations ?? [] {
                   if annotation.isKind(of: CPDFSignatureAnnotation.self) {
                       annos.append(annotation)
                   }
                }
                for annotation in annos {
                    if annotation.annotationShouldDisplay() == false {
                        annos.removeObject(annotation)
                    }
                }

                //转换所有annotation类型
                let section = KMBOTAAnnotationSection()
                for anno in annos {
                    let item = KMBOTAAnnotationItem()
                    item.section = section
                    item.annotation = anno
                    item.index = Int(anno.page.pageIndex())
                    items.append(item)
                    
                    allAnnotation.append(anno)
                }
                
                if items.count != 0 {
                    section.annotations = items
                    section.page = page
                    section.isItemExpanded = true
                    dataArray.append(section)
                }
                
                //添加所有annotation 用于筛选
                annotationArray += (page?.annotations ?? [])
            }
            
            //  处理排序
            if self.noteSortType == .page {
                var datas: [KMBOTAAnnotationSection] = []
                /// 排序(升序)
                if self.isAscendSort {
                    allAnnotation.sort {
                        let idx0 = $0.page?.pageIndex() ?? 0
                        let idx1 = $1.page?.pageIndex() ?? 0
                        return idx0 <= idx1
                    }
                } else {
                    allAnnotation.sort {
                        let idx0 = $0.page?.pageIndex() ?? 0
                        let idx1 = $1.page?.pageIndex() ?? 0
                        return idx0 > idx1
                    }
                }
                for anno in allAnnotation {
                    let section = KMBOTAAnnotationSection()
                    let item = KMBOTAAnnotationItem()
                    item.section = section
                    item.annotation = anno
                    item.index = Int(anno.pageIndex())
                    
                    section.annotations = [item]
                    section.page = anno.page
                    section.isItemExpanded = true
                    
                    datas.append(section)
                }
                self.annotations = datas
            } else if self.noteSortType == .time {
                var datas: [KMBOTAAnnotationSection] = []
                /// 排序(升序)
                if self.isAscendSort {
                    allAnnotation.sort {
                        if $0.modificationDate() == nil {
                            return false
                        }
                        if $1.modificationDate() == nil {
                            return false
                        }
                        return $0.modificationDate() <= $1.modificationDate()
                    }
                } else {
                    allAnnotation.sort {
                        if $0.modificationDate() == nil {
                            return false
                        }
                        if $1.modificationDate() == nil {
                            return false
                        }
                        return $0.modificationDate() > $1.modificationDate()
                    }
                }
                for anno in allAnnotation {
                    let section = KMBOTAAnnotationSection()
                    let item = KMBOTAAnnotationItem()
                    item.section = section
                    item.annotation = anno
                    item.index = Int(anno.pageIndex())
                    
                    section.annotations = [item]
                    section.page = anno.page
                    section.isItemExpanded = true
                    
                    datas.append(section)
                }
                self.annotations = datas
            }
            
            // 转换对象，用于数据显示
            self.allAnnotations = annotationArray
//            if self.annotations.count < 1 {
//               self.filtrateButton.isEnabled = false
//            } else {
//               self.filtrateButton.isEnabled = true
//            }
        }
        
        Task { @MainActor in
            self.noteOutlineView.reloadData()
        }
    }
    
    // 搜索 Action
    func updateNoteFilterPredicate() {
        var stringValue = self.noteSearchField.stringValue
        if self.caseInsensitiveNoteSearch { // 忽略大小写
            stringValue = stringValue.lowercased()
        }
        
        // 清空数据
        self.noteSearchArray.removeAll()
        if stringValue.isEmpty {
            for section in self.annotations {
                guard let note = section.annotations?.first?.annotation else {
                    continue
                }
                self.noteSearchArray.append(note)
            }
        } else {
            for section in self.annotations {
                guard let note = section.annotations?.first?.annotation else {
                    continue
                }
                var noteString = KMBOTAAnnotationTool.fetchContentLabelString(annotation: note)
                if let anno = note as? CPDFMarkupAnnotation {
                    noteString = anno.markupContent()
                }
                if self.caseInsensitiveNoteSearch {
                    noteString = noteString.lowercased()
                }
                if noteString.contains(stringValue) {
                    self.noteSearchArray.append(note)
                }
            }
        }
        // 刷新 UI
        Task { @MainActor in
            self.noteOutlineView.reloadData()
        }
    }
    
    @objc func selectSelectedNote(_ sender: AnyObject?) {
        if self.listView.hideNotes == false {
            let selectedNotes = self.selectedNotes()
            if selectedNotes.count == 1 {
                let annotation = selectedNotes.last!
                self.listView.go(to: annotation.bounds, on: annotation.page, animated: true)
                
//                [pdfView scrollAnnotationToVisible:annotation];
//                [pdfView setActiveAnnotation:annotation];
                    
                    self.listView.updateActiveAnnotations([annotation])
                    self.listView.setNeedsDisplayAnnotationViewForVisiblePages()
//                }
                
            }
//            NSInteger column = [sender clickedColumn];
//            if (column != -1) {
//                NSString *colID = [[[sender tableColumns] objectAtIndex:column] identifier];
//
//                if ([colID isEqualToString:@"color"]){
//                    for (PDFAnnotation *annotation  in self.pdfView.activeAnnotations) {
//                       if (![annotation isKindOfClass:[PDFAnnotationChoiceWidget class]] &&
//                         ![annotation isKindOfClass:[PDFAnnotationButtonWidget class]] &&
//                         ![annotation isKindOfClass:[PDFAnnotationTextWidget class]]) {
//                            [[NSColorPanel sharedColorPanel] orderFront:nil];
//                            break;
//                        }
//
//                    }
//                }
//            }
        }
    }
    
    func selectedNotes() -> [CPDFAnnotation] {
        var selectedNotes: [CPDFAnnotation] = []
        let rowIndexes = self.noteOutlineView.selectedRowIndexes
        for row in rowIndexes {
            let item = self.noteOutlineView.item(atRow: row)
            if item is KMBOTAAnnotationItem {
                if let anno = (item as! KMBOTAAnnotationItem).annotation {
                    //                if anno.type == nil {
                    //                item = [(SKNoteText *)item note];
                    //                }
                    if selectedNotes.contains(anno) == false {
                        selectedNotes.append(anno)
                    }
                }
            }
        }
        return selectedNotes
    }
    
    func clearAnnotationFilterData() {
        if let _key = self.listView?.document?.documentURL?.path {
            let userDefaults = UserDefaults.standard
            let typeData = try?NSKeyedArchiver.archivedData(withRootObject: [Any](), requiringSecureCoding: false)
            userDefaults.set(typeData, forKey: NoteFilterVC.filterSelectTypeKey + _key)
            let colorData = try?NSKeyedArchiver.archivedData(withRootObject: [Any](), requiringSecureCoding: false)
            userDefaults.set(colorData, forKey: NoteFilterVC.filterSelectColorKey + _key)
            let authorData = try?NSKeyedArchiver.archivedData(withRootObject: [Any](), requiringSecureCoding: false)
            userDefaults.set(authorData, forKey: NoteFilterVC.filterSelectAuthorKey + _key)
            userDefaults.synchronize()
        }
    }
}