import AppKit
import Foundation
import OSLog
import WebKit

private let webChatLogger = Logger(subsystem: "com.steipete.clawdis", category: "WebChat")

final class WebChatWindowController: NSWindowController, WKScriptMessageHandler, WKNavigationDelegate {
    private let webView: WKWebView
    private let sessionKey: String
    private let initialMessagesJSON: String

    init(sessionKey: String) {
        webChatLogger.debug("init WebChatWindowController sessionKey=\(sessionKey, privacy: .public)")
        self.sessionKey = sessionKey
        self.initialMessagesJSON = WebChatWindowController.loadInitialMessagesJSON(for: sessionKey)

        let config = WKWebViewConfiguration()
        let contentController = WKUserContentController()
        config.userContentController = contentController
        config.preferences.isElementFullscreenEnabled = true
        config.preferences.setValue(true, forKey: "developerExtrasEnabled")

        // Inject callback receiver stub
        let callbackScript = """
        window.__clawdisCallbacks = new Map();
        window.__clawdisReceive = function(resp) {
          const entry = window.__clawdisCallbacks.get(resp.id);
          if (!entry) return;
          window.__clawdisCallbacks.delete(resp.id);
          if (resp.ok) {
            entry.resolve(resp.result);
          } else {
            entry.reject(resp.error || 'unknown error');
          }
        };
        window.__clawdisSend = function(payload) {
          const id = crypto.randomUUID();
          return new Promise((resolve, reject) => {
            window.__clawdisCallbacks.set(id, { resolve, reject });
            window.webkit?.messageHandlers?.clawdis?.postMessage({ id, ...payload });
          });
        };
        window.__clawdisLog = function(msg) {
          try {
            window.webkit?.messageHandlers?.clawdis?.postMessage({ id: 'log', log: String(msg) });
          } catch (_) {}
        };
        const __origConsoleLog = console.log;
        console.log = function(...args) {
          try { window.__clawdisLog(args.join(' ')); } catch (_) {}
          __origConsoleLog.apply(console, args);
        };
        window.addEventListener('error', (e) => {
          try {
            window.__clawdisLog(`page error: ${e.message} @ ${e.filename}:${e.lineno}:${e.colno}`);
          } catch (_) {}
        });
        window.addEventListener('unhandledrejection', (e) => {
          try {
            window.__clawdisLog(`unhandled rejection: ${e.reason}`);
          } catch (_) {}
        });
        """
        let userScript = WKUserScript(source: callbackScript, injectionTime: .atDocumentStart, forMainFrameOnly: true)
        contentController.addUserScript(userScript)

        self.webView = WKWebView(frame: .zero, configuration: config)
        let window = NSWindow(
            contentRect: NSRect(x: 0, y: 0, width: 960, height: 720),
            styleMask: [.titled, .closable, .resizable, .miniaturizable],
            backing: .buffered,
            defer: false)
        window.title = "Clawd Web Chat"
        window.contentView = self.webView
        super.init(window: window)
        self.webView.navigationDelegate = self
        contentController.add(self, name: "clawdis")
        self.loadPage()
    }

    @available(*, unavailable)
    required init?(coder: NSCoder) { fatalError("init(coder:) is not supported") }

    private func loadPage() {
        webChatLogger.debug("loadPage begin")
        guard let webChatURL = Bundle.main.url(forResource: "WebChat", withExtension: nil),
              let htmlURL = URL(string: "index.html")
        else {
            NSLog("WebChat resources missing")
            webChatLogger.error("WebChat resources missing in bundle")
            return
        }

        let bootstrapScript = """
        window.__clawdisBootstrap = {
          sessionKey: "\(self.sessionKey)",
          initialMessages: \(self.initialMessagesJSON)
        };
        """
        let userScript = WKUserScript(
            source: bootstrapScript,
            injectionTime: .atDocumentStart,
            forMainFrameOnly: true)
        self.webView.configuration.userContentController.addUserScript(userScript)

        WebChatServer.shared.start(root: webChatURL)
        guard let baseURL = self.waitForWebChatServer() else {
            webChatLogger.error("WebChatServer not ready; cannot load web chat")
            return
        }
        let url = baseURL.appendingPathComponent(htmlURL.relativePath)
        self.webView.load(URLRequest(url: url))
        webChatLogger.debug("loadPage queued HTML into WKWebView url=\(url.absoluteString, privacy: .public)")
    }

    private func waitForWebChatServer(timeout: TimeInterval = 2.0) -> URL? {
        let deadline = Date().addingTimeInterval(timeout)
        var base: URL?
        while Date() < deadline {
            if let url = WebChatServer.shared.baseURL() {
                base = url
                break
            }
            RunLoop.current.run(mode: .default, before: Date().addingTimeInterval(0.05))
        }
        if base == nil {
            webChatLogger.error("WebChatServer failed to become ready within \(timeout, privacy: .public)s")
        }
        return base
    }

    func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
        webChatLogger.debug("didFinish navigation url=\(webView.url?.absoluteString ?? "nil", privacy: .public)")
        webView.evaluateJavaScript("document.body.innerText") { result, error in
            if let error {
                webChatLogger.error("eval error: \(error.localizedDescription, privacy: .public)")
            } else if let text = result as? String {
                webChatLogger.debug("body text snapshot: \(String(text.prefix(200)), privacy: .public)")
            }
        }
        webView.evaluateJavaScript("document.readyState") { result, _ in
            if let state = result as? String {
                webChatLogger.debug("readyState=\(state, privacy: .public)")
            }
        }
        webView.evaluateJavaScript("window.location.href") { result, _ in
            if let href = result as? String {
                webChatLogger.debug("js location=\(href, privacy: .public)")
            }
        }
    }

    func webView(_ webView: WKWebView, didStartProvisionalNavigation navigation: WKNavigation!) {
        webChatLogger.debug("didStartProvisional url=\(webView.url?.absoluteString ?? "nil", privacy: .public)")
    }

    func webView(_ webView: WKWebView, didCommit navigation: WKNavigation!) {
        webChatLogger.debug("didCommit url=\(webView.url?.absoluteString ?? "nil", privacy: .public)")
    }

    func webView(
        _ webView: WKWebView,
        didFailProvisionalNavigation navigation: WKNavigation!,
        withError error: any Error)
    {
        webChatLogger.error("didFailProvisional error=\(error.localizedDescription, privacy: .public)")
    }

    func webView(_ webView: WKWebView, didFail navigation: WKNavigation!, withError error: any Error) {
        webChatLogger.error("didFail error=\(error.localizedDescription, privacy: .public)")
    }

    func webViewWebContentProcessDidTerminate(_ webView: WKWebView) {
        webChatLogger.error("webContentProcessDidTerminate")
    }

    func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {
        guard let body = message.body as? [String: Any],
              let id = body["id"] as? String
        else { return }

        if id == "log" {
            if let log = body["log"] as? String {
                webChatLogger.debug("JS: \(log, privacy: .public)")
            }
            return
        }

        guard let type = body["type"] as? String,
              type == "chat",
              let payload = body["payload"] as? [String: Any],
              let text = payload["text"] as? String
        else { return }

        Task { @MainActor in
            let reply = await runAgent(text: text, sessionKey: sessionKey)
            let json: [String: Any] = [
                "id": id,
                "ok": reply.error == nil,
                "result": ["text": reply.text ?? ""],
                "error": reply.error ?? NSNull(),
            ]
            if let data = try? JSONSerialization.data(withJSONObject: json),
               let js = String(data: data, encoding: .utf8)
            {
                _ = try? await self.webView.evaluateJavaScript("window.__clawdisReceive(" + js + ")")
            }
        }
    }

    private func runAgent(text: String, sessionKey: String) async -> (text: String?, error: String?) {
        await MainActor.run { AppStateStore.shared.setWorking(true) }
        defer { Task { await MainActor.run { AppStateStore.shared.setWorking(false) } } }
        let data: Data
        do {
            data = try await Task.detached(priority: .utility) { () -> Data in
                let command = CommandResolver.clawdisCommand(
                    subcommand: "agent",
                    extraArgs: ["--to", sessionKey, "--message", text, "--json"])
                let process = Process()
                process.executableURL = URL(fileURLWithPath: command.first ?? "/usr/bin/env")
                process.arguments = Array(command.dropFirst())
                if command.first != "/usr/bin/ssh" {
                    process.currentDirectoryURL = URL(fileURLWithPath: CommandResolver.projectRootPath())
                }

                var env = ProcessInfo.processInfo.environment
                env["PATH"] = CommandResolver.preferredPaths().joined(separator: ":")
                process.environment = env

                let pipe = Pipe()
                let errPipe = Pipe()
                process.standardOutput = pipe
                process.standardError = errPipe

                try process.run()
                process.waitUntilExit()
                let out = pipe.fileHandleForReading.readDataToEndOfFile()
                let err = errPipe.fileHandleForReading.readDataToEndOfFile()
                guard process.terminationStatus == 0 else {
                    let combined = String(data: out.isEmpty ? err : out, encoding: .utf8)
                    throw NSError(
                        domain: "ClawdisAgent",
                        code: Int(process.terminationStatus),
                        userInfo: [NSLocalizedDescriptionKey: combined?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "unknown error"])
                }
                return out
            }.value
        } catch {
            return (nil, error.localizedDescription)
        }
        if let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
           let payloads = obj["payloads"] as? [[String: Any]],
           let first = payloads.first,
           let text = first["text"] as? String
        {
            return (text, nil)
        }
        return (String(data: data, encoding: .utf8), nil)
    }

    private static func loadInitialMessagesJSON(for sessionKey: String) -> String {
        guard let sessionId = self.sessionId(for: sessionKey) else { return "[]" }
        let path = self.expand("~/.clawdis/sessions/\(sessionId).jsonl")
        guard FileManager.default.fileExists(atPath: path) else { return "[]" }
        guard let content = try? String(contentsOfFile: path, encoding: .utf8) else { return "[]" }

        var messages: [[String: Any]] = []
        for line in content.split(whereSeparator: { $0.isNewline }) {
            guard let data = String(line).data(using: .utf8),
                  let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
            else { continue }
            let message = (obj["message"] as? [String: Any]) ?? obj
            guard let role = message["role"] as? String,
                  ["user", "assistant", "system"].contains(role)
            else { continue }

            var contentPayload = message["content"] as? [[String: Any]]
            if contentPayload == nil, let text = message["text"] as? String {
                contentPayload = [["type": "text", "text": text]]
            }
            guard let finalContent = contentPayload else { continue }
            messages.append(["role": role, "content": finalContent])
        }

        guard let data = try? JSONSerialization.data(withJSONObject: messages, options: []) else {
            return "[]"
        }
        return String(data: data, encoding: .utf8) ?? "[]"
    }

    private static func sessionId(for key: String) -> String? {
        let storePath = self.expand("~/.clawdis/sessions/sessions.json")
        guard let data = try? Data(contentsOf: URL(fileURLWithPath: storePath)) else { return nil }
        guard let decoded = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return nil }
        guard let entry = decoded[key] as? [String: Any] else { return nil }
        return entry["sessionId"] as? String
    }

    private static func expand(_ path: String) -> String {
        (path as NSString).expandingTildeInPath
    }
}

@MainActor
final class WebChatManager {
    static let shared = WebChatManager()
    private var window: WebChatWindowController?
    private var webView: WKWebView? { self.window?.value(forKey: "webView") as? WKWebView }

    func show(sessionKey: String) {
        if self.window == nil {
            self.window = WebChatWindowController(sessionKey: sessionKey)
        }
        self.window?.showWindow(nil)
        self.window?.window?.makeKeyAndOrderFront(nil)
        NSApp.activate(ignoringOtherApps: true)
    }

    /// Send a message into the active web chat session. Returns true if enqueued.
    func sendMessage(_ text: String, thinking: String = "default", sessionKey: String = "main") -> Bool {
        self.show(sessionKey: sessionKey)
        guard let webView else { return false }
        guard let script = try? JSONSerialization.data(withJSONObject: [
            "text": text,
            "thinking": thinking,
        ]) else { return false }

        let payload = String(data: script, encoding: .utf8) ?? ""
        let js = "window.__clawdisEnqueueOutgoing(\(payload))"

        var success = false
        webView.evaluateJavaScript(js) { result, error in
            if error == nil { success = true }
            if let err = error {
                webChatLogger.error("enqueue JS error: \(err.localizedDescription, privacy: .public)")
            } else if let res = result {
                webChatLogger.debug("enqueue JS result: \(String(describing: res), privacy: .public)")
            }
        }
        return success
    }
}