import SwiftUI
import AppKit

// MARK: - Terminal View

struct TerminalView: View {
    @ObservedObject var viewModel: EditorViewModel
    @FocusState private var inputFocused: Bool
    @State private var showSearch: Bool = false
    @State private var searchQuery: String = ""
    @State private var searchResultCount: Int = 0

    private var terminal: TerminalSession { viewModel.terminalSession }

    var body: some View {
        VStack(spacing: 0) {
            terminalHeader
            if showSearch {
                terminalSearchBar
            }
            Divider()
            TerminalOutputView(terminal: terminal, highlightQuery: showSearch ? searchQuery : nil)
            terminalInput
        }
        .background(Color(red: 0.05, green: 0.05, blue: 0.07))
        .onAppear {
            if !terminal.isRunning {
                if let dir = viewModel.workspaceService.currentWorkspace?.rootURL {
                    terminal.start(in: dir)
                } else {
                    terminal.start(in: FileManager.default.homeDirectoryForCurrentUser)
                }
            }
            inputFocused = true
        }
        .onChange(of: viewModel.workspaceService.currentWorkspace?.rootURL) { _, newURL in
            if let url = newURL, terminal.workingDirectory != url {
                terminal.sendInput("cd \(url.path.replacingOccurrences(of: " ", with: "\\ "))")
            }
        }
    }

    // MARK: - Header

    private var terminalHeader: some View {
        HStack(spacing: 6) {
            Image(systemName: "terminal")
                .font(.caption)
                .foregroundColor(.green)
            Text(terminal.title)
                .font(.system(size: 11, weight: .medium, design: .monospaced))
                .foregroundColor(.gray)
                .lineLimit(1)
            Spacer()

            // Process indicator
            if terminal.isRunning {
                Circle()
                    .fill(.green)
                    .frame(width: 6, height: 6)
            } else {
                Circle()
                    .fill(.red)
                    .frame(width: 6, height: 6)
            }

            Button(action: terminal.clear) {
                Image(systemName: "trash")
                    .font(.caption)
                    .foregroundColor(.gray)
            }
            .buttonStyle(.plain)
            .help("Clear output")

            Button(action: { showSearch.toggle() }) {
                Image(systemName: "magnifyingglass")
                    .font(.caption)
                    .foregroundColor(showSearch ? .accentColor : .gray)
            }
            .buttonStyle(.plain)
            .help("Search output (⌘F)")

            Button(action: {
                terminal.kill()
                if let dir = viewModel.workspaceService.currentWorkspace?.rootURL {
                    terminal.start(in: dir)
                } else {
                    terminal.start(in: FileManager.default.homeDirectoryForCurrentUser)
                }
            }) {
                Image(systemName: "arrow.counterclockwise")
                    .font(.caption)
                    .foregroundColor(.gray)
            }
            .buttonStyle(.plain)
            .help("Restart terminal")
        }
        .padding(.horizontal, 10)
        .padding(.vertical, 4)
    }

    // MARK: - Search Bar

    private var terminalSearchBar: some View {
        HStack(spacing: 6) {
            Image(systemName: "magnifyingglass")
                .font(.caption)
                .foregroundColor(.gray)

            TextField("Search output...", text: $searchQuery)
                .font(.system(size: 11, design: .monospaced))
                .textFieldStyle(.plain)
                .foregroundColor(.white)
                .onChange(of: searchQuery) { _, newValue in
                    searchResultCount = terminal.searchOutput(newValue).count
                }

            if !searchQuery.isEmpty {
                Text("\(searchResultCount) matches")
                    .font(.system(size: 10, design: .monospaced))
                    .foregroundColor(.gray)
            }

            Button(action: {
                searchQuery = ""
                showSearch = false
            }) {
                Image(systemName: "xmark.circle.fill")
                    .font(.caption)
                    .foregroundColor(.gray)
            }
            .buttonStyle(.plain)
        }
        .padding(.horizontal, 10)
        .padding(.vertical, 3)
        .background(Color(white: 0.12))
    }

    // MARK: - Input

    private var terminalInput: some View {
        HStack(spacing: 6) {
            Text(terminal.prompt)
                .font(.system(size: 12, design: .monospaced))
                .foregroundColor(.green.opacity(0.7))

            TerminalInputField(
                text: $viewModel.terminalSession.inputBuffer,
                onSubmit: {
                    let cmd = terminal.inputBuffer
                    terminal.sendInput(cmd)
                    terminal.inputBuffer = ""
                },
                onHistoryUp: { terminal.historyUp() },
                onHistoryDown: { terminal.historyDown() },
                onTab: { terminal.handleTab() },
                onInterrupt: { terminal.sendInterrupt() }
            )
            .focused($inputFocused)
        }
        .padding(.horizontal, 8)
        .padding(.vertical, 6)
        .background(Color(white: 0.08))
    }
}

// MARK: - Terminal Input Field (NSViewRepresentable for key handling)

struct TerminalInputField: NSViewRepresentable {
    @Binding var text: String
    let onSubmit: () -> Void
    let onHistoryUp: () -> Void
    let onHistoryDown: () -> Void
    let onTab: () -> Void
    let onInterrupt: () -> Void

    func makeNSView(context: Context) -> NSTextField {
        let field = NSTextField()
        field.font = NSFont.monospacedSystemFont(ofSize: 12, weight: .regular)
        field.textColor = .white
        field.backgroundColor = .clear
        field.isBordered = false
        field.focusRingType = .none
        field.delegate = context.coordinator
        field.placeholderString = ""
        field.cell?.sendsActionOnEndEditing = false
        return field
    }

    func updateNSView(_ nsView: NSTextField, context: Context) {
        if nsView.stringValue != text {
            nsView.stringValue = text
        }
    }

    func makeCoordinator() -> Coordinator {
        Coordinator(self)
    }

    class Coordinator: NSObject, NSTextFieldDelegate {
        var parent: TerminalInputField

        init(_ parent: TerminalInputField) {
            self.parent = parent
        }

        func controlTextDidChange(_ obj: Notification) {
            if let field = obj.object as? NSTextField {
                parent.text = field.stringValue
            }
        }

        func control(_ control: NSControl, textView: NSTextView, doCommandBy commandSelector: Selector) -> Bool {
            switch commandSelector {
            case #selector(NSResponder.insertNewline(_:)):
                parent.onSubmit()
                return true
            case #selector(NSResponder.moveUp(_:)):
                parent.onHistoryUp()
                return true
            case #selector(NSResponder.moveDown(_:)):
                parent.onHistoryDown()
                return true
            case #selector(NSResponder.insertTab(_:)):
                parent.onTab()
                return true
            case #selector(NSResponder.cancelOperation(_:)):
                parent.onInterrupt()
                return true
            default:
                return false
            }
        }
    }
}

// MARK: - Terminal Output View (NSViewRepresentable for performance)

struct TerminalOutputView: NSViewRepresentable {
    @ObservedObject var terminal: TerminalSession
    var highlightQuery: String? = nil

    func makeNSView(context: Context) -> NSScrollView {
        let scrollView = NSScrollView()
        scrollView.hasVerticalScroller = true
        scrollView.hasHorizontalScroller = false
        scrollView.autohidesScrollers = true
        scrollView.borderType = .noBorder
        scrollView.backgroundColor = NSColor(red: 0.05, green: 0.05, blue: 0.07, alpha: 1.0)

        let textView = NSTextView()
        textView.isEditable = false
        textView.isSelectable = true
        textView.isRichText = true
        textView.backgroundColor = NSColor(red: 0.05, green: 0.05, blue: 0.07, alpha: 1.0)
        textView.textContainerInset = NSSize(width: 8, height: 4)
        textView.font = NSFont.monospacedSystemFont(ofSize: 12, weight: .regular)
        textView.textColor = NSColor(calibratedRed: 0.85, green: 0.85, blue: 0.85, alpha: 1.0)
        textView.isAutomaticQuoteSubstitutionEnabled = false
        textView.isAutomaticDashSubstitutionEnabled = false
        textView.isAutomaticTextReplacementEnabled = false
        textView.allowsUndo = false

        let maxSize = NSSize(width: CGFloat.greatestFiniteMagnitude, height: CGFloat.greatestFiniteMagnitude)
        textView.maxSize = maxSize
        textView.isVerticallyResizable = true
        textView.isHorizontallyResizable = false
        textView.textContainer?.widthTracksTextView = true
        textView.textContainer?.containerSize = NSSize(width: scrollView.contentSize.width, height: CGFloat.greatestFiniteMagnitude)

        scrollView.documentView = textView
        context.coordinator.textView = textView
        context.coordinator.scrollView = scrollView
        return scrollView
    }

    func updateNSView(_ nsView: NSScrollView, context: Context) {
        context.coordinator.updateContent(terminal.lines)
    }

    func makeCoordinator() -> Coordinator {
        Coordinator()
    }

    class Coordinator {
        weak var textView: NSTextView?
        weak var scrollView: NSScrollView?
        private var lastLineCount = 0

        func updateContent(_ lines: [TerminalSession.TerminalLine]) {
            guard let textView = textView else { return }

            if lines.isEmpty {
                textView.string = ""
                lastLineCount = 0
                return
            }

            // Incremental append for performance
            if lines.count > lastLineCount {
                let newLines = lines[lastLineCount...]
                let storage = textView.textStorage!
                storage.beginEditing()
                for line in newLines {
                    let attrs = lineAttributes(for: line)
                    let str = NSAttributedString(string: (storage.length > 0 ? "\n" : "") + line.text, attributes: attrs)
                    storage.append(str)
                }
                storage.endEditing()
                lastLineCount = lines.count
            } else if lines.count < lastLineCount {
                // Cleared — rebuild
                let storage = textView.textStorage!
                storage.beginEditing()
                let fullText = NSMutableAttributedString()
                for (i, line) in lines.enumerated() {
                    let attrs = lineAttributes(for: line)
                    let prefix = i > 0 ? "\n" : ""
                    fullText.append(NSAttributedString(string: prefix + line.text, attributes: attrs))
                }
                storage.setAttributedString(fullText)
                storage.endEditing()
                lastLineCount = lines.count
            }

            // Auto-scroll to bottom
            DispatchQueue.main.async {
                textView.scrollToEndOfDocument(nil)
            }
        }

        private func lineAttributes(for line: TerminalSession.TerminalLine) -> [NSAttributedString.Key: Any] {
            let font = NSFont.monospacedSystemFont(ofSize: 12, weight: .regular)
            let color: NSColor
            switch line.kind {
            case .stdout:
                color = NSColor(calibratedRed: 0.85, green: 0.85, blue: 0.85, alpha: 1.0)
            case .stderr:
                color = NSColor(calibratedRed: 1.0, green: 0.45, blue: 0.4, alpha: 1.0)
            case .stdin:
                color = NSColor(calibratedRed: 0.4, green: 0.9, blue: 0.4, alpha: 1.0)
            case .system:
                color = NSColor(calibratedRed: 0.5, green: 0.6, blue: 0.8, alpha: 1.0)
            }
            return [.font: font, .foregroundColor: color]
        }
    }
}

// MARK: - Terminal Session (PTY-backed persistent bash process)

@MainActor
final class TerminalSession: ObservableObject {
    @Published var lines: [TerminalLine] = []
    @Published var inputBuffer: String = ""
    @Published var title: String = "bash"
    @Published var isRunning: Bool = false
    @Published var currentDirectory: String = ""

    let id = UUID()
    var prompt: String { isRunning ? "$ " : "[exited] $ " }

    private var process: Process?
    private var inputPipe: Pipe?
    private var outputPipe: Pipe?
    private var errorPipe: Pipe?
    var workingDirectory: URL?

    // Command history
    private(set) var commandHistory: [String] = []
    private(set) var historyIndex: Int = -1
    private var savedInput: String = ""
    let maxHistory = 500

    // Ring buffer for agent reads
    private(set) var recentOutput: [String] = []
    let maxRecentLines = 200

    // Shell aliases
    private(set) var aliases: [String: String] = [
        "ll": "ls -la",
        "la": "ls -A",
        "l": "ls -CF",
        "gs": "git status",
        "gd": "git diff",
        "gl": "git log --oneline -20",
        "gb": "git branch",
        "..": "cd ..",
        "...": "cd ../..",
    ]

    // Blocked commands (security)
    static let blockedPatterns: [String] = [
        "rm -rf /",
        "rm -rf /*",
        "mkfs",
        ":(){:|:&};:",  // fork bomb
        "dd if=/dev/",
        "chmod -R 777 /",
        "curl.*|.*bash",
        "wget.*|.*bash",
    ]

    enum LineKind: String, CaseIterable {
        case stdout, stderr, stdin, system
    }

    struct TerminalLine: Identifiable {
        let id = UUID()
        let text: String
        let kind: LineKind
        let timestamp: Date = Date()

        // Legacy compat
        var isError: Bool { kind == .stderr }
    }

    // MARK: - Lifecycle

    func start(in directory: URL) {
        kill()

        workingDirectory = directory
        currentDirectory = directory.path
        title = "bash — \(directory.lastPathComponent)"

        let proc = Process()
        proc.executableURL = URL(fileURLWithPath: "/bin/bash")
        proc.arguments = ["--login"]
        proc.currentDirectoryURL = directory

        var env = ProcessInfo.processInfo.environment
        env["TERM"] = "dumb"
        env["CLICOLOR"] = "0"
        env["NO_COLOR"] = "1"
        // Custom prompt that's recognizable and clean
        env["PS1"] = "\\W $ "
        env["PS2"] = "> "
        // Strip secrets
        for key in env.keys where key.lowercased().contains("api_key") || key.lowercased().contains("secret") || key.lowercased().contains("token") || key.lowercased().contains("password") {
            env.removeValue(forKey: key)
        }
        proc.environment = env

        let inPipe = Pipe()
        let outPipe = Pipe()
        let errPipe = Pipe()
        proc.standardInput = inPipe
        proc.standardOutput = outPipe
        proc.standardError = errPipe

        // Read stdout
        outPipe.fileHandleForReading.readabilityHandler = { [weak self] handle in
            let data = handle.availableData
            guard !data.isEmpty, let text = String(data: data, encoding: .utf8) else { return }
            let cleaned = Self.stripANSI(text)
            Task { @MainActor [weak self] in
                self?.handleOutput(cleaned, kind: .stdout)
            }
        }

        // Read stderr
        errPipe.fileHandleForReading.readabilityHandler = { [weak self] handle in
            let data = handle.availableData
            guard !data.isEmpty, let text = String(data: data, encoding: .utf8) else { return }
            let cleaned = Self.stripANSI(text)
            Task { @MainActor [weak self] in
                self?.handleOutput(cleaned, kind: .stderr)
            }
        }

        // Termination
        proc.terminationHandler = { [weak self] proc in
            Task { @MainActor [weak self] in
                self?.isRunning = false
                self?.title = "bash [exited: \(proc.terminationStatus)]"
                self?.appendLine("[Process exited with code \(proc.terminationStatus)]", kind: .system)
            }
        }

        do {
            try proc.run()
            process = proc
            inputPipe = inPipe
            outputPipe = outPipe
            errorPipe = errPipe
            isRunning = true
            appendLine("Terminal ready — \(directory.path)", kind: .system)
        } catch {
            appendLine("Failed to start: \(error.localizedDescription)", kind: .system)
        }
    }

    // MARK: - Input

    func sendInput(_ input: String) {
        guard !input.isEmpty else { return }

        // Check for blocked commands
        if Self.isBlocked(input) {
            appendLine("$ \(input)", kind: .stdin)
            appendLine("⛔ Blocked: this command is not allowed for safety reasons.", kind: .system)
            return
        }

        // Handle built-in commands
        if handleBuiltIn(input) { return }

        // Expand aliases
        let expanded = expandAlias(input)

        // Add to history (skip duplicates of last entry)
        if commandHistory.last != input {
            commandHistory.append(input)
            if commandHistory.count > maxHistory {
                commandHistory.removeFirst(commandHistory.count - maxHistory)
            }
        }
        historyIndex = -1
        savedInput = ""

        if isRunning, let pipe = inputPipe {
            appendLine("$ \(input)", kind: .stdin)
            let data = (expanded + "\n").data(using: .utf8)!
            pipe.fileHandleForWriting.write(data)
        } else {
            // No running process — execute one-shot
            appendLine("$ \(input)", kind: .stdin)
            Task { await executeOneShot(expanded) }
        }
    }

    /// Check if a command is blocked for security
    nonisolated static func isBlocked(_ command: String) -> Bool {
        let trimmed = command.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
        for pattern in blockedPatterns {
            if trimmed.contains(pattern.lowercased()) { return true }
        }
        // Block sudo rm -rf with broad path
        if trimmed.hasPrefix("sudo") && trimmed.contains("rm") && trimmed.contains("-rf") {
            return true
        }
        return false
    }

    /// Expand aliases in the command
    func expandAlias(_ input: String) -> String {
        let parts = input.split(separator: " ", maxSplits: 1, omittingEmptySubsequences: false)
        guard let firstWord = parts.first else { return input }
        let key = String(firstWord)
        if let expanded = aliases[key] {
            if parts.count > 1 {
                return expanded + " " + String(parts[1])
            }
            return expanded
        }
        return input
    }

    /// Handle built-in terminal commands (return true if handled)
    func handleBuiltIn(_ input: String) -> Bool {
        let trimmed = input.trimmingCharacters(in: .whitespaces)
        let parts = trimmed.split(separator: " ", maxSplits: 1, omittingEmptySubsequences: true)
        guard let cmd = parts.first else { return false }

        switch String(cmd) {
        case "clear":
            clear()
            return true
        case "history":
            appendLine("$ history", kind: .stdin)
            for (i, entry) in commandHistory.enumerated() {
                appendLine("  \(i + 1)  \(entry)", kind: .stdout)
            }
            return true
        case "alias":
            if parts.count == 1 {
                // List all aliases
                appendLine("$ alias", kind: .stdin)
                for (key, val) in aliases.sorted(by: { $0.key < $1.key }) {
                    appendLine("alias \(key)='\(val)'", kind: .stdout)
                }
                return true
            } else {
                // Set alias: alias name='command'
                let rest = String(parts[1])
                if let eqIdx = rest.firstIndex(of: "=") {
                    let name = String(rest[rest.startIndex..<eqIdx]).trimmingCharacters(in: .whitespaces)
                    var value = String(rest[rest.index(after: eqIdx)...]).trimmingCharacters(in: .whitespaces)
                    // Strip surrounding quotes
                    if (value.hasPrefix("'") && value.hasSuffix("'")) ||
                       (value.hasPrefix("\"") && value.hasSuffix("\"")) {
                        value = String(value.dropFirst().dropLast())
                    }
                    if !name.isEmpty && !value.isEmpty {
                        aliases[name] = value
                        appendLine("$ alias \(name)='\(value)'", kind: .stdin)
                        return true
                    }
                }
                return false
            }
        case "unalias":
            if let name = parts.dropFirst().first {
                let key = String(name)
                aliases.removeValue(forKey: key)
                appendLine("$ unalias \(key)", kind: .stdin)
                return true
            }
            return false
        case "export":
            // Show environment info
            appendLine("$ export", kind: .stdin)
            appendLine("CWD: \(currentDirectory)", kind: .stdout)
            appendLine("SHELL: /bin/bash", kind: .stdout)
            appendLine("TERM: dumb", kind: .stdout)
            return true
        default:
            return false
        }
    }

    func sendInterrupt() {
        guard let proc = process, proc.isRunning else { return }
        proc.interrupt() // sends SIGINT
        appendLine("^C", kind: .system)
    }

    // MARK: - History Navigation

    func historyUp() {
        guard !commandHistory.isEmpty else { return }
        if historyIndex == -1 {
            savedInput = inputBuffer
            historyIndex = commandHistory.count - 1
        } else if historyIndex > 0 {
            historyIndex -= 1
        }
        inputBuffer = commandHistory[historyIndex]
    }

    func historyDown() {
        guard historyIndex >= 0 else { return }
        if historyIndex < commandHistory.count - 1 {
            historyIndex += 1
            inputBuffer = commandHistory[historyIndex]
        } else {
            historyIndex = -1
            inputBuffer = savedInput
        }
    }

    // MARK: - Tab Completion

    func handleTab() {
        guard !inputBuffer.isEmpty else { return }
        let partial = inputBuffer

        // Find the last path component to complete
        let parts = partial.split(separator: " ", omittingEmptySubsequences: false)
        guard let lastPart = parts.last, !lastPart.isEmpty else { return }

        let pathStr = String(lastPart)
        let baseDir: String
        let prefix: String

        if pathStr.contains("/") {
            let url = URL(fileURLWithPath: pathStr, relativeTo: workingDirectory)
            baseDir = url.deletingLastPathComponent().path
            prefix = url.lastPathComponent
        } else {
            baseDir = workingDirectory?.path ?? FileManager.default.currentDirectoryPath
            prefix = pathStr
        }

        let fm = FileManager.default
        guard let contents = try? fm.contentsOfDirectory(atPath: baseDir) else { return }
        let matches = contents.filter { $0.hasPrefix(prefix) }.sorted()

        if matches.count == 1 {
            var completion = matches[0]
            let fullPath = (baseDir as NSString).appendingPathComponent(completion)
            var isDir: ObjCBool = false
            if fm.fileExists(atPath: fullPath, isDirectory: &isDir), isDir.boolValue {
                completion += "/"
            }
            // Replace the last part
            var newParts = Array(parts.dropLast())
            if pathStr.contains("/") {
                let dirPart = (pathStr as NSString).deletingLastPathComponent
                newParts.append(Substring(dirPart + "/" + completion))
            } else {
                newParts.append(Substring(completion))
            }
            inputBuffer = newParts.joined(separator: " ")
        } else if matches.count > 1 {
            // Show options
            appendLine(matches.joined(separator: "  "), kind: .system)
            // Complete common prefix
            let common = Self.commonPrefix(matches)
            if common.count > prefix.count {
                var newParts = Array(parts.dropLast())
                if pathStr.contains("/") {
                    let dirPart = (pathStr as NSString).deletingLastPathComponent
                    newParts.append(Substring(dirPart + "/" + common))
                } else {
                    newParts.append(Substring(common))
                }
                inputBuffer = newParts.joined(separator: " ")
            }
        }
    }

    // MARK: - Agent API

    /// Execute a command and return the output (for agent tool calls)
    func executeAndCapture(_ command: String, timeout: Int = 30) async -> (output: String, exitCode: Int32, isError: Bool) {
        let cwd = workingDirectory ?? FileManager.default.homeDirectoryForCurrentUser
        return await withCheckedContinuation { continuation in
            DispatchQueue.global(qos: .userInitiated).async {
                let proc = Process()
                proc.executableURL = URL(fileURLWithPath: "/bin/bash")
                proc.arguments = ["-c", command]
                proc.currentDirectoryURL = cwd

                var env = ProcessInfo.processInfo.environment
                env["TERM"] = "dumb"
                for key in env.keys where key.lowercased().contains("api_key") || key.lowercased().contains("secret") || key.lowercased().contains("token") || key.lowercased().contains("password") {
                    env.removeValue(forKey: key)
                }
                proc.environment = env

                let outPipe = Pipe()
                let errPipe = Pipe()
                proc.standardOutput = outPipe
                proc.standardError = errPipe

                do {
                    try proc.run()

                    let deadline = DispatchTime.now() + .seconds(timeout)
                    let group = DispatchGroup()
                    group.enter()
                    DispatchQueue.global().async {
                        proc.waitUntilExit()
                        group.leave()
                    }

                    let result = group.wait(timeout: deadline)
                    if result == .timedOut {
                        proc.terminate()
                        continuation.resume(returning: ("Command timed out after \(timeout)s", -1, true))
                        return
                    }

                    let outData = outPipe.fileHandleForReading.readDataToEndOfFile()
                    let errData = errPipe.fileHandleForReading.readDataToEndOfFile()
                    let output = String(data: outData, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
                    let errOutput = String(data: errData, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
                    let exitCode = proc.terminationStatus

                    var combined = output
                    if !errOutput.isEmpty {
                        combined += combined.isEmpty ? errOutput : "\n\(errOutput)"
                    }

                    continuation.resume(returning: (combined, exitCode, exitCode != 0))
                } catch {
                    continuation.resume(returning: ("Error: \(error.localizedDescription)", -1, true))
                }
            }
        }
    }

    /// Get recent output lines (for agent to read terminal state)
    func getRecentOutput(lineCount: Int = 50) -> String {
        let count = min(lineCount, recentOutput.count)
        return recentOutput.suffix(count).joined(separator: "\n")
    }

    /// Append agent-executed command output to the terminal UI
    func appendAgentCommand(_ command: String, output: String) {
        appendLine("[agent] $ \(command)", kind: .system)
        if !output.isEmpty {
            for line in output.components(separatedBy: "\n") where !line.isEmpty {
                appendLine(line, kind: .stdout)
            }
        }
    }

    // MARK: - Clear/Kill

    func clear() {
        lines.removeAll()
        recentOutput.removeAll()
    }

    func kill() {
        outputPipe?.fileHandleForReading.readabilityHandler = nil
        errorPipe?.fileHandleForReading.readabilityHandler = nil
        if let proc = process, proc.isRunning {
            proc.terminate()
        }
        process = nil
        inputPipe = nil
        outputPipe = nil
        errorPipe = nil
        isRunning = false
    }

    func setCwd(_ path: String) {
        workingDirectory = URL(fileURLWithPath: path)
        currentDirectory = path
    }

    // MARK: - Search & Filtering

    /// Search terminal output for a pattern (case-insensitive)
    func searchOutput(_ query: String) -> [TerminalLine] {
        guard !query.isEmpty else { return [] }
        let lower = query.lowercased()
        return lines.filter { $0.text.lowercased().contains(lower) }
    }

    /// Get line counts by kind
    func lineCounts() -> [LineKind: Int] {
        var counts: [LineKind: Int] = [:]
        for kind in LineKind.allCases {
            counts[kind] = lines.filter { $0.kind == kind }.count
        }
        return counts
    }

    /// Total output size in characters
    var totalOutputSize: Int {
        lines.reduce(0) { $0 + $1.text.count }
    }

    // MARK: - Internal (exposed for testing)

    func handleOutput(_ text: String, kind: LineKind) {
        let outputLines = text.components(separatedBy: "\n")
        for line in outputLines where !line.isEmpty {
            // Skip prompt echo lines
            if line.hasSuffix(" $ ") && line.count < 60 { continue }
            appendLine(line, kind: kind)
            recentOutput.append(line)
            if recentOutput.count > maxRecentLines {
                recentOutput.removeFirst(recentOutput.count - maxRecentLines)
            }
        }
    }

    func appendLine(_ text: String, kind: LineKind) {
        lines.append(TerminalLine(text: text, kind: kind))
        if lines.count > 5000 {
            lines.removeFirst(lines.count - 5000)
        }
    }

    private func executeOneShot(_ command: String) async {
        let result = await executeAndCapture(command)
        if !result.output.isEmpty {
            for line in result.output.components(separatedBy: "\n") {
                appendLine(line, kind: result.isError ? .stderr : .stdout)
            }
        }
        if result.exitCode != 0 {
            appendLine("[exit code: \(result.exitCode)]", kind: .system)
        }
    }

    // MARK: - Static Helpers

    /// Strip ANSI escape sequences from terminal output
    nonisolated static func stripANSI(_ text: String) -> String {
        // Match ESC[ ... m (SGR), ESC[ ... H (cursor), ESC[ ... J (erase), etc.
        guard let regex = try? NSRegularExpression(pattern: "\\x1B(?:[@-Z\\\\-_]|\\[[0-?]*[ -/]*[@-~])", options: []) else {
            return text
        }
        return regex.stringByReplacingMatches(in: text, options: [], range: NSRange(text.startIndex..., in: text), withTemplate: "")
    }

    /// Find the common prefix of an array of strings
    nonisolated static func commonPrefix(_ strings: [String]) -> String {
        guard let first = strings.first else { return "" }
        var prefix = first
        for s in strings.dropFirst() {
            while !s.hasPrefix(prefix) {
                prefix = String(prefix.dropLast())
                if prefix.isEmpty { return "" }
            }
        }
        return prefix
    }
}

// MARK: - Split Editor View

struct SplitEditorView: View {
    @ObservedObject var viewModel: EditorViewModel
    let orientation: SplitOrientation

    var body: some View {
        Group {
            if orientation == .horizontal {
                HSplitView {
                    CodeEditorView(viewModel: viewModel)
                    if viewModel.splitEditorEnabled, let splitVM = viewModel.splitViewModel {
                        Divider()
                        CodeEditorView(viewModel: splitVM)
                    }
                }
            } else {
                VSplitView {
                    CodeEditorView(viewModel: viewModel)
                    if viewModel.splitEditorEnabled, let splitVM = viewModel.splitViewModel {
                        Divider()
                        CodeEditorView(viewModel: splitVM)
                    }
                }
            }
        }
    }
}