import SwiftUI

enum JSON: Decodable {
    case string(String)
    case number(Double)
    case bool(Bool)
    case object([String: JSON])
    case array([JSON])
    case null

    init(from decoder: Decoder) throws {
        let c = try decoder.singleValueContainer()
        if c.decodeNil() {
            self = .null
        } else if let v = try? c.decode(Bool.self) {
            self = .bool(v)
        } else if let v = try? c.decode(Double.self) {
            self = .number(v)
        } else if let v = try? c.decode(String.self) {
            self = .string(v)
        } else if let v = try? c.decode([JSON].self) {
            self = .array(v)
        } else {
            self = .object(try c.decode([String: JSON].self))
        }
    }

    subscript(key: String) -> JSON? {
        if case .object(let o) = self {
            return o[key]
        }
        return nil
    }

    var string: String? {
        if case .string(let s) = self {
            return s
        }
        return nil
    }
}

struct Event: Decodable {
    let seq: Int64
    let kind: String
    let payload: JSON
}

struct Row: Identifiable {
    let id: Int64
    let kind: String
    var text: String
    var tools: [String] = []
}

func buildRows(_ events: [Event]) -> [Row] {
    var rows: [Row] = []
    for e in events {
        switch e.kind {
        case "user.message", "agent.message", "agent.thinking":
            rows.append(Row(id: e.seq, kind: e.kind, text: e.payload["text"]?.string ?? ""))
        case "agent.tool_call":
            let name = e.payload["name"]?.string ?? "?"
            let input = e.payload["input"]
            let detail = input?["file_path"]?.string ?? input?["command"]?.string ?? input?["pattern"]?.string ?? ""
            let line = "\(name) \(detail)"
            if rows.last?.kind == "tools" {
                rows[rows.count - 1].tools.append(line)
            } else {
                rows.append(Row(id: e.seq, kind: "tools", text: "", tools: [line]))
            }
        default:
            continue
        }
    }
    return rows
}

func toolSummary(_ tools: [String]) -> String {
    var order: [String] = []
    var counts: [String: Int] = [:]
    for t in tools {
        let name = String(t.split(separator: " ").first ?? "")
        if counts[name] == nil {
            order.append(name)
        }
        counts[name, default: 0] += 1
    }
    return order.map { counts[$0]! > 1 ? "\($0) ×\(counts[$0]!)" : $0 }.joined(separator: ", ")
}

struct RowView: View {
    let row: Row
    @ViewState private var open = false

    var body: some View {
        switch row.kind {
        case "tools":
            VStack(alignment: .leading, spacing: 2) {
                Button((open ? "▾ " : "▸ ") + toolSummary(row.tools)) {
                    open.toggle()
                }
                .buttonStyle(.plain)
                .foregroundStyle(.secondary)
                if open {
                    ForEach(Array(row.tools.enumerated()), id: \.offset) { _, t in
                        Text(t)
                            .foregroundStyle(.secondary)
                            .textSelection(.enabled)
                    }
                }
            }
        case "user.message":
            Text(markdown(row.text))
                .textSelection(.enabled)
                .padding(8)
                .frame(maxWidth: .infinity, alignment: .leading)
                .background(Color.accentColor.opacity(0.12))
        case "agent.thinking":
            Text(row.text)
                .italic()
                .foregroundStyle(.secondary)
                .textSelection(.enabled)
        default:
            Text(markdown(row.text))
                .textSelection(.enabled)
                .frame(maxWidth: .infinity, alignment: .leading)
        }
    }

    private func markdown(_ s: String) -> AttributedString {
        (try? AttributedString(markdown: s, options: .init(interpretedSyntax: .inlineOnlyPreservingWhitespace))) ?? AttributedString(s)
    }
}

enum Container: String, CaseIterable {
    case lazyVStack = "ScrollView + LazyVStack"
    case list = "List"
}

struct TranscriptSpike: View {
    @Environment(Server.self) private var server
    @ViewState private var all: [Row] = []
    @ViewState private var shown = 0
    @ViewState private var container = Container.lazyVStack
    @ViewState private var playing = false
    @ViewState private var streaming = false
    @ViewState private var pinned = true
    @ViewState private var distance: CGFloat = 0
    @ViewState private var tick = 0
    @ViewState private var position = ScrollPosition(edge: .bottom)
    @ViewState private var events = 0
    @ViewState private var loadTime = ""

    private var rows: ArraySlice<Row> {
        all.prefix(shown)
    }

    var body: some View {
        VStack(alignment: .leading) {
            HStack {
                Picker("", selection: $container) {
                    ForEach(Container.allCases, id: \.self) { c in
                        Text(c.rawValue).tag(c)
                    }
                }
                .pickerStyle(.segmented)
                .frame(width: 320)
                Toggle("Play held-back rows", isOn: $playing)
                Toggle("Stream a message", isOn: $streaming)
                Text("\(events) events, \(shown)/\(all.count) rows \(loadTime) · \(pinned ? "stuck to bottom" : "scrolled up") · \(Int(distance)) pt from bottom")
                    .foregroundStyle(.secondary)
            }
            switch container {
            case .lazyVStack:
                ScrollView {
                    LazyVStack(alignment: .leading, spacing: 10) {
                        ForEach(rows) { r in
                            RowView(row: r)
                        }
                    }
                    .scrollTargetLayout()
                    .padding(.horizontal, 8)
                }
                .scrollPosition($position)
                .defaultScrollAnchor(.bottom)
                .onScrollGeometryChange(for: CGFloat.self) { g in
                    g.contentSize.height - g.visibleRect.maxY
                } action: { _, d in
                    distance = d
                    pinned = d <= 80
                }
                .onChange(of: tick) {
                    if pinned {
                        position.scrollTo(edge: .bottom)
                    }
                }
            case .list:
                ScrollViewReader { proxy in
                    List(rows) { r in
                        RowView(row: r)
                    }
                    .onScrollGeometryChange(for: CGFloat.self) { g in
                        g.contentSize.height - g.visibleRect.maxY
                    } action: { _, d in
                        distance = d
                        pinned = d <= 80
                    }
                    .onChange(of: tick) {
                        if pinned, let last = rows.last {
                            proxy.scrollTo(last.id, anchor: .bottom)
                        }
                    }
                    .onAppear {
                        if let last = rows.last {
                            proxy.scrollTo(last.id, anchor: .bottom)
                        }
                    }
                }
            }
        }
        .task {
            await load()
        }
        .task(id: playing) {
            while playing && shown < all.count {
                shown += 1
                tick += 1
                try? await Task.sleep(for: .milliseconds(150))
            }
        }
        .task(id: streaming) {
            await stream()
        }
    }

    private func load() async {
        guard !server.taskId.isEmpty else {
            return
        }
        let start = Date()
        var got: [Event] = []
        var after: Int64 = 0
        do {
            while true {
                let page = try await server.get([Event].self, "/api/tasks/\(server.taskId)/events", [URLQueryItem(name: "after", value: String(after)), URLQueryItem(name: "limit", value: "1000")])
                got += page
                if page.count < 1000 {
                    break
                }
                after = page.last!.seq
            }
        } catch {
            server.log("transcript: \(error)")
            return
        }
        events = got.count
        all = buildRows(got)
        shown = all.count > 200 ? all.count - 100 : all.count
        loadTime = String(format: "in %.2fs", Date().timeIntervalSince(start))
        tick += 1
    }

    private func stream() async {
        guard streaming, let source = all.filter({ $0.kind == "agent.message" }).max(by: { $0.text.count < $1.text.count }) else {
            return
        }
        let id = (all.last?.id ?? 0) + 1_000_000
        all.insert(Row(id: id, kind: "agent.message", text: ""), at: shown)
        shown += 1
        let index = shown - 1
        for word in source.text.split(separator: " ", omittingEmptySubsequences: false) {
            if !streaming {
                break
            }
            all[index].text += (all[index].text.isEmpty ? "" : " ") + word
            tick += 1
            try? await Task.sleep(for: .milliseconds(30))
        }
        streaming = false
    }
}