HTMLPopup.swift

import Cocoa
import WebKit
import CommonCrypto
import UniformTypeIdentifiers

func logError(_ message: String) {
    fputs("ERROR: \(message)\n", stderr)
}

func logFatalError(_ message: String) -> Never {
    NSApplication.shared.terminate(nil)
    fatalError("FATAL: \(message)")
}

func readStdin() -> String {
    var input = ""
    while let line = readLine() {
        input += line + "\n"
    }
    return input
}

struct Options {
    var html: String = ""
    var url: URL? = nil
    var title: String = ""
    var width: CGFloat = 800
    var height: CGFloat = 600
    var env: [String: Any] = [:] // Default empty dictionary
    var staticDirectory: String? = nil
    var filePath: String? = nil
    var storageID: String? = nil
}

var currentVersion = "dev" // Default version, will be overridden by build system

func printUsage() {
    fputs("""
Usage: htmlpopup [OPTIONS] content

Arguments:
  content
    HTML content string, path to an HTML file, a URL, or a directory.
    Use '-' to read HTML from stdin.
    If a directory is provided, it will serve 'index.html' from that directory
    or generate a directory listing if 'index.html' is not found.

Options:
  --title <title>         Set the window title (default: <empty>).
  --width <width>         Set the window width (default: 800)
  --height <height>       Set the window height (default: 600)
  --env <json_object>     Provide a JSON object to be injected as window.env in the web view.
  --env.<key> <value>     Provide individual key-value pairs to be injected as window.env.
                          Values are parsed as JSON if possible, otherwise as strings.
  --version               Print the version of htmlpopup.
  --help                  Print this help message.

Javascript API:
  Your HTML has access to the following Javascript APIs:

  interface App {
    // Properties
    theme: 'light' | 'dark';  // Current system theme

    // Window Control
    finish(message: string): void;  // Close window and print message to stdout
    setSize(width: number, height: number): void;  // Resize the window
    setFullscreen(enabled: boolean): void;  // Toggle fullscreen mode
    setFloating(enabled: boolean): void;  // Pin/unpin window to stay on top
    setTitle(title: string): void;  // Change the window title

    // File System
    selectFolder(): Promise<string>;  // Open native folder picker dialog
    selectFile(options?: {  // Open native file picker dialog
      canChooseFiles?: boolean;
      canChooseDirectories?: boolean;
      allowsMultipleSelection?: boolean;
      allowedFileTypes?: string[];
    }): Promise<string | string[]>;
    saveFile(content: string, fileName?: string): Promise<string>;  // Open save dialog
    readFile(filePath: string): Promise<string>;  // Read file content as text
    readFileAsDataURL(filePath: string): Promise<string>;  // Read file as base64 Data URL
    revealInFinder(path: string): void;  // Show file/folder in Finder

    // Terminal Output
    writeLine(text: string): void;  // Print line to stdout
  }

  declare const window: {
    env: Record<string, any>;  // From --env or --env.<key>
    app: App;
  };

  // Events
  'files-dropped': CustomEvent<{ files: string[] }>;  // Fired when files are dropped
  'themechange': CustomEvent<{ theme: 'light' | 'dark' }>;  // Fired on theme change

  // CSS Variables (auto-adapt to theme)
  --htmlpopup-background, --htmlpopup-text, --htmlpopup-border,
  --htmlpopup-surface, --htmlpopup-link, --htmlpopup-muted

Examples:
  htmlpopup "<h1>Hello, World!</h1>"
  htmlpopup my_page.html
  htmlpopup --width 1024 --height 768 --title "My App" ./static/
  htmlpopup --env.API_KEY "secret" --env.DEBUG true app.html
  echo "<p>From stdin</p>" | htmlpopup -

""", stderr)
}


struct ArgumentError: Error {
    let message: String
}

func parseArguments() throws -> Options {
    var options = Options()
    let args = Array(CommandLine.arguments.dropFirst())
    var envArgs: [String: Any] = [:]
    var parsingFlags = true

    // 1. Fast path for global flags
    if args.contains("--version") {
        print("htmlpopup version: \(currentVersion)")
        exit(0)
    }
    if args.contains("--help") {
        printUsage()
        exit(0)
    }

    var argIterator = args.makeIterator()
    while let arg = argIterator.next() {

        // 2. Handle the "end of flags" marker --
        if arg == "--" {
            parsingFlags = false
            continue
        }

        if parsingFlags && arg.hasPrefix("--") {
            if arg.hasPrefix("--env.") {
                let key = String(arg.dropFirst(6))
                guard let valueString = argIterator.next() else {
                    throw ArgumentError(message: "Missing value for \(arg)")
                }
                // Attempt to parse value as JSON (e.g., numbers, booleans), fallback to string
                if let data = valueString.data(using: .utf8),
                   let jsonValue = try? JSONSerialization.jsonObject(with: data, options: .allowFragments) {
                    envArgs[key] = jsonValue
                } else {
                    envArgs[key] = valueString
                }
            } else {
                guard let value = argIterator.next() else {
                    throw ArgumentError(message: "Missing value for \(arg)")
                }
                switch arg {
                case "--id":     options.storageID = value
                case "--title":  options.title = value
                case "--width":  options.width = CGFloat(Double(value) ?? 800)
                case "--height": options.height = CGFloat(Double(value) ?? 600)
                case "--env":
                    if let data = value.data(using: .utf8),
                       let dict = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any] {
                        options.env = dict
                    } else {
                        throw ArgumentError(message: "Invalid JSON for --env")
                    }
                default:
                    throw ArgumentError(message: "Unknown option: \(arg)")
                }
            }
        } else {
            // 3. Handle Content Argument
            if options.html.isEmpty && options.url == nil && options.staticDirectory == nil {
                if arg == "-" {
                    options.html = readStdin()
                } else if let url = URL(string: arg), let scheme = url.scheme?.lowercased(), ["http", "https"].contains(scheme) {
                    options.url = url
                } else {
                    // Check if it is a directory or file
                    var isDir: ObjCBool = false
                    if FileManager.default.fileExists(atPath: arg, isDirectory: &isDir) {
                        if isDir.boolValue {
                            options.staticDirectory = arg // Allowed even without index.html now
                        } else {
                            options.filePath = arg
                            options.html = try String(contentsOfFile: arg, encoding: .utf8)
                        }
                    } else {
                        // If it ends in .html but doesn't exist, warn the user
                        if arg.hasSuffix(".html") || arg.hasSuffix(".htm") {
                            logError("Warning: '\(arg)' looks like a file but was not found. Treating as raw string.")
                        }
                        options.html = arg
                    }
                }
            } else {
                throw ArgumentError(message: "Unexpected argument: \(arg)")
            }
        }
    }

    options.env = options.env.merging(envArgs) { (_, new) in new }

    guard !(options.html.isEmpty && options.url == nil && options.staticDirectory == nil) else {
        throw ArgumentError(message: "No content provided (HTML string, file, or URL).")
    }

    return options
}

func stableUUID(from string: String) -> UUID {
    let data = Data(string.utf8)
    var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
    data.withUnsafeBytes { _ = CC_SHA256($0.baseAddress, CC_LONG(data.count), &hash) }
    // Use first 16 bytes for UUID
    return UUID(uuid: (hash[0], hash[1], hash[2], hash[3], hash[4], hash[5], hash[6], hash[7],
                       hash[8], hash[9], hash[10], hash[11], hash[12], hash[13], hash[14], hash[15]))
}

class WindowController: NSWindowController, NSWindowDelegate {
    private var pinButton: NSButton!
    public var isPinned: Bool {
        get {
            return window?.level == .floating
        }
        set {
            window?.level = newValue ? .floating : .normal
            updatePinButtonImage()
        }
    }

    init(width: CGFloat, height: CGFloat, title: String) {
        let window = NSWindow(
            contentRect: NSRect(x: 0, y: 0, width: width, height: height),
            styleMask: [.titled, .closable, .miniaturizable, .resizable],
            backing: .buffered,
            defer: false
        )

        window.title = title
        window.level = .floating  // Window starts as floating
        window.center()

        // Added .fullScreenPrimary to support standard macOS fullscreen behavior
        window.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .fullScreenPrimary]
        window.isReleasedWhenClosed = false

        super.init(window: window)
        window.delegate = self

        setupPinButton()
        setupKeyEventMonitor()
    }

    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    private var keyEventMonitor: Any?

    private func setupPinButton() {
        guard let window = self.window else { return }

        pinButton = NSButton(frame: NSRect(x: 0, y: 0, width: 16, height: 16))
        pinButton.bezelStyle = .texturedRounded
        pinButton.isBordered = false
        pinButton.imagePosition = .imageOnly
        pinButton.state = isPinned ? .on : .off  // Set initial state based on window level
        updatePinButtonImage()  // Set initial image
        pinButton.toolTip = "Keep window floating on top"
        pinButton.target = self
        pinButton.action = #selector(togglePin)

        // Position the button in the titlebar
        if let titlebarView = window.standardWindowButton(.closeButton)?.superview {
            titlebarView.addSubview(pinButton)

            if let closeButton = window.standardWindowButton(.closeButton) {
                let margin: CGFloat = 6
                let pinButtonX = titlebarView.frame.width - pinButton.frame.width - margin
                let pinButtonY = closeButton.frame.minY

                pinButton.frame.origin = CGPoint(x: pinButtonX, y: pinButtonY)
                pinButton.autoresizingMask = [.minXMargin]
            }
        }
    }

    private func updatePinButtonImage() {
        let imageName = isPinned ? "pin.fill" : "pin"
        pinButton.image = NSImage(systemSymbolName: imageName, accessibilityDescription: isPinned ? "Unpin Window" : "Pin Window")
    }

    @objc private func togglePin() {
        isPinned.toggle()
    }

    // Set up a local key event monitor that will detect ESC key presses
    private func setupKeyEventMonitor() {
        keyEventMonitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { [weak self] event in
            if event.keyCode == 53 { // ESC key
                // Unfloat the window and move it to background
                self?.isPinned = false
                self?.window?.orderBack(nil)
                return nil // Consume the event
            }
            return event // Pass other events through
        }
    }

    deinit {
        if let monitor = keyEventMonitor {
            NSEvent.removeMonitor(monitor)
        }
    }
}

class DraggableWebView: WKWebView {
    weak var appDelegate: AppDelegate?
    
    override func awakeFromNib() {
        super.awakeFromNib()
        registerForDraggedTypes([.fileURL, .string])
    }
    
    override init(frame: CGRect, configuration: WKWebViewConfiguration) {
        super.init(frame: frame, configuration: configuration)
        registerForDraggedTypes([.fileURL, .string])
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        registerForDraggedTypes([.fileURL, .string])
    }
    
    override func draggingEntered(_ sender: NSDraggingInfo) -> NSDragOperation {
        if sender.draggingPasteboard.types?.contains(.fileURL) == true {
            return .copy
        }
        return []
    }
    
    override func performDragOperation(_ sender: NSDraggingInfo) -> Bool {
        guard let urls = sender.draggingPasteboard.readObjects(forClasses: [NSURL.self]) as? [URL] else {
            return false
        }
        
        let paths = urls.map { $0.path }
        
        do {
            let jsonData = try JSONSerialization.data(withJSONObject: paths, options: [])
            guard let jsonString = String(data: jsonData, encoding: .utf8) else { return false }
            
            let jsCallback = """
            window.dispatchEvent(new CustomEvent('files-dropped', {
                detail: { files: \(jsonString) }
            }));
            """
            
            evaluateJavaScript(jsCallback)
        } catch {
            logError("JSON serialization error: \(error)")
        }
        
        return true
    }
}

class AppDelegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKScriptMessageHandler {
    var windowController: WindowController?
    var webView: WKWebView?
    var closeString: String?
    let options: Options
    private var themeObserver: NSKeyValueObservation?

    init(options: Options) {
        self.options = options
        super.init()
    }

    func applicationDidFinishLaunching(_ notification: Notification) {
        NSApplication.shared.setActivationPolicy(.regular)
        setupMenuBar()
        setupWindowAndWebView()
        handleThemeChange()
        setupThemeObserver()
    }

    private func setupMenuBar() {
        let menuBar = NSMenu()
        NSApplication.shared.mainMenu = menuBar

        let fileMenuItem = NSMenuItem()
        menuBar.addItem(fileMenuItem)
        let fileMenu = NSMenu(title: "File")
        fileMenuItem.submenu = fileMenu

        fileMenu.addItem(NSMenuItem(title: "Close Window",
                                    action: #selector(NSWindow.performClose(_:)),
                                    keyEquivalent: "w"))
        fileMenu.addItem(NSMenuItem.separator())
        fileMenu.addItem(NSMenuItem(title: "Quit",
                                    action: #selector(NSApplication.terminate(_:)),
                                    keyEquivalent: "q"))

        let editMenuItem = NSMenuItem()
        menuBar.addItem(editMenuItem)
        let editMenu = NSMenu(title: "Edit")
        editMenuItem.submenu = editMenu

        editMenu.addItem(NSMenuItem(title: "Undo",
                                    action: Selector(("undo:")),
                                    keyEquivalent: "z"))
        editMenu.addItem(NSMenuItem(title: "Redo",
                                    action: Selector(("redo:")),
                                    keyEquivalent: "Z"))
        editMenu.addItem(NSMenuItem.separator())
        editMenu.addItem(NSMenuItem(title: "Cut",
                                    action: #selector(NSText.cut(_:)),
                                    keyEquivalent: "x"))
        editMenu.addItem(NSMenuItem(title: "Copy",
                                    action: #selector(NSText.copy(_:)),
                                    keyEquivalent: "c"))
        editMenu.addItem(NSMenuItem(title: "Paste",
                                    action: #selector(NSText.paste(_:)),
                                    keyEquivalent: "v"))
        editMenu.addItem(NSMenuItem(title: "Select All",
                                    action: #selector(NSText.selectAll(_:)),
                                    keyEquivalent: "a"))
    }

    private func setupThemeObserver() {
        if #available(macOS 10.14, *) {
            themeObserver = NSApp.observe(\.effectiveAppearance) { [weak self] _, _ in
                DispatchQueue.main.async {
                    self?.handleThemeChange()
                }
            }
        }
    }

    private func handleThemeChange() {
        guard let window = windowController?.window,
              let webView = self.webView else { return }

        // Update window appearance
        if #available(macOS 10.14, *) {
            let isDarkMode = NSApp.effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua
            window.appearance = NSAppearance(named: isDarkMode ? .darkAqua : .aqua)

            // Notify web content about theme change
            let themeScript = """
                if (window.app && window.app.onThemeChange) {
                    window.app.onThemeChange('\(isDarkMode ? "dark" : "light")');
                }
                // Also dispatch a custom event for more flexibility
                window.dispatchEvent(new CustomEvent('themechange', {
                    detail: { theme: '\(isDarkMode ? "dark" : "light")' }
                }));
            """

            webView.evaluateJavaScript(themeScript) { _, error in
                if let error = error {
                    print("Error executing theme change script: \(error)")
                }
            }
        }
    }

    private func setupWindowAndWebView() {
        windowController = WindowController(
            width: options.width,
            height: options.height,
            title: options.title
        )

        let userContentController = WKUserContentController()
        userContentController.add(self, name: "app")
        setupUserScripts(userContentController: userContentController, env: options.env)

        let config = WKWebViewConfiguration()
        config.userContentController = userContentController

        // 1. GENERATE UNIQUE ORIGIN
        // We use http://[ID].local to guarantee localStorage partitioning by hostname.
        // We use a stable hash of the source to keep the hostname clean and consistent.
        let identifierSource: String
        if let sid = options.storageID {
            identifierSource = sid
        } else if let fp = options.filePath {
            identifierSource = fp // Stable path, content can change
        } else if let sd = options.staticDirectory {
            identifierSource = sd
        } else if let url = options.url {
            identifierSource = url.absoluteString
        } else if !options.html.isEmpty {
            identifierSource = "html-" + stableUUID(from: options.html).uuidString
        } else {
            identifierSource = "default"
        }

        let hostID = stableUUID(from: identifierSource).uuidString.lowercased().replacingOccurrences(of: "-", with: "")
        let dummyOrigin = URL(string: "http://\(hostID).local")!

        // 2. CONFIGURE PERSISTENCE
        config.websiteDataStore = WKWebsiteDataStore.default()

        config.preferences.setValue(true, forKey: "developerExtrasEnabled")
        config.preferences.setValue(true, forKey: "allowFileAccessFromFileURLs")
        config.setValue(true, forKey: "allowUniversalAccessFromFileURLs")

        if #available(macOS 11.0, *) {
            config.defaultWebpagePreferences.allowsContentJavaScript = true
        } else {
            config.preferences.javaScriptEnabled = true
        }

        guard let contentView = windowController?.window?.contentView else {
            logFatalError("Window contentView is nil.")
        }

        webView = DraggableWebView(frame: contentView.bounds, configuration: config)
        guard let webView = webView else {
            logFatalError("Failed to create WKWebView.")
        }
        (webView as? DraggableWebView)?.appDelegate = self
        webView.autoresizingMask = [.width, .height]
        webView.navigationDelegate = self

        if #available(macOS 10.14, *) {
            webView.setValue(false, forKey: "drawsBackground")
        }

        // 3. LOAD CONTENT
        if let staticDir = options.staticDirectory {
            let dirURL = URL(fileURLWithPath: staticDir, isDirectory: true)
            let indexURL = dirURL.appendingPathComponent("index.html")

            if FileManager.default.fileExists(atPath: indexURL.path) {
                if var html = try? String(contentsOf: indexURL) {
                    // Inject <base> tag to support relative paths while using a custom origin
                    let baseTag = "<base href=\"\(dirURL.absoluteString)\">"
                    if html.lowercased().contains("<head>") {
                        html = html.replacingOccurrences(of: "<head>", with: "<head>\(baseTag)", options: .caseInsensitive)
                    } else {
                        html = "<head>\(baseTag)</head>" + html
                    }
                    webView.loadHTMLString(html, baseURL: dummyOrigin)
                } else {
                    // Fallback to file URL if reading fails
                    webView.loadFileURL(indexURL, allowingReadAccessTo: dirURL)
                }
            } else {
                // Generate directory listing if index.html is missing
                let html = generateDirectoryListing(for: dirURL)
                webView.loadHTMLString(html, baseURL: dirURL)
            }
        } else if let url = options.url {
            webView.load(URLRequest(url: url))
        } else if !options.html.isEmpty {
            let baseURL: URL
            if let fp = options.filePath {
                baseURL = URL(fileURLWithPath: fp).deletingLastPathComponent()
            } else {
                baseURL = URL(fileURLWithPath: FileManager.default.currentDirectoryPath, isDirectory: true)
            }

            let baseTag = "<base href=\"\(baseURL.absoluteString)\">"
            var html = options.html
            if html.lowercased().contains("<head>") {
                html = html.replacingOccurrences(of: "<head>", with: "<head>\(baseTag)", options: .caseInsensitive)
            } else {
                html = "<head>\(baseTag)</head>" + html
            }
            webView.loadHTMLString(html, baseURL: dummyOrigin)
        }

        contentView.addSubview(webView)
        windowController?.showWindow(nil)
        NSApplication.shared.activate(ignoringOtherApps: true)
        windowController?.window?.makeKeyAndOrderFront(nil)
    }

    func webView(_ webView: WKWebView,
                decidePolicyFor navigationAction: WKNavigationAction,
                decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {

        if let url = navigationAction.request.url {
            let host = url.host?.lowercased() ?? ""
            let scheme = url.scheme?.lowercased() ?? ""

            // 1. Allow our internal partitioned origins
            if host.hasSuffix(".local") {
                decisionHandler(.allow)
                return
            }

            // 2. Allow standard web/file schemes
            if ["http", "https", "about", "file"].contains(scheme) {
                decisionHandler(.allow)
                return
            }

            // 3. Hand off external protocols (mailto, slack, etc) to the system
            if !NSWorkspace.shared.open(url) {
                logError("Failed to open URL: \(url)")
            }
            decisionHandler(.cancel)
            return
        }

        decisionHandler(.allow)
    }

    func setupUserScripts(userContentController: WKUserContentController, env: [String: Any] = [:]) {
        // Convert the dictionary to a JSON string
        var envJsonString = "{}"
        if let jsonData = try? JSONSerialization.data(withJSONObject: env, options: []),
           let jsonString = String(data: jsonData, encoding: .utf8) {
            envJsonString = jsonString
        }

        // Get current theme state
        let isDarkMode = NSApp.effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua
        let currentTheme = isDarkMode ? "dark" : "light"

        let defaultThemeCSS = """
:root {
    color-scheme: light dark;
    --htmlpopup-background: #ffffff;
    --htmlpopup-text: #1c1c1e;
    --htmlpopup-border: #d1d1d6;
    --htmlpopup-surface: rgba(249, 249, 251, 0.9);
    --htmlpopup-link: #0a84ff;
    --htmlpopup-muted: #6e6e73;
}

:root[data-theme='dark'],
.dark {
    color-scheme: dark;
    --htmlpopup-background: #1c1c1e;
    --htmlpopup-text: #f5f5f7;
    --htmlpopup-border: #2c2c2e;
    --htmlpopup-surface: rgba(44, 44, 46, 0.85);
    --htmlpopup-link: #63a4ff;
    --htmlpopup-muted: #8e8e93;
}

body {
    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
    background-color: var(--htmlpopup-background);
    color: var(--htmlpopup-text);
}

a, button {
    color: inherit;
    cursor: pointer;
}

input,
textarea,
select {
    color: inherit;
}

code,
pre {
    color: inherit;
}
"""

        // First inject ENV
        let envScript = WKUserScript(
            source: "window.env = \(envJsonString);",
            injectionTime: .atDocumentStart,
            forMainFrameOnly: true
        )

        // Provide baseline theming tokens so content inherits light/dark styling automatically.
        let cssInjectionScript = WKUserScript(
            source: """
                (function() {
                    if (document.getElementById('htmlpopup-theme-style')) { return; }
                    const css = `\(defaultThemeCSS)`;
                    const style = document.createElement('style');
                    style.id = 'htmlpopup-theme-style';
                    style.type = 'text/css';
                    style.textContent = css;
                    (document.head || document.documentElement).appendChild(style);
                })();
            """,
            injectionTime: .atDocumentStart,
            forMainFrameOnly: true
        )

        // Then inject app API
        let appScript = WKUserScript(
            source: """
            window.app = {
                theme: '\(currentTheme)',
                onThemeChange: null,
                finish: function(message) {
                    window.webkit.messageHandlers.app.postMessage({ action: "finish", message: message });
                },
                setSize: function(width, height) {
                    window.webkit.messageHandlers.app.postMessage({ action: "setSize", width: width, height: height });
                },
                setFullscreen: function(enabled) {
                    window.webkit.messageHandlers.app.postMessage({ action: "setFullscreen", enabled: !!enabled });
                },
                setFloating: function(enabled) {
                    window.webkit.messageHandlers.app.postMessage({ action: "setFloating", enabled: !!enabled });
                },
                setTitle: function(title) {
                    window.webkit.messageHandlers.app.postMessage({ action: "setTitle", title: title });
                },
                revealInFinder: function(path) {
                    window.webkit.messageHandlers.app.postMessage({ action: "revealInFinder", path: path });
                },
                selectFolder: function() {
                    return new Promise((resolve, reject) => {
                        const callbackId = 'callback_' + Math.random().toString(36).substr(2, 9);
                        window[callbackId] = { resolve: resolve, reject: reject };
                        window.webkit.messageHandlers.app.postMessage({
                            action: "selectFolder",
                            callbackId: callbackId
                        });
                    });
                },
                selectFile: function(options = {}) {
                    return new Promise((resolve, reject) => {
                        const callbackId = 'callback_' + Math.random().toString(36).substr(2, 9);
                        window[callbackId] = { resolve: resolve, reject: reject };
                        window.webkit.messageHandlers.app.postMessage({
                            action: "selectFile",
                            callbackId: callbackId,
                            options: options
                        });
                    });
                },
                saveFile: function(content, fileName) {
                    return new Promise((resolve, reject) => {
                        const callbackId = 'callback_' + Math.random().toString(36).substr(2, 9);
                        window[callbackId] = { resolve: resolve, reject: reject };
                        window.webkit.messageHandlers.app.postMessage({
                            action: "saveFile",
                            callbackId: callbackId,
                            content: content,
                            fileName: fileName
                        });
                    });
                },
                readFile: function(filePath) {
                    return new Promise((resolve, reject) => {
                        const callbackId = 'callback_' + Math.random().toString(36).substr(2, 9);
                        window[callbackId] = { resolve: resolve, reject: reject };
                        window.webkit.messageHandlers.app.postMessage({
                            action: "readFile",
                            callbackId: callbackId,
                            filePath: filePath
                        });
                    });
                },
                readFileAsDataURL: function(filePath) {
                    return new Promise((resolve, reject) => {
                        const callbackId = 'callback_' + Math.random().toString(36).substr(2, 9);
                        window[callbackId] = { resolve: resolve, reject: reject };
                        window.webkit.messageHandlers.app.postMessage({
                            action: "readFileAsDataURL",
                            callbackId: callbackId,
                            filePath: filePath
                        });
                    });
                },
                writeLine: function(text) {
                    window.webkit.messageHandlers.app.postMessage({ action: "writeLine", text: text });
                }
            };

            // Set initial theme class on document
            document.addEventListener('DOMContentLoaded', function() {
                document.documentElement.setAttribute('data-theme', window.app.theme);
                document.documentElement.classList.toggle('dark', window.app.theme === 'dark');
            });

            // Listen for theme changes
            window.addEventListener('themechange', function(event) {
                window.app.theme = event.detail.theme;
                document.documentElement.setAttribute('data-theme', event.detail.theme);
                document.documentElement.classList.toggle('dark', event.detail.theme === 'dark');
            });
            """,
            injectionTime: .atDocumentStart,
            forMainFrameOnly: true
        )

        userContentController.addUserScript(envScript)
        userContentController.addUserScript(cssInjectionScript)
        userContentController.addUserScript(appScript)
    }

    func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {
        if message.name == "app" {
            if let messageBody = message.body as? [String: Any] {
                let action = messageBody["action"] as? String ?? "unknown"

                switch action {
                case "finish":
                    appFinish(messageBody["message"] as? String ?? "")
                case "setSize":
                    if let width = messageBody["width"] as? CGFloat, let height = messageBody["height"] as? CGFloat {
                        appSetSize(width, height)
                    }
                case "setFullscreen":
                    appSetFullscreen(messageBody["enabled"] as? Bool ?? false)
                case "setFloating":
                    appSetFloating(messageBody["enabled"] as? Bool ?? false)
                case "setTitle":
                    if let title = messageBody["title"] as? String {
                        appSetTitle(title)
                    }
                case "selectFolder":
                    if let callbackId = messageBody["callbackId"] as? String {
                        appSelectFolder(callbackId: callbackId)
                    }
                case "selectFile":
                    if let callbackId = messageBody["callbackId"] as? String {
                        appSelectFile(callbackId: callbackId, options: messageBody["options"] as? [String: Any] ?? [:])
                    }
                case "saveFile":
                    if let callbackId = messageBody["callbackId"] as? String {
                        appSaveFile(callbackId: callbackId,
                                   content: messageBody["content"] as? String ?? "",
                                   fileName: messageBody["fileName"] as? String)
                    }
                case "revealInFinder":
                    if let path = messageBody["path"] as? String {
                        appRevealInFinder(path: path)
                    }
                case "readFile":
                    if let callbackId = messageBody["callbackId"] as? String,
                       let filePath = messageBody["filePath"] as? String {
                        appReadFile(callbackId: callbackId, filePath: filePath, asDataURL: false)
                    }
                case "readFileAsDataURL":
                    if let callbackId = messageBody["callbackId"] as? String,
                       let filePath = messageBody["filePath"] as? String {
                        appReadFile(callbackId: callbackId, filePath: filePath, asDataURL: true)
                    }
                case "writeLine":
                    if let text = messageBody["text"] as? String {
                        appWriteLine(text)
                    }
                default:
                    logError("Unknown action: \(action)")
                }
            }
        }
    }

    func appSelectFolder(callbackId: String) {
        let openPanel = NSOpenPanel()
        openPanel.canChooseDirectories = true
        openPanel.canChooseFiles = false
        openPanel.allowsMultipleSelection = false
        openPanel.level = .floating + 1

        let response = openPanel.runModal()
        self.handleFileSelection(callbackId: callbackId, response: response, panel: openPanel)
    }

    func appSelectFile(callbackId: String, options: [String: Any]) {
        let openPanel = NSOpenPanel()
        openPanel.canChooseDirectories = options["canChooseDirectories"] as? Bool ?? false
        openPanel.canChooseFiles = options["canChooseFiles"] as? Bool ?? true
        openPanel.allowsMultipleSelection = options["allowsMultipleSelection"] as? Bool ?? false

        if let allowedTypes = options["allowedFileTypes"] as? [String] {
            if #available(macOS 11.0, *) {
                let types = allowedTypes.compactMap { UTType(filenameExtension: $0) }
                openPanel.allowedContentTypes = types
            } else {
                openPanel.allowedFileTypes = allowedTypes
            }
        }

        openPanel.level = .floating + 1

        let response = openPanel.runModal()
        self.handleFileSelection(callbackId: callbackId, response: response, panel: openPanel)
    }

    private func handleFileSelection(callbackId: String, response: NSApplication.ModalResponse, panel: NSOpenPanel) {
        guard let webView = self.webView else { return }

        if response == .OK {
            let paths = panel.urls.map { $0.path }
            let result: Any = (panel.allowsMultipleSelection) ? paths : (paths.first ?? "")

            do {
                let jsonData = try JSONSerialization.data(withJSONObject: [result], options: [])
                guard let jsonArrayString = String(data: jsonData, encoding: .utf8) else { return }
                let jsonString = String(jsonArrayString.dropFirst().dropLast())
                
                let jsCallback = """
                (function() {
                    const cb = window['\(callbackId)'];
                    if (cb) {
                        cb.resolve(\(jsonString));
                        delete window['\(callbackId)'];
                    }
                })();
                """
                
                DispatchQueue.main.async {
                    webView.evaluateJavaScript(jsCallback) { _, error in
                        if let error = error {
                            logError("JS evaluation error: \(error.localizedDescription)")
                        }
                    }
                }
            } catch {
                logError("JSON serialization error: \(error.localizedDescription)")
            }
        } else {
            let jsCallback = "if(window['\(callbackId)']) { window['\(callbackId)'].reject('Cancelled'); delete window['\(callbackId)']; }"
            DispatchQueue.main.async {
                webView.evaluateJavaScript(jsCallback, completionHandler: nil)
            }
        }
    }

    func appSaveFile(callbackId: String, content: String, fileName: String?) {
        let savePanel = NSSavePanel()
        if let fileName = fileName {
            savePanel.nameFieldStringValue = fileName
        }
        savePanel.level = .floating + 1

        let response = savePanel.runModal()
        guard let webView = self.webView else { return }

        if response == .OK, let url = savePanel.url {
            do {
                try content.write(to: url, atomically: true, encoding: .utf8)
                let jsonData = try JSONSerialization.data(withJSONObject: [url.path], options: [])
                let jsonPath = String(data: jsonData, encoding: .utf8)?.dropFirst().dropLast() ?? "\"\""
                
                let jsCallback = """
                (function() {
                    const cb = window['\(callbackId)'];
                    if (cb) {
                        cb.resolve(\(jsonPath));
                        delete window['\(callbackId)'];
                    }
                })();
                """
                webView.evaluateJavaScript(jsCallback)
            } catch {
                let errString = error.localizedDescription
                let jsonData = (try? JSONSerialization.data(withJSONObject: [errString], options: [])) ?? Data()
                let jsonErr = String(data: jsonData, encoding: .utf8)?.dropFirst().dropLast() ?? "\"Error\""
                
                let jsCallback = "window['\(callbackId)'].reject(\(jsonErr)); delete window['\(callbackId)'];"
                webView.evaluateJavaScript(jsCallback)
            }
        } else {
            let jsCallback = "if(window['\(callbackId)']) { window['\(callbackId)'].reject('Cancelled'); delete window['\(callbackId)']; }"
            webView.evaluateJavaScript(jsCallback)
        }
    }

    func appRevealInFinder(path: String) {
        NSWorkspace.shared.selectFile(path, inFileViewerRootedAtPath: "")
    }

    func appWriteLine(_ text: String) {
        print(text)
    }

    func applicationWillTerminate(_ aNotification: Notification) {
        themeObserver?.invalidate()
        themeObserver = nil

        if let closeMessage = closeString {
            print(closeMessage)
        }
    }

    // JavaScript binding function
    func appFinish(_ message: String) {
        closeString = message
        NSApplication.shared.terminate(nil)
    }

    func appSetSize(_ width: CGFloat, _ height: CGFloat) {
        guard let window = windowController?.window else { return }
        window.setContentSize(NSSize(width: width, height: height))
    }

    func appSetFullscreen(_ enabled: Bool) {
        guard let window = windowController?.window else { return }
        let isFullscreen = window.styleMask.contains(.fullScreen)
        
        if isFullscreen != enabled {
            // If entering fullscreen, we should ensure window level is normal
            // as floating windows can sometimes misbehave in fullscreen.
            if enabled {
                window.level = .normal
            }
            window.toggleFullScreen(nil)
            
            // Restore floating state if we are exiting fullscreen and it was pinned
            if !enabled && (windowController?.isPinned ?? false) {
                window.level = .floating
            }
        }
    }

    func appSetFloating(_ enabled: Bool) {
        windowController?.isPinned = enabled
    }

    func appSetTitle(_ title: String) {
        windowController?.window?.title = title
    }

    func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
        return true
    }

    func appReadFile(callbackId: String, filePath: String, asDataURL: Bool) {
        guard let webView = self.webView else { return }
        
        let fileURL = URL(fileURLWithPath: filePath)
        
        do {
            let data = try Data(contentsOf: fileURL)
            
            let result: String
            if asDataURL {
                let mimeType = getMimeType(for: filePath)
                let base64 = data.base64EncodedString()
                result = "data:\(mimeType);base64,\(base64)"
            } else {
                result = String(data: data, encoding: .utf8) ?? ""
            }
            
            let jsonData = try JSONSerialization.data(withJSONObject: [result], options: [])
            guard let jsonString = String(data: jsonData, encoding: .utf8) else { return }
            let content = String(jsonString.dropFirst().dropLast())
            
            let jsCallback = """
            (function() {
                const cb = window['\(callbackId)'];
                if (cb) {
                    cb.resolve(\(content));
                    delete window['\(callbackId)'];
                }
            })();
            """
            
            webView.evaluateJavaScript(jsCallback)
        } catch {
            let jsCallback = "if(window['\(callbackId)']) { window['\(callbackId)'].reject('\(error.localizedDescription)'); delete window['\(callbackId)']; }"
            webView.evaluateJavaScript(jsCallback)
        }
    }
    
    private func getMimeType(for path: String) -> String {
        let ext = (path as NSString).pathExtension.lowercased()
        let mimeTypes: [String: String] = [
            "jpg": "image/jpeg", "jpeg": "image/jpeg", "png": "image/png",
            "gif": "image/gif", "webp": "image/webp", "svg": "image/svg+xml",
            "txt": "text/plain", "pdf": "application/pdf", "json": "application/json"
        ]
        return mimeTypes[ext] ?? "application/octet-stream"
    }

    private func generateDirectoryListing(for directory: URL) -> String {
        do {
            let contents = try FileManager.default.contentsOfDirectory(at: directory, includingPropertiesForKeys: nil)
            var html = """
            <!DOCTYPE html>
            <html>
            <head>
                <title>Directory Listing</title>
                <style>
                    body { font-family: -apple-system, sans-serif; padding: 20px; }
                    h1 { color: #333; }
                    ul { list-style: none; padding: 0; }
                    li { padding: 5px 0; }
                    a { color: #0066cc; text-decoration: none; }
                    a:hover { text-decoration: underline; }
                </style>
            </head>
            <body>
                <h1>Directory Listing</h1>
                <ul>
            """

            for item in contents {
                let name = item.lastPathComponent
                html += "<li><a href=\"\(name)\">\(name)</a></li>\n"
            }

            html += """
                </ul>
            </body>
            </html>
            """
            return html
        } catch {
            return "<html><body><h1>Error reading directory</h1></body></html>"
        }
    }
}

extension WKWebView {
    func toggleInspector(_ sender: Any?) {
        guard responds(to: Selector(("_inspector"))) else { return }

        let inspector = value(forKey: "_inspector") as AnyObject
        let selector = Selector(("show:"))
        if inspector.responds(to: selector) {
            _ = inspector.perform(selector, with: nil as Any?)
        }
    }
}

// Global reference to prevent deallocation
var appDelegate: AppDelegate?

// Parse and validate arguments before launching the app
do {
    let options = try parseArguments()
    let app = NSApplication.shared
    appDelegate = AppDelegate(options: options)
    app.delegate = appDelegate
    app.run()
} catch let error as ArgumentError {
    logError(error.message)
    printUsage()
    exit(1)
}