import Foundation

public struct AgentSession: Codable, Equatable, Sendable, Identifiable {
    public enum Provider: String, Codable, Sendable {
        case codex
        case claude
    }

    public enum Source: String, Codable, Sendable {
        case cli
        case desktopApp
        case ide
        case unknown
    }

    public enum State: String, Codable, Sendable {
        case active
        case idle
    }

    public var id: String
    public var provider: Provider
    public var source: Source
    public var state: State
    public var pid: Int32?
    public var cwd: String?
    public var projectName: String?
    public var startedAt: Date?
    public var lastActivityAt: Date?
    public var transcriptPath: String?
    public var host: String

    public init(
        id: String,
        provider: Provider,
        source: Source,
        state: State,
        pid: Int32?,
        cwd: String?,
        projectName: String?,
        startedAt: Date?,
        lastActivityAt: Date?,
        transcriptPath: String?,
        host: String)
    {
        self.id = id
        self.provider = provider
        self.source = source
        self.state = state
        self.pid = pid
        self.cwd = cwd
        self.projectName = projectName
        self.startedAt = startedAt
        self.lastActivityAt = lastActivityAt
        self.transcriptPath = transcriptPath
        self.host = host
    }
}

public struct SessionScanConfig: Equatable, Sendable {
    public var activeWindow: TimeInterval
    public var fileOnlyWindow: TimeInterval

    public init(activeWindow: TimeInterval = 120, fileOnlyWindow: TimeInterval = 30 * 60) {
        self.activeWindow = activeWindow
        self.fileOnlyWindow = fileOnlyWindow
    }

    public func state(lastActivityAt: Date?, now: Date, hasLiveProcess: Bool) -> AgentSession.State {
        guard let lastActivityAt else { return hasLiveProcess ? .active : .idle }
        return now.timeIntervalSince(lastActivityAt) <= self.activeWindow ? .active : .idle
    }
}

public struct AgentProcessRecord: Equatable, Sendable {
    public let pid: Int32
    public let ppid: Int32
    public let startedAt: Date?
    public let command: String

    public init(pid: Int32, ppid: Int32, startedAt: Date?, command: String) {
        self.pid = pid
        self.ppid = ppid
        self.startedAt = startedAt
        self.command = command
    }

    public var executableBasename: String {
        let firstToken = self.command.split(whereSeparator: \ .isWhitespace).first.map(String.init) ?? ""
        let firstBasename = URL(fileURLWithPath: firstToken).lastPathComponent
        if firstBasename == "disclaimer" {
            return firstBasename
        }
        if self.command.contains("Application Support/Claude/claude-code/claude") {
            return "claude"
        }
        return firstBasename
    }
}

public enum AgentPSOutputParser {
    public static func parse(_ output: String) -> [AgentProcessRecord] {
        let formatter = DateFormatter()
        formatter.locale = Locale(identifier: "en_US_POSIX")
        formatter.dateFormat = "EEE MMM d HH:mm:ss yyyy"
        return output.split(whereSeparator: \ .isNewline).compactMap { rawLine -> AgentProcessRecord? in
            let fields = rawLine.split(maxSplits: 7, omittingEmptySubsequences: true, whereSeparator: \ .isWhitespace)
            guard fields.count == 8,
                  let pid = Int32(fields[0]),
                  let ppid = Int32(fields[1])
            else { return nil }

            let dateText = fields[2...6].joined(separator: " ")
            return AgentProcessRecord(
                pid: pid,
                ppid: ppid,
                startedAt: formatter.date(from: dateText),
                command: String(fields[7]))
        }
    }

    public static func agentProcesses(from records: [AgentProcessRecord]) -> [AgentProcessRecord] {
        let candidates = records.filter { record in
            let basename = record.executableBasename.lowercased()
            if basename == "codex" {
                let arguments = self.arguments(record.command)
                return self.isCodexAgentExecutable(record.command) &&
                    !arguments.contains("app-server") &&
                    !arguments.contains("--help") &&
                    !arguments.contains("--version")
            }
            if basename == "claude" {
                return self.isClaudeAgentExecutable(record.command) && !self.isObviousClaudeHelper(record.command)
            }
            return basename == "disclaimer" && record.command.contains("claude")
        }

        let recordsByPID = Dictionary(uniqueKeysWithValues: candidates.map { ($0.pid, $0) })
        return candidates.filter { record in
            guard record.executableBasename.lowercased() == "disclaimer" else { return true }
            return !candidates.contains { child in
                child.ppid == record.pid &&
                    child.executableBasename.lowercased() == "claude" &&
                    self.normalizedClaudeArguments(child.command) == self.normalizedClaudeArguments(record.command)
            } && recordsByPID[record.ppid] == nil
        }
    }

    public static func provider(for record: AgentProcessRecord) -> AgentSession.Provider? {
        let basename = record.executableBasename.lowercased()
        if basename == "codex" {
            return .codex
        }
        if basename == "claude" || basename == "disclaimer" {
            return .claude
        }
        return nil
    }

    public static func source(for record: AgentProcessRecord) -> AgentSession.Source {
        guard self.provider(for: record) == .claude else { return .cli }
        return record.command.contains("Application Support/Claude/claude-code") ? .desktopApp : .cli
    }

    public static func hasCodexAppServer(in records: [AgentProcessRecord]) -> Bool {
        records.contains { record in
            record.executableBasename.lowercased() == "codex" &&
                self.isCodexAgentExecutable(record.command) &&
                self.arguments(record.command).contains("app-server")
        }
    }

    private static func arguments(_ command: String) -> [String] {
        command.split(whereSeparator: \ .isWhitespace).dropFirst().map(String.init)
    }

    private static func normalizedClaudeArguments(_ command: String) -> [String] {
        let arguments = self.arguments(command)
        if let index = arguments.firstIndex(where: { URL(fileURLWithPath: $0).lastPathComponent == "claude" }) {
            return Array(arguments.suffix(from: arguments.index(after: index)))
        }
        return arguments
    }

    private static func isObviousClaudeHelper(_ command: String) -> Bool {
        let lowercased = command.lowercased()
        return lowercased.contains("--version") ||
            lowercased.contains("--help") ||
            lowercased.contains("claude-code-acp")
    }

    private static func isCodexAgentExecutable(_ command: String) -> Bool {
        let lowercased = command.lowercased()
        guard lowercased.contains(".app/") else { return true }
        return lowercased.hasPrefix("/applications/codex.app/contents/resources/codex ") ||
            lowercased.hasPrefix("/applications/codex.app/contents/resources/codex\t")
    }

    private static func isClaudeAgentExecutable(_ command: String) -> Bool {
        let lowercased = command.lowercased()
        return !lowercased.contains(".app/") || lowercased.contains("application support/claude/claude-code/claude")
    }
}

public enum LSOFCWDOutputParser {
    public static func parse(_ output: String) -> [Int32: String] {
        var result: [Int32: String] = [:]
        var currentPID: Int32?
        for line in output.split(whereSeparator: \ .isNewline).map(String.init) {
            guard let prefix = line.first else { continue }
            switch prefix {
            case "p":
                currentPID = Int32(line.dropFirst())
            case "n":
                if let currentPID {
                    result[currentPID] = String(line.dropFirst())
                }
            default:
                continue
            }
        }
        return result
    }
}

public enum ClaudeSessionProjectMapper {
    public struct Transcript: Equatable, Sendable {
        public let url: URL
        public let modifiedAt: Date

        public init(url: URL, modifiedAt: Date) {
            self.url = url
            self.modifiedAt = modifiedAt
        }
    }

    public static func escapedCWD(_ cwd: String) -> String {
        String(cwd.unicodeScalars.map { scalar in
            let value = scalar.value
            let isASCIIAlphanumeric = (48...57).contains(value) ||
                (65...90).contains(value) ||
                (97...122).contains(value)
            return isASCIIAlphanumeric ? Character(scalar) : "-"
        })
    }

    public static func projectDirectories(
        cwd: String,
        homeDirectory: URL = FileManager.default.homeDirectoryForCurrentUser,
        fileManager: FileManager = .default) -> [URL]
    {
        let standardRoot = homeDirectory
            .appendingPathComponent(".claude", isDirectory: true)
            .appendingPathComponent("projects", isDirectory: true)
        return ([standardRoot] + ClaudeDesktopProjectsLocator.roots(
            homeDirectory: homeDirectory,
            fileManager: fileManager))
            .map { $0.appendingPathComponent(self.escapedCWD(cwd), isDirectory: true) }
    }

    public static func newestTranscript(
        cwd: String,
        homeDirectory: URL = FileManager.default.homeDirectoryForCurrentUser,
        fileManager: FileManager = .default) -> (url: URL, modifiedAt: Date)?
    {
        self.transcripts(cwd: cwd, homeDirectory: homeDirectory, fileManager: fileManager).first
            .map { (url: $0.url, modifiedAt: $0.modifiedAt) }
    }

    public static func transcripts(
        cwd: String,
        homeDirectory: URL = FileManager.default.homeDirectoryForCurrentUser,
        fileManager: FileManager = .default) -> [Transcript]
    {
        self.projectDirectories(cwd: cwd, homeDirectory: homeDirectory, fileManager: fileManager)
            .flatMap { directory -> [(URL, Date)] in
                guard let files = try? fileManager.contentsOfDirectory(
                    at: directory,
                    includingPropertiesForKeys: [.contentModificationDateKey],
                    options: [.skipsHiddenFiles])
                else { return [] }
                return files.compactMap { file in
                    guard file.pathExtension == "jsonl",
                          let modifiedAt = try? file.resourceValues(
                              forKeys: [.contentModificationDateKey]).contentModificationDate
                    else { return nil }
                    return (file, modifiedAt)
                }
            }
            .sorted { $0.1 > $1.1 }
            .map { Transcript(url: $0.0, modifiedAt: $0.1) }
    }
}

public enum AgentSessionCorrelation {
    public static func newestProcessesFirst(_ processes: [AgentProcessRecord]) -> [AgentProcessRecord] {
        processes.sorted { lhs, rhs in
            let lhsDate = lhs.startedAt ?? .distantPast
            let rhsDate = rhs.startedAt ?? .distantPast
            if lhsDate != rhsDate { return lhsDate > rhsDate }
            return lhs.pid > rhs.pid
        }
    }

    public static func assignClaudeTranscripts(
        processes: [AgentProcessRecord],
        cwdByPID: [Int32: String],
        transcriptsByCWD: [String: [ClaudeSessionProjectMapper.Transcript]])
        -> [Int32: ClaudeSessionProjectMapper.Transcript]
    {
        var assigned: [Int32: ClaudeSessionProjectMapper.Transcript] = [:]
        var usedPaths = Set<String>()
        let unambiguousPIDs = self.unambiguousProcessIDs(processes: processes, cwdByPID: cwdByPID)
        for process in self.newestProcessesFirst(processes) {
            guard unambiguousPIDs.contains(process.pid),
                  let cwd = cwdByPID[process.pid],
                  let candidates = transcriptsByCWD[cwd]
            else { continue }
            let candidate = candidates.first { transcript in
                guard !usedPaths.contains(transcript.url.path) else { return false }
                guard let startedAt = process.startedAt else { return true }
                return transcript.modifiedAt >= startedAt
            }
            if let candidate {
                assigned[process.pid] = candidate
                usedPaths.insert(candidate.url.path)
            }
        }
        return assigned
    }

    public static func unambiguousProcessIDs(
        processes: [AgentProcessRecord],
        cwdByPID: [Int32: String]) -> Set<Int32>
    {
        let grouped = Dictionary(grouping: processes.compactMap { process -> (Int32, String)? in
            guard let cwd = cwdByPID[process.pid] else { return nil }
            return (process.pid, URL(fileURLWithPath: cwd).standardizedFileURL.path)
        }, by: { $0.1 })
        return Set(grouped.values.compactMap { records in
            records.count == 1 ? records[0].0 : nil
        })
    }

    public static func codexWorkingDirectoriesMatch(_ lhs: String?, _ rhs: String?) -> Bool {
        guard let lhs, let rhs else { return false }
        return URL(fileURLWithPath: lhs).standardizedFileURL.path ==
            URL(fileURLWithPath: rhs).standardizedFileURL.path
    }

    public static func fileOnlyCodexSource(
        metadataSource: AgentSession.Source,
        appServerPresent: Bool) -> AgentSession.Source
    {
        metadataSource == .unknown && appServerPresent ? .desktopApp : metadataSource
    }
}

public struct CodexRolloutMetadata: Equatable, Sendable {
    public let sessionID: String
    public let cwd: String?
    public let originator: String?
    public let source: String?

    public init(sessionID: String, cwd: String?, originator: String?, source: String?) {
        self.sessionID = sessionID
        self.cwd = cwd
        self.originator = originator
        self.source = source
    }

    public var sessionSource: AgentSession.Source {
        let value = [self.originator, self.source]
            .compactMap { $0?.lowercased() }
            .joined(separator: " ")
        if value.contains("desktop") || value.contains("app-server") {
            return .desktopApp
        }
        if value.contains("ide") || value.contains("vscode") || value.contains("cursor") || value.contains("zed") {
            return .ide
        }
        if value.contains("codex_exec") || value.contains("exec") || value.contains("cli") {
            return .cli
        }
        return .unknown
    }
}

public enum CodexRolloutFirstLineParser {
    public static func parse(_ line: String) -> CodexRolloutMetadata? {
        guard let data = line.data(using: .utf8),
              let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
              object["type"] as? String == "session_meta",
              let payload = object["payload"] as? [String: Any],
              let sessionID = (payload["session_id"] as? String) ?? (payload["id"] as? String)
        else { return nil }
        return CodexRolloutMetadata(
            sessionID: sessionID,
            cwd: payload["cwd"] as? String,
            originator: payload["originator"] as? String,
            source: payload["source"] as? String)
    }

    public static func read(from url: URL) -> CodexRolloutMetadata? {
        guard let handle = try? FileHandle(forReadingFrom: url) else { return nil }
        defer { try? handle.close() }
        var data = Data()
        while data.count < 256 * 1024 {
            guard let chunk = try? handle.read(upToCount: 4096), !chunk.isEmpty else { break }
            if let newline = chunk.firstIndex(of: 0x0A) {
                data.append(chunk.prefix(upTo: newline))
                break
            }
            data.append(chunk)
        }
        guard let line = String(data: data, encoding: .utf8) else { return nil }
        return self.parse(line)
    }

    public static func makeSession(
        metadata: CodexRolloutMetadata,
        transcriptURL: URL,
        modifiedAt: Date,
        pid: Int32? = nil,
        startedAt: Date? = nil,
        host: String,
        config: SessionScanConfig = SessionScanConfig(),
        now: Date = Date()) -> AgentSession?
    {
        guard pid != nil || now.timeIntervalSince(modifiedAt) <= config.fileOnlyWindow else { return nil }
        let cwd = metadata.cwd
        return AgentSession(
            id: metadata.sessionID,
            provider: .codex,
            source: metadata.sessionSource,
            state: config.state(lastActivityAt: modifiedAt, now: now, hasLiveProcess: pid != nil),
            pid: pid,
            cwd: cwd,
            projectName: cwd.map { URL(fileURLWithPath: $0).lastPathComponent },
            startedAt: startedAt,
            lastActivityAt: modifiedAt,
            transcriptPath: transcriptURL.path,
            host: host)
    }
}