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")
        let messagesJSON = self.initialMessagesJSON.replacingOccurrences(of: "</script>", with: "<\\/script>")
        guard let webChatURL = Bundle.main.url(forResource: "WebChat", withExtension: nil) else {
            NSLog("WebChat resources missing")
            webChatLogger.error("WebChat resources missing in bundle")
            return
        }

        let importMap = [
            "imports": [
                "@mariozechner/pi-web-ui": "./index.js",
                "@mariozechner/pi-web-ui/": "./",
                "@mariozechner/pi-ai": "./pi-ai-stub.js",
                "@mariozechner/pi-ai/": "./pi-ai-stub.js",
                "@mariozechner/mini-lit": "./vendor/@mariozechner/mini-lit/dist/index.js",
                "@mariozechner/mini-lit/": "./vendor/@mariozechner/mini-lit/dist/",
                "lit": "./vendor/lit/index.js",
                "lit/": "./vendor/lit/",
                "lucide": "./vendor/lucide/dist/esm/lucide.js",
                "pdfjs-dist": "./vendor/pdfjs-dist/build/pdf.js",
                "pdfjs-dist/": "./vendor/pdfjs-dist/",
                "pdfjs-dist/build/pdf.worker.min.mjs": "./vendor/pdfjs-dist/build/pdf.worker.min.mjs",
                "docx-preview": "./vendor/docx-preview/dist/docx-preview.mjs",
                "jszip": "./vendor/jszip/dist/jszip.min.js",
                "highlight.js": "./vendor/highlight.js/es/index.js",
                "@lmstudio/sdk": "./vendor/@lmstudio/sdk/dist/index.mjs",
                "ollama/browser": "./vendor/ollama/dist/browser.mjs",
                "@sinclair/typebox": "./vendor/@sinclair/typebox/build/esm/index.mjs",
                "xlsx": "./vendor/xlsx/xlsx.mjs",
            ],
        ]

        let importMapJSON: String = if let data = try? JSONSerialization.data(
            withJSONObject: importMap,
            options: [.prettyPrinted]),
            let json = String(data: data, encoding: .utf8)
        {
            json
        } else {
            "{}"
        }

        let html = self.makeHTML(importMapJSON: importMapJSON, messagesJSON: messagesJSON)
        self.webView.loadHTMLString(html, baseURL: webChatURL)
        webChatLogger.debug("loadPage queued HTML into WKWebView baseURL=\(webChatURL.absoluteString, privacy: .public)")
    }

    // swiftlint:disable line_length
    private func makeHTML(importMapJSON: String, messagesJSON: String) -> String {
        """
        <!doctype html>
        <html>
        <head>
          <meta http-equiv="Content-Security-Policy" content="default-src 'self' 'unsafe-inline' data: blob:;">
          <meta charset='utf-8'>
          <title>Clawd Web Chat</title>
          <link rel='stylesheet' href='app.css'>
          <script type="importmap">
          \(importMapJSON)
          </script>
          <style>html,body{height:100%;margin:0;padding:0;}#app{height:100%;}</style>
        </head>
        <body>
          <div id="app" style="padding:16px;font:14px -apple-system, BlinkMacSystemFont, sans-serif;color:#222">Booting web chat…</div>
          <script type="module">
            // Minimal Node globals expected by pi-web-ui
            if (!window.process) window.process = { env: {} };

            const initialMessages = \(messagesJSON);
            const status = (msg) => {
              console.log(msg);
              window.__clawdisLog(msg);
              const el = document.getElementById('app');
              if (el && !el.dataset.booted) {
                el.textContent = msg;
              }
            };

            status('boot: starting imports');

            (async () => {
              try {
                const { Agent } = await import('./agent/agent.js');
                status('boot: agent loaded');
                const { ChatPanel } = await import('./ChatPanel.js');
                status('boot: ChatPanel loaded');
                const { AppStorage, setAppStorage } = await import('./storage/app-storage.js');
                status('boot: pi-web-ui imported');
                const { getModel } = await import('@mariozechner/pi-ai');
                status('boot: pi-ai stub imported');

                class NativeTransport {
                  async *run(messages, userMessage, cfg, signal) {
                    const result = await window.__clawdisSend({ type: 'chat', payload: { text: userMessage.content?.[0]?.text ?? '', sessionKey: '\(
                        self.sessionKey)' } });
                    const usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } };
                    const assistant = {
                      role: 'assistant',
                      content: [{ type: 'text', text: result.text ?? '' }],
                      api: cfg.model.api,
                      provider: cfg.model.provider,
                      model: cfg.model.id,
                      usage,
                      stopReason: 'stop',
                      timestamp: Date.now()
                    };
                    yield { type: 'turn_start' };
                    yield { type: 'message_start', message: assistant };
                    yield { type: 'message_end', message: assistant };
                    yield { type: 'turn_end' };
                    yield { type: 'agent_end' };
                  }
                }

                // Minimal storage
                const storage = new AppStorage();
                setAppStorage(storage);

                const agent = new Agent({
                  initialState: {
                    systemPrompt: 'You are Clawd (primary session).',
                    model: getModel('anthropic', 'claude-opus-4-5'),
                    thinkingLevel: 'off',
                    messages: initialMessages
                  },
                  transport: new NativeTransport()
                });

                // Patch prompt to append user message into history first
                const origPrompt = agent.prompt.bind(agent);
                agent.prompt = async (input, attachments) => {
                  const userMessage = {
                    role: 'user',
                    content: [{ type: 'text', text: input }],
                    attachments: attachments?.length ? attachments : undefined,
                    timestamp: Date.now()
                  };
                  agent.appendMessage(userMessage);
                  return origPrompt(input, attachments);
                };

                const panel = new ChatPanel();
                panel.style.height = '100%';
                panel.style.display = 'block';
                await panel.setAgent(agent);
                const mount = document.getElementById('app');
                mount.dataset.booted = '1';
                mount.textContent = '';
                mount.appendChild(panel);
                status('boot: ready');
              } catch (err) {
                const msg = err?.stack || err?.message || String(err);
                window.__clawdisLog(msg);
                document.body.style.color = '#e06666';
                document.body.style.fontFamily = 'monospace';
                document.body.style.padding = '16px';
                document.body.innerText = 'Web chat failed to load:\\n' + msg;
              }
            })();
          </script>
        </body>
        </html>
        """
    }

    // swiftlint:enable line_length

    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 process = Process()
                process.executableURL = URL(fileURLWithPath: "/usr/bin/env")
                process.arguments = ["pnpm", "clawdis", "agent", "--to", sessionKey, "--message", text, "--json"]
                process.currentDirectoryURL = URL(fileURLWithPath: "/Users/steipete/Projects/clawdis")

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

                try process.run()
                process.waitUntilExit()
                let out = pipe.fileHandleForReading.readDataToEndOfFile()
                guard process.terminationStatus == 0 else {
                    throw NSError(
                        domain: "ClawdisAgent",
                        code: Int(process.terminationStatus),
                        userInfo: [NSLocalizedDescriptionKey: String(data: out, encoding: .utf8) ?? "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?

    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)
    }
}