ViewController.swift

//
//  ViewController.swift
//  FSNotes
//
//  Created by Oleksandr Glushchenko on 7/20/17.
//  Copyright © 2017 Oleksandr Glushchenko. All rights reserved.
//

import Cocoa
import MASShortcut
import FSNotesCore_macOS
import Foundation
import Shout
import UserNotifications
import WebKit

class ViewController: EditorViewController,
    NSSplitViewDelegate,
    NSOutlineViewDelegate,
    NSOutlineViewDataSource,
    NSTextFieldDelegate,
    UNUserNotificationCenterDelegate {
    
    // MARK: - Properties
    public var fsManager: FileSystemEventManager?
    public var projectSettingsViewController: ProjectSettingsViewController?

    private var isPreLoaded = false
    
    let storage = Storage.shared()
    
    private var sidebarTimer = Timer()
    private var selectRowTimer = Timer()

    private let searchQueue = OperationQueue()

    public static var gitQueue = OperationQueue()
    public static var gitQueueBusy: Bool = false
    public static var gitQueueOperationDate: Date?

    public var prevCommit: Commit?

    /* Git */
    private var updateViews = [Note]()

    var tagsScannerQueue = [Note]()

    @available(*, deprecated, message: "Remove after macOS 10.15 is no longer supported")
    public var printerLegacy: PrinterLegacy?

    override var representedObject: Any? {
        didSet { }  // Update the view, if already loaded.
    }

    // MARK: - IBOutlets
    @IBOutlet weak var nonSelectedLabel: NSTextField!

    @IBOutlet weak var splitView: EditorSplitView!
    @IBOutlet var editor: EditTextView!
    @IBOutlet weak var editAreaScroll: EditorScrollView!
    @IBOutlet weak var search: SearchTextField!
    @IBOutlet weak var notesTableView: NotesTableView!
    @IBOutlet var noteMenu: NSMenu!
    @IBOutlet weak var sidebarOutlineView: SidebarOutlineView!
    @IBOutlet weak var sidebarSplitView: NSSplitView!
    @IBOutlet weak var notesListCustomView: NSView!
    @IBOutlet weak var outlineHeader: OutlineHeaderView!
    @IBOutlet weak var showInSidebar: NSMenuItem!
    @IBOutlet weak var searchTopConstraint: NSLayoutConstraint!

    @IBOutlet weak var lockedFolder: NSTextField!
    @IBOutlet weak var newNoteButton: NSButton!
    @IBOutlet weak var titleLabel: TitleTextField! {
        didSet {
            let clickGesture = NSClickGestureRecognizer()
            clickGesture.target = self
            clickGesture.numberOfClicksRequired = 2
            clickGesture.buttonMask = 0x1
            clickGesture.action = #selector(switchTitleToEditMode)
            
            titleLabel.addGestureRecognizer(clickGesture)
        }
    }
    @IBOutlet weak var shareButton: NSButton!
    @IBOutlet weak var sortByOutlet: NSMenuItem!

    @IBOutlet weak var titleBarAdditionalView: NSVisualEffectView! {
        didSet {
            let layer = CALayer()
            layer.frame = titleBarAdditionalView.bounds
            layer.backgroundColor = .clear
            titleBarAdditionalView.wantsLayer = true
            titleBarAdditionalView.layer = layer
            titleBarAdditionalView.alphaValue = 0
        }
    }
    @IBOutlet weak var previewButton: NSButton! {
        didSet {
            previewButton.state = vcEditor?.isPreviewEnabled() == true ? .on : .off
        }
    }
    @IBOutlet weak var titleBarView: TitleBarView! {
        didSet {
            titleBarView.onMouseExitedClosure = { [weak self] in
                DispatchQueue.main.async {
                    NSAnimationContext.runAnimationGroup({ context in
                        context.duration = 0.35
                        self?.titleBarAdditionalView.alphaValue = 0
                        self?.titleLabel.backgroundColor = .clear
                    }, completionHandler: nil)
                }
            }
            titleBarView.onMouseEnteredClosure = { [weak self] in
                DispatchQueue.main.async {
                    guard self?.titleLabel.isEnabled == false || self?.titleLabel.isEditable == false else { return }
                    
                    if let note = self?.editor.note {
                        if note.isEncryptedAndLocked() {
                            self?.lockUnlock.image = NSImage(named: NSImage.lockLockedTemplateName)
                        } else {
                            self?.lockUnlock.image = NSImage(named: NSImage.lockUnlockedTemplateName)
                        }
                    }

                    self?.lockUnlock.isHidden = (self?.editor.note == nil)

                    NSAnimationContext.runAnimationGroup({ context in
                        context.duration = 0.35
                        self?.titleBarAdditionalView.alphaValue = 1
                    }, completionHandler: nil)
                }
            }
        }
    }

    @IBOutlet weak var lockUnlock: NSButton!

    @IBOutlet weak var sidebarScrollView: NSScrollView!
    @IBOutlet weak var notesScrollView: NSScrollView!

    @IBOutlet weak var menuChangeCreationDate: NSMenuItem!

    // MARK: - Overrides
    
    override func viewDidLoad() {
        if isPreLoaded {
            return
        }

        isPreLoaded = true

        if #available(macOS 12.0, *) {
            let image = NSImage(systemSymbolName: "square.and.pencil", accessibilityDescription: nil)
            var config = NSImage.SymbolConfiguration(textStyle: .body, scale: .large)
            config = config.applying(.init(paletteColors: [.systemTeal, .systemGray]))

            newNoteButton.image = image?.withSymbolConfiguration(config)
        } else {
            newNoteButton.image = NSImage(imageLiteralResourceName: "new_note_button").resize(to: CGSize(width: 20, height: 20))
        }

        configureShortcuts()
        configureDelegates()
        configureLayout()
        configureEditor()

        // Must before event manager starts
        self.storage.checkWelcome()
        
        fsManager = FileSystemEventManager(storage: storage, delegate: self)
        fsManager?.start()

        loadBookmarks(data: UserDefaultsManagement.sftpAccessData)
        loadBookmarks(data: UserDefaultsManagement.gitPrivateKeyData)

        loadMoveMenu()
        loadSortBySetting()
        checkSidebarConstraint()

    #if CLOUD_RELATED_BLOCK
        registerKeyValueObserver()
    #endif

        ViewController.gitQueue.maxConcurrentOperationCount = 1

        notesTableView.doubleAction = #selector(self.doubleClickOnNotesTable)

        DispatchQueue.global().async {
            self.storage.loadInboxAndTrash()

            DispatchQueue.main.async {
                self.buildSearchQuery()
                self.configureSidebar()
                self.configureNoteList()
            }
        }
    }
    
    override func viewDidAppear() {
        // Restore window position

        if sidebarOutlineView.isFirstLaunch, let x = UserDefaultsManagement.lastScreenX, let y = UserDefaultsManagement.lastScreenY {
            view.window?.setFrameOrigin(NSPoint(x: x, y: y))

            UserDefaultsManagement.lastScreenX = nil
            UserDefaultsManagement.lastScreenY = nil
        }

        if UserDefaultsManagement.fullScreen {
            view.window?.toggleFullScreen(nil)
        }
    }

    public func preLoadProjectsData() {
        let projectsLoading = Date()
        let results = self.storage.getProjectDiffs()

        OperationQueue.main.addOperation {
            self.sidebarOutlineView.removeRows(projects: results.0)
            self.sidebarOutlineView.insertRows(projects: results.1)
            self.notesTableView.doVisualChanges(results: (results.2, results.3, []))
        }

        print("0. Projects diff loading finished in \(projectsLoading.timeIntervalSinceNow * -1) seconds")

        let diffLoading = Date()
        for project in self.storage.getProjects() {
            let changes = project.checkNotesCacheDiff()
            self.notesTableView.doVisualChanges(results: changes)
        }

        // Reload added projects
        self.fsManager?.restart()
        
        self.storage.migrationAPIIds()

        print("1. Notes diff loading finished in \(diffLoading.timeIntervalSinceNow * -1) seconds")

        let tagsPoint = Date()

        // Schedule git actions
        self.scheduleSnapshots()
        self.schedulePull()

        // Loads tags
        self.storage.loadNotesContent()

        DispatchQueue.main.async {
            if self.storage.isCrashedLastTime {

                // Unsafe – resets selected note
                self.restoreSidebar()
            }

            // Safe – only tags loading
            self.sidebarOutlineView.loadAllTags()
        }

        print("2. Tags loading finished in \(tagsPoint.timeIntervalSinceNow * -1) seconds")

        let highlightCachePoint = Date()
        for note in self.storage.noteList {
            if note.type == .Markdown {
                note.cache(backgroundThread: true)
            }
        }
        
        print("3. Notes attributes cache for \(self.storage.noteList.count) notes in \(highlightCachePoint.timeIntervalSinceNow * -1) seconds")

        let gitCachePoint = Date()
        self.cacheGitRepositories()
        print("4. git history cached in \(gitCachePoint.timeIntervalSinceNow * -1) seconds")

    }
    
    // MARK: - Initial configuration
    
    private func configureLayout() {
        dropTitle()

        editor.configure()
        notesTableView.setDraggingSourceOperationMask(.every, forLocal: false)
                
        if (UserDefaultsManagement.horizontalOrientation) {
            self.splitView.isVertical = false
        }

        self.menuChangeCreationDate.title = NSLocalizedString("Change Creation Date", comment: "Menu")

        self.shareButton.sendAction(on: .leftMouseDown)
        self.setTableRowHeight()

        self.sidebarOutlineView.sidebarItems = Sidebar().getList()
        self.sidebarOutlineView.reloadData()

        sidebarOutlineView.selectionHighlightStyle = .regular
        sidebarOutlineView.backgroundColor = .windowBackgroundColor

        self.sidebarSplitView.autosaveName = "SidebarSplitView"
        self.splitView.autosaveName = "EditorSplitView"

        // Always show notes list at launch
        
        if (self.splitView.subviews[0].frame.width < 10) {
            self.splitView.setPosition(300, ofDividerAt: 0)
        }

        notesScrollView.scrollerStyle = .overlay
        sidebarScrollView.scrollerStyle = .overlay

        if UserDefaultsManagement.appearanceType == .Custom {
            titleBarView.wantsLayer = true
            titleBarView.layer?.backgroundColor = UserDefaultsManagement.bgColor.cgColor
            titleLabel.backgroundColor = UserDefaultsManagement.bgColor
        }

        if let cell = search.cell as? NSSearchFieldCell {
            cell.searchButtonCell?.target = self
            cell.searchButtonCell?.action = #selector(openRecentPopup(_:))
        }

        DistributedNotificationCenter.default().addObserver(self, selector: #selector(onWakeNote(note:)), name: Notification.Name("com.apple.screenIsUnlocked"), object: nil)

        NSWorkspace.shared.notificationCenter.addObserver(
            self, selector: #selector(onSleepNote(note:)),
            name: NSWorkspace.willSleepNotification, object: nil)

        NSWorkspace.shared.notificationCenter.addObserver(
            self, selector: #selector(onUserSwitch(note:)),
            name: NSWorkspace.sessionDidBecomeActiveNotification, object: nil)

        DistributedNotificationCenter.default().addObserver(
            self,
            selector: #selector(onScreenLocked(note:)),
            name: NSNotification.Name(rawValue: "com.apple.screenIsLocked"),
            object: nil
        )
        
        DistributedNotificationCenter.default().addObserver(
            self,
            selector: #selector(onAccentColorChanged(note:)),
            name: NSNotification.Name(rawValue: "AppleColorPreferencesChangedNotification"),
            object: nil
        )

        DistributedNotificationCenter.default.addObserver(
            self,
            selector: #selector(onAccentColorChanged(note:)),
            name: NSNotification.Name(rawValue: "AppleInterfaceThemeChangedNotification"),
            object: nil
        )

    }

    public func restoreSidebar() {
        self.sidebarOutlineView.sidebarItems = Sidebar().getList()
        self.sidebarOutlineView.reloadData()

        self.storage.restoreProjectsExpandState()

        for project in self.storage.getProjects() {
            if project.isExpanded {
                self.sidebarOutlineView.expandItem(project)
            }
        }
    }


    public func configureSidebar() {
        if isVisibleSidebar() {
            self.restoreSidebar()

            if UserDefaultsManagement.lastSidebarItem != nil || UserDefaultsManagement.lastProjectURL != nil {
                if let lastSidebarItem = UserDefaultsManagement.lastSidebarItem {
                    let sidebarItem = self.sidebarOutlineView.sidebarItems?.first(where: { ($0 as? SidebarItem)?.type.rawValue == lastSidebarItem })
                    let item = self.sidebarOutlineView.row(forItem: sidebarItem)
                    if item > -1 {
                        self.sidebarOutlineView.selectRowIndexes([item], byExtendingSelection: false)
                    }
                } else if let lastURL = UserDefaultsManagement.lastProjectURL, let project = self.storage.getProjectBy(url: lastURL) {
                    let item = self.sidebarOutlineView.row(forItem: project)
                    if item > -1 {
                        self.sidebarOutlineView.selectRowIndexes([item], byExtendingSelection: false)
                    }
                }
            }
        }
    }
    
    private func configureNoteList() {
        updateTable() {            
            if UserDefaultsManagement.copyWelcome {
                DispatchQueue.main.async {
                    let welcome = self.storage.getProjects().first(where: { $0.label == "Welcome" })
                    let index = self.sidebarOutlineView.row(forItem: welcome)
                    self.sidebarOutlineView.selectRowIndexes([index], byExtendingSelection: false)
                }

                UserDefaultsManagement.copyWelcome = false
                return
            }

            DispatchQueue.main.async {

                self.restoreOpenedWindows()
                self.importAndCreate()

                DispatchQueue.global().async {
                    self.preLoadProjectsData()
                }
            }
        }
    }

    private func configureEditor() {
        self.editor.isGrammarCheckingEnabled = UserDefaultsManagement.grammarChecking
        self.editor.isContinuousSpellCheckingEnabled = UserDefaultsManagement.continuousSpellChecking
        self.editor.smartInsertDeleteEnabled = UserDefaultsManagement.smartInsertDelete
        self.editor.isAutomaticSpellingCorrectionEnabled = UserDefaultsManagement.automaticSpellingCorrection
        self.editor.isAutomaticQuoteSubstitutionEnabled = UserDefaultsManagement.automaticQuoteSubstitution
        self.editor.isAutomaticDataDetectionEnabled = UserDefaultsManagement.automaticDataDetection
        self.editor.isAutomaticLinkDetectionEnabled = UserDefaultsManagement.automaticLinkDetection
        self.editor.isAutomaticTextReplacementEnabled = UserDefaultsManagement.automaticTextReplacement
        self.editor.isAutomaticDashSubstitutionEnabled = UserDefaultsManagement.automaticDashSubstitution

        if UserDefaultsManagement.appearanceType != AppearanceType.Custom {
            if #available(OSX 10.13, *) {
                self.editor?.linkTextAttributes = [
                    .foregroundColor:  NSColor.init(named: "link")!
                ]
            }
        }

        self.editor.usesFindBar = true
        self.editor.isIncrementalSearchingEnabled = true

        editor.initTextStorage()
        editor.editorViewController = self
        
        self.editor.viewDelegate = self
        
        // configure editor view controller
        
        vcEditor = editor
        vcTitleLabel = titleLabel
        vcEditorScrollView = editAreaScroll
        vcNonSelectedLabel = nonSelectedLabel
        
        super.initView()
    }

    private func configureShortcuts() {
        MASShortcutMonitor.shared().register(UserDefaultsManagement.newNoteShortcut, withAction: {
            self.makeNoteShortcut()
        })
        
        MASShortcutMonitor.shared().register(UserDefaultsManagement.searchNoteShortcut, withAction: {
            self.searchShortcut()
        })
        
        MASShortcutMonitor.shared().register(UserDefaultsManagement.quickNoteShortcut, withAction: {
            self.quickNote(self)
        })
        
        NSEvent.addLocalMonitorForEvents(matching: NSEvent.EventTypeMask.flagsChanged) {
            return $0
        }
        
        NSEvent.addLocalMonitorForEvents(matching: NSEvent.EventTypeMask.keyDown) {
            if self.keyDown(with: $0) {
                return $0
            }

            return nil
        }
    }
    
    private func configureDelegates() {
        self.search.vcDelegate = self
        self.search.delegate = self.search
        self.sidebarSplitView.delegate = self
        self.sidebarOutlineView.viewDelegate = self
        
        if #available(macOS 10.14, *) {
            UNUserNotificationCenter.current().delegate = self
        }
    }
    
    // MARK: - Actions

    @IBAction public func openRecentPopup(_ sender: Any) {
        search.searchesMenu = search.generateRecentMenu()
        let general = search.searchesMenu!.item(at: 0)
        search.searchesMenu!.popUp(positioning: general, at: NSPoint(x: 5, y: search.frame.height + 7), in: search)
    }

    @IBAction func searchAndCreate(_ sender: Any) {
        AppDelegate.mainWindowController?.window?.makeKeyAndOrderFront(nil)
        
        guard let vc = ViewController.shared() else { return }

        if let view = NSApplication.shared.mainWindow?.firstResponder as? NSTextView, let textField = view.superview?.superview {

            if textField.isKind(of: SearchTextField.self) {
                if vc.search.searchesMenu != nil {
                    vc.search.searchesMenu = nil
                } else {
                    vc.search.searchesMenu = vc.search.generateRecentMenu()
                    let general = vc.search.searchesMenu!.item(at: 0)
                    vc.search.searchesMenu!.popUp(positioning: general, at: NSPoint(x: 5, y: vc.search.frame.height + 7), in: vc.search)

                    return
                }
            }
        }

        let size = UserDefaultsManagement.horizontalOrientation
            ? vc.splitView.subviews[0].frame.height
            : vc.splitView.subviews[0].frame.width

        if size == 0 {
            toggleNoteList(self)
        }
        
        vc.search.window?.makeFirstResponder(vc.search)
    }

    @IBAction func sortBy(_ sender: NSMenuItem) {
        if let id = sender.identifier {
            let key = String(id.rawValue.dropFirst(3))
            guard let sortBy = SortBy(rawValue: key) else { return }

            if sortBy.rawValue == UserDefaultsManagement.sort.rawValue {
                UserDefaultsManagement.sortDirection = !UserDefaultsManagement.sortDirection
            }

            UserDefaultsManagement.sort = sortBy

            if let submenu = sortByOutlet.submenu {
                for item in submenu.items {
                    item.state = NSControl.StateValue.off
                }
            }
            
            sender.state = NSControl.StateValue.on
            
            ViewController.shared()?.buildSearchQuery()
            ViewController.shared()?.updateTable()
        }
    }
        
    // Ask project password before move to encrypted
    public func moveReq(notes: [Note], project: Project, completion: @escaping (Bool) -> ()) {
        for note in notes {
            if note.isEncrypted() && project.isEncrypted {
                let alert = NSAlert()
                alert.alertStyle = .critical
                alert.informativeText = NSLocalizedString("You cannot move an already encrypted note to an encrypted directory. You must first decrypt the note and repeat the steps.", comment: "")
                alert.messageText = NSLocalizedString("Move error", comment: "")
                alert.runModal()
                return
            }
        }
        
        // Encrypted and locked
        if project.isEncrypted && project.isLocked() {
            getMasterPassword() { password in
                self.sidebarOutlineView.unlock(projects: [project], password: password)
                if project.password != nil {
                    self.move(notes: notes, project: project)
                    
                    for note in notes {
                        note.encryptAndUnlock(password: password)
                    }
                    completion(true)
                    return
                }
                
                completion(false)
            }
            return
        }
        
        self.move(notes: notes, project: project)
        
        // Encrypted and non locked
        if project.isEncrypted, let password = project.password {
            for note in notes {
                note.encryptAndUnlock(password: password)
            }
        }
        
        completion(true)
    }
    
    private func move(notes: [Note], project: Project) {
        let selectedRow = notesTableView.selectedRowIndexes.min()
        
        for note in notes {
            if note.project == project {
                continue
            }

            if note.isEncrypted() {
                _ = note.lock()
            }

            let destination = project.url.appendingPathComponent(note.name, isDirectory: false)

            note.moveImages(to: project)
            
            _ = note.move(to: destination, project: project)

            if !storage.searchQuery.isFit(note: note) {
                notesTableView.removeRows(notes: [note])

                if let i = selectedRow, i > -1 {
                    if notesTableView.noteList.count > i {
                        notesTableView.selectRow(i)
                    } else {
                        notesTableView.selectRow(notesTableView.noteList.count - 1)
                    }
                }
            }

            note.invalidateCache()
        }
        
        editor.clear()
    }

    override func viewDidResize() {
        guard let vc = ViewController.shared() else { return }
        vc.checkSidebarConstraint()

        super.viewDidResize()
    }

    func reloadSideBar() {
        guard let outline = sidebarOutlineView else { return }

        sidebarTimer.invalidate()
        sidebarTimer = Timer.scheduledTimer(timeInterval: 1.2, target: outline, selector: #selector(outline.reloadSidebar), userInfo: nil, repeats: false)
    }
        
    func setTableRowHeight() {
        notesTableView.rowHeight = CGFloat(21 + UserDefaultsManagement.cellSpacing)
        notesTableView.reloadData()
    }
            
    public func keyDown(with event: NSEvent) -> Bool {
        guard let mw = MainWindowController.shared() else { return false }

        guard self.alert == nil else {
            if event.keyCode == kVK_Escape, let unwrapped = alert {
                mw.endSheet(unwrapped.window)
                self.alert = nil
            }

            return true
        }

        if event.modifierFlags.contains(.shift)
            && event.modifierFlags.contains(.option)
            && event.keyCode == kVK_ANSI_N {

            sidebarOutlineView.createFolder(NSMenuItem())
            return false
        }

        if event.keyCode == kVK_Delete && event.modifierFlags.contains(.command) && editor.hasFocus() {
            editor.deleteToBeginningOfLine(nil)
            return false
        }
        
        // Return / Cmd + Return navigation
        if event.keyCode == kVK_Return {
            if let fr = NSApp.mainWindow?.firstResponder, self.alert == nil {
                if event.modifierFlags.contains(.command) {
                    if fr.isKind(of: NotesTableView.self) {
                        NSApp.mainWindow?.makeFirstResponder(self.sidebarOutlineView)

                        if sidebarOutlineView.selectedRowIndexes.count == 0 {
                            sidebarOutlineView.selectRowIndexes([0], byExtendingSelection: false)
                        } else {
                            sidebarOutlineView.selectRowIndexes(sidebarOutlineView.selectedRowIndexes, byExtendingSelection: false)
                        }

                        return false
                    }
                    
                    if fr.isKind(of: EditTextView.self) || fr.isKind(of: MPreviewView.self) {
                        NSApp.mainWindow?.makeFirstResponder(self.notesTableView)
                        return false
                    }
                } else {
                    if fr.isKind(of: SidebarOutlineView.self) {
                        self.notesTableView.selectCurrent()
                        NSApp.mainWindow?.makeFirstResponder(self.notesTableView)
                        return false
                    }
                    
                    if let note = editor.note, fr.isKind(of: NotesTableView.self) {
                        if note.container != .encryptedTextPack {
                            if vcEditor?.isPreviewEnabled() == true {
                                disablePreview()
                            }
                            NSApp.mainWindow?.makeFirstResponder(editor)
                        }
                        return false
                    }
                }
            }
            
            return true
        }
        
        // Tab / Control + Tab
        if event.keyCode == kVK_Tab {
            if event.modifierFlags.contains(.control) {
                self.notesTableView.window?.makeFirstResponder(self.notesTableView)
                return true
            }

            if let fr = NSApp.mainWindow?.firstResponder, fr.isKind(of: NotesTableView.self) {
                NSApp.mainWindow?.makeFirstResponder(self.notesTableView)
                return false
            }
        }
                
        // Focus search bar on ESC
        if (
            (
                event.keyCode == kVK_Escape
                || (
                    event.characters == "." &&
                    event.modifierFlags.contains(.command)
                )
            )
            && NSApplication.shared.mainWindow == NSApplication.shared.keyWindow
            && UserDefaultsManagement.shouldFocusSearchOnESCKeyDown
            && !editor.hasMarkedText()
        ) {
            self.view.window?.orderFront(nil)
            self.view.window?.makeKey()
            
            search.searchesMenu = nil

            if NSApplication.shared.mainWindow?.firstResponder === editor, editor.selectedRange().length > 0 {
                editor.selectedRange = NSRange(location: editor.selectedRange().upperBound, length: 0)
                return false
            }

            if let view = NSApplication.shared.mainWindow?.firstResponder as? NSTextView, let textField = view.superview?.superview, textField.isKind(of: NameTextField.self) {
                NSApp.mainWindow?.makeFirstResponder( self.notesTableView)
                return false
            }

            if self.editAreaScroll.isFindBarVisible {
                cancelTextSearch()
                NSApp.mainWindow?.makeFirstResponder(editor)
                return false
            }

            // Renaming is in progress
            if titleLabel.isEditable {
                titleLabel.editModeOff()
                titleLabel.window?.makeFirstResponder(notesTableView)
                return false
            }

            UserDefaultsManagement.lastSidebarItem = nil
            UserDefaultsManagement.lastProjectURL = nil
            UserDefaultsManagement.lastSelectedURL = nil

            notesTableView.scroll(.zero)
            
            let hasSelectedNotes = notesTableView.selectedRow > -1
            let hasSelectedBarItem = sidebarOutlineView.selectedRow > -1
            
            if hasSelectedBarItem && hasSelectedNotes {
                UserDataService.instance.isNotesTableEscape = true
                notesTableView.deselectAll(nil)
                NSApp.mainWindow?.makeFirstResponder(search)
                return false
            }

            sidebarOutlineView.deselectAll(nil)
            sidebarOutlineView.scrollRowToVisible(0)
            cleanSearchAndEditArea()

            return true
        }

        // Search cmd-f
        if (event.characters?.unicodeScalars.first == "f" && event.modifierFlags.contains(.command) && !event.modifierFlags.contains(.control)) {
            if self.notesTableView.getSelectedNote() != nil {
                if search.stringValue.count > 0 {
                    let pb = NSPasteboard(name: NSPasteboard.Name.find)
                    pb.declareTypes([.textFinderOptions, .string], owner: nil)
                    pb.setString(search.stringValue, forType: NSPasteboard.PasteboardType.string)
                }

                //Turn off preview mode as text search works only in text editor
                disablePreview()
                return true
            }
        }

        if let fr = mw.firstResponder, !fr.isKind(of: EditTextView.self), !fr.isKind(of: NSTextView.self), !event.modifierFlags.contains(.command),
            !event.modifierFlags.contains(.control) {

            if let char = event.characters {
                let newSet = CharacterSet(charactersIn: char)
                if newSet.isSubset(of: CharacterSet.alphanumerics) {
                    self.search.becomeFirstResponder()
                }
            }
        }

        if event.modifierFlags.contains(.control)
            && !event.modifierFlags.contains(.shift)
            && !event.modifierFlags.contains(.option) {

            switch event.characters?.unicodeScalars.first {
            case "1":
                sidebarOutlineView.selectRowIndexes([0], byExtendingSelection: false)
            case "2":
                sidebarOutlineView.selectRowIndexes([1], byExtendingSelection: false)
            case "3":
                sidebarOutlineView.selectRowIndexes([2], byExtendingSelection: false)
            case "4":
                sidebarOutlineView.selectRowIndexes([3], byExtendingSelection: false)
            case "5":
                sidebarOutlineView.selectRowIndexes([4], byExtendingSelection: false)
            default:
                return true
            }

            return false
        }

        if event.keyCode == kVK_RightArrow {
            if let fr = mw.firstResponder, fr.isKind(of: NotesTableView.self) {
                if let note = vcEditor?.note, note.isEncryptedAndLocked() {
                    unLock(notes: [note])
                    return true
                }
                
                if vcEditor?.isPreviewEnabled() == true {
                    NSApp.mainWindow?.makeFirstResponder(editor.markdownView)
                } else {
                    focusEditArea()
                }

                return false
            }
        }

        if event.keyCode == kVK_LeftArrow {
            if let fr = mw.firstResponder {
                if fr.isKind(of: MPreviewView.self) {
                    sidebarOutlineView.window?.makeFirstResponder(notesTableView)
                    return false
                }

                if fr.isKind(of: NotesTableView.self) {
                    sidebarOutlineView.window?.makeFirstResponder(sidebarOutlineView)

                    if sidebarOutlineView.selectedRowIndexes.count == 0 {
                        sidebarOutlineView.selectRowIndexes([0], byExtendingSelection: false)
                    }

                    return false
                }
            }
        }
        
        return true
    }

    @objc func onWakeNote(note: NSNotification) {
        refillEditArea()
    }

    @IBAction func noteUp(_ sender: NSMenuItem) {
        NSApp.mainWindow?.makeFirstResponder(notesTableView)

        if titleLabel.isEditable {
            titleLabel.editModeOff()
            titleLabel.window?.makeFirstResponder(nil)
        }

        notesTableView.selectPrev()
    }

    @IBAction func noteDown(_ sender: NSMenuItem) {
        NSApp.mainWindow?.makeFirstResponder(notesTableView)

        if titleLabel.isEditable {
            titleLabel.editModeOff()
            titleLabel.window?.makeFirstResponder(nil)
        }

        notesTableView.selectNext()
    }

    @IBAction func sidebarUp(_ sender: NSMenuItem) {
        if titleLabel.isEditable {
            titleLabel.editModeOff()
            titleLabel.window?.makeFirstResponder(nil)
        }

        NSApp.mainWindow?.makeFirstResponder(sidebarOutlineView)

        guard let cgEvent = CGEvent(keyboardEventSource: .none, virtualKey: 126, keyDown: true) else { return }
        cgEvent.flags.remove(.maskShift)
        guard let nsEvent = NSEvent(cgEvent: cgEvent) else { return }
        sidebarOutlineView.keyDown(with: nsEvent)
    }

    @IBAction func sidebarDown(_ sender: NSMenuItem) {
        if titleLabel.isEditable {
            titleLabel.editModeOff()
            titleLabel.window?.makeFirstResponder(nil)
        }

        NSApp.mainWindow?.makeFirstResponder(sidebarOutlineView)

        guard let cgEvent = CGEvent(keyboardEventSource: .none, virtualKey: 125, keyDown: true) else { return }
        cgEvent.flags.remove(.maskShift)
        guard let nsEvent = NSEvent(cgEvent: cgEvent) else { return }
        sidebarOutlineView.keyDown(with: nsEvent)
    }

    @IBAction func makeNote(_ sender: SearchTextField) {
        guard let vc = ViewController.shared() else { return }
        
        if let type = vc.getSidebarType(), type == .Trash {
            vc.sidebarOutlineView.deselectAllRows()
        }

        let value = sender.stringValue
        let inlineTags = vc.sidebarOutlineView.getSelectedInlineTags()

        if (value.count > 0) {
            search.stringValue = String()
            editor.clear()
            var content = String()

            let selectedProject = sidebarOutlineView.getSidebarProjects()?.first ?? Storage.shared().getDefault()

            if UserDefaultsManagement.fileFormat == .Markdown, (
                UserDefaultsManagement.naming == .autoRename || UserDefaultsManagement.naming == .autoRenameNew
                ),
                UserDefaultsManagement.autoInsertHeader,
                UserDefaultsManagement.firstLineAsTitle || selectedProject?.settings.firstLineAsTitle == true {
                content.append("# \(value)\n\n")
            }

            if (inlineTags.count > 0) {
                content.append(inlineTags)
            }

            _ = createNote(name: value, content: content)
        } else {
            _ = createNote(content: inlineTags)
        }
    }
    
    @IBAction func fileMenuNewNote(_ sender: Any) {
        AppDelegate.mainWindowController?.window?.makeKeyAndOrderFront(nil)
        
        guard let vc = ViewController.shared() else { return }
        
        // Disable notes creation if folder encrypted
        if let project = vc.sidebarOutlineView.getSelectedProject(), project.isEncrypted, project.isLocked() {
            let menuItem = NSMenuItem()
            menuItem.identifier = NSUserInterfaceItemIdentifier("menu.newNote")
            vc.toggleFolderLock(menuItem)
            return
        }
        
        if let type = vc.getSidebarType(), type == .Trash {
            vc.sidebarOutlineView.deselectAllRows()
        }

        let inlineTags = vc.sidebarOutlineView.getSelectedInlineTags()

        _ = vc.createNote(content: inlineTags)
    }

    @IBAction func fileMenuNewRTF(_ sender: Any) {
        guard let vc = ViewController.shared() else { return }
        
        if let type = vc.getSidebarType(), type == .Trash {
            vc.sidebarOutlineView.deselectAllRows()
        }
        
        _ = vc.createNote(type: .RichText)