import AppKit
import SwiftUI
import TermindApplication
import UniformTypeIdentifiers

/// The native source list for Vault and Workspaces.
/// Workspace layout drops are accepted only inside the Workspace section.
struct WorkspaceNavigatorView: View {
    @Environment(AppModel.self) private var app
    @Environment(WindowModel.self) private var window
    @Environment(\.locale) private var locale

    @AppStorage(DesktopSettingsKey.vaultSectionExpanded) private var vaultExpanded = true
    @AppStorage(DesktopSettingsKey.workspaceSectionExpanded) private var workspaceExpanded = true

    @State private var workspaceDropTarget: WorkspaceSidebarDropTarget?
    @State private var workspaceFrames: [Workspace.ID: CGRect] = [:]
    @State private var workspaceHeaderFrame = CGRect.zero
    @State private var batchStartupFrame = CGRect.zero

    @State private var renamingWorkspaceID: Workspace.ID?
    @State private var workspaceRenameTitle = ""

    nonisolated private static let coordinateSpace = "termind.workspaceNavigator"

    var body: some View {
        VStack(spacing: 0) {
            List {
                // Applied once here rather than on each row: the rows are shared
                // with the ListViewKit-backed modes, which have no list of their
                // own to inset, and the one rendered edge everything lines up on is
                // `Metrics.Sidebar.rowHorizontalMargin` inside the row itself.
                Group {
                    welcomeRow
                    SidebarNavigatorRow(
                        title: "Metrics", symbol: "waveform.path.ecg",
                        isSelected: window.selectedDestination == .metrics
                    ) {
                        window.dragging = nil
                        window.selectedDestination = .metrics
                    }
                    vaultSection
                    workspaceSection
                    settingsSection
                }
                .listRowInsets(EdgeInsets())
                .listRowBackground(Color.clear)
                .listRowSeparator(.hidden)
            }
            .listStyle(.plain)
            .contentMargins(.horizontal, 0, for: .scrollContent)
            .scrollContentBackground(.hidden)
            .environment(\.defaultMinListRowHeight, 0)
            .coordinateSpace(.named(Self.coordinateSpace))
            .overlay { workspaceLayoutDropTarget }

        }
        // `List` is backed by AppKit. A destination attached to the SwiftUI
        // ancestor sits behind its native rows and only wins sporadically as a
        // pane crosses from Ghostty into the sidebar. Put one receiver above the
        // complete Workspace section while an internal layout drag is active.
        .onChange(of: window.selectedDestination) {
            switch window.selectedDestination {
            case .vault: vaultExpanded = true
            case .assistant, .settings, .metrics: break
            case .workspace: workspaceExpanded = true
            }
        }
        .onChange(of: window.vaultDestination) { vaultExpanded = true }
        .onChange(of: window.dragging) {
            if window.dragging?.isLayoutPayload != true { workspaceDropTarget = nil }
        }
    }

    private var settingsSection: some View {
        Group {
            Text("Settings")
                .frame(maxWidth: .infinity, alignment: .leading)
                .frame(height: 32)
                .padding(
                    .horizontal,
                    Metrics.Sidebar.navigationRowInset + Metrics.Sidebar.rowHorizontalMargin
                )
                .termindSidebarSectionLabel()

            SidebarNavigatorRow(
                title: "Settings",
                symbol: "gearshape",
                isSelected: window.selectedDestination == .settings
            ) {
                window.dragging = nil
                window.openSettings()
            }
        }
    }

    // MARK: - Vault

    private var welcomeRow: some View {
        navigatorRow(
            title: VaultPage.welcome.label,
            symbol: VaultPage.welcome.symbol,
            count: 0,
            isSelected: window.selectedDestination == .vault
                && window.vaultDestination.page == .welcome
        ) {
            window.dragging = nil
            window.openPage(.welcome)
        }
    }

    private var vaultSection: some View {
        Group {
            navigatorSectionHeader("Vault", isExpanded: $vaultExpanded)

            if vaultExpanded {
                ForEach(VaultPage.allCases.filter { $0 != .welcome }) { page in
                    SidebarNavigatorRow(
                        title: page.label,
                        symbol: page.symbol,
                        count: count(for: page),
                        isSelected: window.selectedDestination == .vault
                            && window.vaultDestination.page == page,
                        // The page's own New verbs, so adding a host does not
                        // require visiting Hosts first.
                        menu: { window.creationMenu(for: page, locale: locale) }
                    ) {
                        window.dragging = nil
                        vaultExpanded = true
                        window.openPage(page)
                    }
                }
            }
        }
    }

    private func count(for page: VaultPage) -> Int {
        switch page {
        case .welcome: 0
        case .hosts: app.hostLibrary.hosts.count
        case .keychain: app.hostLibrary.keys.count + app.hostLibrary.identities.count
        case .snippets: app.hostLibrary.snippets.count
        case .knownHosts: app.knownHosts.entries.count
        }
    }

    // MARK: - Workspaces

    private var workspaceSection: some View {
        Group {
            navigatorSectionHeader("Workspaces", isExpanded: $workspaceExpanded)
                .onGeometryChange(for: CGRect.self) {
                    $0.frame(in: .named(Self.coordinateSpace))
                } action: {
                    workspaceHeaderFrame = $0
                }

            if workspaceExpanded {
                if window.workspaces.isEmpty {
                    emptyRow("No Workspaces")
                }
                ForEach(Array(window.workspaces.enumerated()), id: \.element.id) { index, workspace in
                    WorkspaceNavigatorRow(
                        workspace: workspace,
                        isSelected: window.displayedWorkspace?.id == workspace.id,
                        isRenaming: renamingWorkspaceID == workspace.id,
                        renameTitle: $workspaceRenameTitle,
                        onBeginRename: { beginWorkspaceRename(workspace) },
                        onCommitRename: { commitWorkspaceRename(workspace) },
                        onCancelRename: cancelWorkspaceRename
                    )
                    .onGeometryChange(for: CGRect.self) {
                        $0.frame(in: .named(Self.coordinateSpace))
                    } action: {
                        workspaceFrames[workspace.id] = $0
                    }
                    .overlay(alignment: .top) {
                        if workspaceDropTarget?.visibleBoundaryIndex == index {
                            workspaceInsertionLine
                        }
                    }
                    .overlay(alignment: .bottom) {
                        if index == window.workspaces.indices.last,
                            workspaceDropTarget?.visibleBoundaryIndex == window.workspaces.count
                        {
                            workspaceInsertionLine
                        }
                    }
                }

                // The same container as the destinations above it. Drawn by
                // hand it sat 8pt further left than every other row and never
                // lit up under the pointer.
                SidebarNavigatorRow(title: "Batch Startup", symbol: "wind") {
                    workspaceExpanded = true
                    app.batchStartup(in: window)
                }
                .overlay(alignment: .top) {
                    if window.workspaces.isEmpty, workspaceDropTarget != nil {
                        workspaceInsertionLine
                    }
                }
                .onGeometryChange(for: CGRect.self) {
                    $0.frame(in: .named(Self.coordinateSpace))
                } action: {
                    batchStartupFrame = $0
                }
            }
        }
    }

    private var draggedWorkspaceID: Workspace.ID? {
        guard case .workspace(let id)? = window.dragging else { return nil }
        return id
    }

    private var workspaceDropBounds: CGRect {
        guard workspaceExpanded else { return workspaceHeaderFrame }
        let frames =
            [workspaceHeaderFrame, batchStartupFrame]
            + window.workspaces.compactMap { workspaceFrames[$0.id] }
        return frames.filter { !$0.isEmpty }.reduce(.null) { $0.union($1) }
    }

    @ViewBuilder
    private var workspaceLayoutDropTarget: some View {
        if window.dragging?.isLayoutPayload == true,
            !workspaceDropBounds.isNull, !workspaceDropBounds.isEmpty
        {
            GeometryReader { proxy in
                WorkspaceNavigatorDropReceiver(
                    onLocation: { point in
                        guard window.dragging?.isLayoutPayload == true else {
                            workspaceDropTarget = nil
                            return false
                        }
                        workspaceExpanded = true
                        workspaceDropTarget = dropTarget(at: point)
                        return workspaceDropTarget != nil
                    },
                    onExit: { workspaceDropTarget = nil },
                    onDrop: { point in
                        guard window.dragging?.isLayoutPayload == true,
                            let target = dropTarget(at: point)
                        else {
                            workspaceDropTarget = nil
                            return false
                        }
                        workspaceDropTarget = nil
                        switch window.dragging {
                        case .pane(let id): window.detachPane(id, at: target.insertionIndex)
                        case .workspace(let id): window.move(id, to: target.insertionIndex)
                        case .assistantConversation, nil: return false
                        }
                        window.dragging = nil
                        return true
                    }
                )
                .frame(width: proxy.size.width, height: proxy.size.height)
            }
            .allowsHitTesting(true)
        }
    }

    private func dropTarget(at location: CGPoint) -> WorkspaceSidebarDropTarget? {
        let visibleRows = window.workspaces.compactMap { workspace -> (Workspace.ID, CGRect)? in
            guard let frame = workspaceFrames[workspace.id] else { return nil }
            return (workspace.id, frame)
        }
        let draggedRowIndex = draggedWorkspaceID.flatMap { draggedID in
            visibleRows.firstIndex(where: { $0.0 == draggedID })
        }
        return WorkspaceSidebarDropGeometry.target(
            rowFrames: visibleRows.map(\.1),
            draggedRowIndex: draggedRowIndex,
            pointerY: location.y
        )
    }

    private var workspaceInsertionLine: some View {
        Rectangle()
            .fill(Color.accentColor)
            .frame(height: 2)
            .padding(.horizontal, 8)
            .allowsHitTesting(false)
    }

    // MARK: - Shared rows and editing

    private func navigatorRow(
        title: LocalizedStringKey,
        symbol: String,
        count: Int,
        isSelected: Bool,
        action: @escaping () -> Void
    ) -> some View {
        SidebarNavigatorRow(
            title: title, symbol: symbol, count: count,
            isSelected: isSelected, action: action
        )
    }

    private func navigatorSectionHeader(
        _ title: LocalizedStringKey,
        isExpanded: Binding<Bool>
    ) -> some View {
        SidebarSectionHeader(title: title, isExpanded: isExpanded)
    }

    private func emptyRow(_ title: LocalizedStringKey) -> some View {
        Text(title)
            .font(.callout)
            .foregroundStyle(.tertiary)
            .frame(maxWidth: .infinity, alignment: .leading)
            .frame(height: Metrics.Sidebar.navigationRowHeight)
            .padding(.horizontal, Metrics.Sidebar.navigationRowInset)
            // The same breathing edge the rows around it carry, so "No
            // Workspaces" starts where a workspace name would.
            .padding(.horizontal, Metrics.Sidebar.rowHorizontalMargin)
    }

    private func beginWorkspaceRename(_ workspace: Workspace) {
        guard workspace.isRenameable else { return }
        renamingWorkspaceID = workspace.id
        workspaceRenameTitle = workspace.title(in: app.hostLibrary, locale: locale)
    }

    private func commitWorkspaceRename(_ workspace: Workspace) {
        guard renamingWorkspaceID == workspace.id else { return }
        let title = workspaceRenameTitle
        cancelWorkspaceRename()
        window.rename(workspace.id, to: title)
    }

    private func cancelWorkspaceRename() {
        renamingWorkspaceID = nil
        workspaceRenameTitle = ""
    }

}

nonisolated struct WorkspaceSidebarDropTarget: Equatable, Sendable {
    let insertionIndex: Int
    let visibleBoundaryIndex: Int
}

nonisolated enum WorkspaceSidebarDropGeometry {
    static func target(
        rowFrames: [CGRect],
        draggedRowIndex: Int?,
        pointerY: CGFloat
    ) -> WorkspaceSidebarDropTarget {
        let visibleBoundaryIndex = insertionIndex(rowFrames: rowFrames, pointerY: pointerY)
        let insertionFrames = rowFrames.enumerated().compactMap { index, frame in
            index == draggedRowIndex ? nil : frame
        }
        return WorkspaceSidebarDropTarget(
            insertionIndex: insertionIndex(rowFrames: insertionFrames, pointerY: pointerY),
            visibleBoundaryIndex: visibleBoundaryIndex
        )
    }

    static func insertionIndex(rowFrames: [CGRect], pointerY: CGFloat) -> Int {
        rowFrames.reduce(into: 0) { index, frame in
            if frame.midY < pointerY { index += 1 }
        }
    }
}

private struct WorkspaceNavigatorRow: View {
    let workspace: Workspace
    let isSelected: Bool
    let isRenaming: Bool
    @Binding var renameTitle: String
    let onBeginRename: () -> Void
    let onCommitRename: () -> Void
    let onCancelRename: () -> Void

    @Environment(AppModel.self) private var app
    @Environment(WindowModel.self) private var window
    @Environment(\.controlActiveState) private var controlActiveState
    @Environment(\.locale) private var locale
    @State private var hovering = false

    @ViewBuilder
    var body: some View {
        if isRenaming {
            row
        } else {
            row.onDrag {
                window.dragging = .workspace(workspace.id)
                return NSItemProvider(object: workspace.id.uuidString as NSString)
            }
        }
    }

    private var row: some View {
        HStack(spacing: Metrics.Space.s) {
            Image(systemName: workspace.symbol)
                .foregroundStyle(
                    SidebarSelectionStyle.foreground(
                        isSelected: isSelected,
                        controlActiveState: controlActiveState,
                        unselected: AnyShapeStyle(.secondary)
                    )
                )
                .frame(width: Metrics.Sidebar.rowIcon)

            if isRenaming {
                SidebarInlineRenameField(
                    text: $renameTitle,
                    prompt: String(localized: "Workspace Name"),
                    isSelected: isSelected,
                    controlActiveState: controlActiveState,
                    onSubmit: onCommitRename,
                    onCancel: onCancelRename
                )
                .frame(height: 18)
            } else {
                VStack(alignment: .leading, spacing: 1) {
                    Text(workspace.title(in: app.hostLibrary, locale: locale))
                        .fontWeight(isSelected ? .semibold : .regular)
                        .lineLimit(1)
                    if let subtitle = workspace.subtitle(in: app.hostLibrary) {
                        Text(subtitle)
                            .font(.caption2)
                            .foregroundStyle(.secondary)
                            .lineLimit(1)
                            .truncationMode(.head)
                    }
                }
            }

            Spacer(minLength: 0)
            trailingControl
        }
        .padding(.horizontal, Metrics.Sidebar.navigationRowInset)
        .frame(maxWidth: .infinity, alignment: .leading)
        .frame(height: Metrics.Sidebar.workspaceRowHeight)
        .contentShape(.rect)
        .termindSidebarRow(isSelected: isSelected) { contextMenu }
        .onTapGesture {
            window.dragging = nil
            window.select(workspace.id)
        }
        .simultaneousGesture(TapGesture(count: 2).onEnded(onBeginRename))
        .onHover { hovering = $0 }
        // Match Assistant's inline rename treatment: the row itself must not
        // draw a second keyboard-focus rectangle around the plain field.
        .focusable(false)
        .focusEffectDisabled()
        .help(Text(workspace.title(in: app.hostLibrary, locale: locale)))
        .accessibilityElement(children: .combine)
        .accessibilityLabel(
            Text(workspace.title(in: app.hostLibrary, locale: locale))
        )
        .accessibilityAddTraits(isSelected ? [.isSelected, .isButton] : .isButton)
    }

    @ViewBuilder
    private var trailingControl: some View {
        if hovering, !isRenaming {
            Button {
                if NSEvent.modifierFlags.contains(.option) {
                    window.closeOthers(than: workspace.id)
                } else {
                    window.close(workspace.id)
                }
            } label: {
                Image(systemName: "xmark")
                    .font(.system(size: 8, weight: .bold))
                    .frame(width: 14, height: 14)
            }
            .buttonStyle(.plain)
            .help(Text("Close Workspace — ⌥-click to close the others"))
        } else if workspace.status != .disconnected || workspace.hasUnreadOutput {
            StatusDot(status: workspace.status, hasUnread: workspace.hasUnreadOutput, size: 6)
                .frame(width: 14)
        } else {
            Color.clear.frame(width: 14, height: 14)
        }
    }

    private var contextMenu: [NativeMenuEntry] {
        var entries: [NativeMenuEntry] = []
        if workspace.isRenameable {
            entries.append(
                NativeMenuEntry(
                    title: localized("Rename"),
                    symbol: MenuSymbol.rename,
                    action: onBeginRename
                )
            )
            if namedTitle != nil {
                entries.append(
                    NativeMenuEntry(
                        title: localized("Reset Name"), symbol: MenuSymbol.resetName
                    ) {
                        window.rename(workspace.id, to: "")
                    }
                )
            }
            entries.append(.separator)
        }
        // Only a merged Workspace can be taken apart, and taking it apart is
        // the only way back — the last pane cannot be dragged out to the
        // Navigator, because a pane alone in its Workspace has nothing to
        // detach from.
        if workspace.isSplit {
            entries.append(
                NativeMenuEntry(
                    title: localized("Separate Panes"), symbol: MenuSymbol.separatePanes
                ) {
                    window.separatePanes(in: workspace.id)
                }
            )
            entries.append(.separator)
        }
        if workspace.isCombinable {
            if workspace.isSplit {
                entries.append(
                    NativeMenuEntry(
                        title: localized("Duplicate in New Workspace"),
                        symbol: MenuSymbol.duplicate
                    ) {
                        act { window.duplicateSelectedInNewWorkspace() }
                    }
                )
            } else {
                entries.append(
                    NativeMenuEntry(
                        title: localized("Duplicate"),
                        symbol: MenuSymbol.duplicate,
                        children: [
                            NativeMenuEntry(
                                title: localized("in Current Workspace"),
                                symbol: MenuSymbol.currentWorkspace
                            ) {
                                act { window.duplicateSelected(axis: .horizontal) }
                            },
                            NativeMenuEntry(
                                title: localized("in New Workspace"),
                                symbol: MenuSymbol.newWorkspace
                            ) {
                                act { window.duplicateSelectedInNewWorkspace() }
                            },
                        ]
                    )
                )
            }
            entries.append(.separator)
            entries.append(
                NativeMenuEntry(title: localized("Split Right"), symbol: MenuSymbol.splitRight) {
                    act { window.splitSelected(axis: .horizontal) }
                }
            )
            entries.append(
                NativeMenuEntry(title: localized("Split Down"), symbol: MenuSymbol.splitDown) {
                    act { window.splitSelected(axis: .vertical) }
                }
            )
            entries.append(.separator)
        }
        // Close Other and Close All are the same verb as the item above them,
        // so only the first of the run carries a glyph.
        entries.append(
            NativeMenuEntry(
                title: localized("Close Workspace"), symbol: MenuSymbol.closeWorkspace
            ) {
                window.close(workspace.id)
            }
        )
        entries.append(
            NativeMenuEntry(title: localized("Close Other Workspaces")) {
                window.closeOthers(than: workspace.id)
            }
        )
        entries.append(
            NativeMenuEntry(title: localized("Close All Workspaces")) {
                window.closeAll()
            }
        )
        return entries
    }

    private var namedTitle: String? {
        workspace.isSplit ? workspace.customTitle : workspace.focusedPane.customTitle
    }

    private func localized(_ key: String.LocalizationValue) -> String {
        AppLocalization.string(key, locale: locale)
    }

    private func act(_ action: () -> Void) {
        window.select(workspace.id)
        action()
    }
}

private struct WorkspaceNavigatorDropReceiver: NSViewRepresentable {
    let onLocation: (CGPoint) -> Bool
    let onExit: () -> Void
    let onDrop: (CGPoint) -> Bool

    func makeNSView(context _: Context) -> WorkspaceNavigatorDropReceivingView {
        WorkspaceNavigatorDropReceivingView()
    }

    func updateNSView(_ view: WorkspaceNavigatorDropReceivingView, context _: Context) {
        view.onLocation = onLocation
        view.onExit = onExit
        view.onDrop = onDrop
    }
}

@MainActor
private final class WorkspaceNavigatorDropReceivingView: NSView {
    var onLocation: (CGPoint) -> Bool = { _ in false }
    var onExit: () -> Void = {}
    var onDrop: (CGPoint) -> Bool = { _ in false }

    override var isFlipped: Bool { true }

    override init(frame frameRect: NSRect) {
        super.init(frame: frameRect)
        registerForDraggedTypes([.string])
    }

    @available(*, unavailable)
    required init?(coder _: NSCoder) { fatalError() }

    override func draggingEntered(_ sender: any NSDraggingInfo) -> NSDragOperation {
        update(sender) ? .move : []
    }

    override func draggingUpdated(_ sender: any NSDraggingInfo) -> NSDragOperation {
        update(sender) ? .move : []
    }

    override func draggingExited(_: (any NSDraggingInfo)?) {
        onExit()
    }

    override func performDragOperation(_ sender: any NSDraggingInfo) -> Bool {
        let accepted = onDrop(location(of: sender))
        onExit()
        return accepted
    }

    override func concludeDragOperation(_ sender: (any NSDraggingInfo)?) {
        onExit()
        super.concludeDragOperation(sender)
    }

    private func update(_ sender: any NSDraggingInfo) -> Bool {
        guard sender.draggingPasteboard.availableType(from: [.string]) != nil else {
            onExit()
            return false
        }
        return onLocation(location(of: sender))
    }

    private func location(of sender: any NSDraggingInfo) -> CGPoint {
        convert(sender.draggingLocation, from: nil)
    }

}