import AppKit
import ByreAPI
import OpenAPIRuntime
import SwiftUI

typealias JSONDict = [String: (any Sendable)?]
typealias Review = Components.Schemas.Review

let taskPalette = [
    Palette.task0, Palette.task1, Palette.task2, Palette.task3, Palette.task4, Palette.task5,
    Palette.task6, Palette.task7, Palette.task8, Palette.task9, Palette.task10,
]

func str(_ d: JSONDict, _ key: String) -> String? {
    d[key] as? String
}

func int(_ d: JSONDict, _ key: String) -> Int? {
    if let i = d[key] as? Int {
        return i
    }
    return (d[key] as? Double).map { Int($0) }
}

func bool(_ d: JSONDict, _ key: String) -> Bool {
    d[key] as? Bool == true
}

func dict(_ d: JSONDict, _ key: String) -> JSONDict? {
    d[key] as? JSONDict
}

func jsString(_ v: (any Sendable)??) -> String {
    switch v {
    case .none, .some(.none):
        return "undefined"
    case .some(.some(let x)):
        if let s = x as? String {
            return s
        }
        if let b = x as? Bool {
            return b ? "true" : "false"
        }
        if let i = x as? Int {
            return String(i)
        }
        if let d = x as? Double {
            return d == d.rounded() && abs(d) < 1e15 ? String(Int(d)) : String(d)
        }
        return prettyJSON(x)
    }
}

func prettyJSON(_ v: (any Sendable)?) -> String {
    jsonText(v, indent: "  ", depth: 0)
}

func compactJSON(_ v: (any Sendable)?) -> String {
    jsonText(v, indent: nil, depth: 0)
}

private func jsonText(_ v: (any Sendable)?, indent: String?, depth: Int) -> String {
    guard let v else {
        return "null"
    }
    if let s = v as? String {
        return jsonQuote(s)
    }
    if let b = v as? Bool {
        return b ? "true" : "false"
    }
    if let i = v as? Int {
        return String(i)
    }
    if let d = v as? Double {
        return d.isFinite ? jsString(d) : "null"
    }
    let items: [String]
    let open: String
    let close: String
    if let list = v as? [(any Sendable)?] {
        items = list.map { jsonText($0, indent: indent, depth: depth + 1) }
        open = "["
        close = "]"
    } else if let d = v as? JSONDict {
        let keys = d.keys.sorted { $0.utf8.lexicographicallyPrecedes($1.utf8) }
        items = keys.map { "\(jsonQuote($0)):\(indent == nil ? "" : " ")\(jsonText(d[$0] ?? nil, indent: indent, depth: depth + 1))" }
        open = "{"
        close = "}"
    } else {
        return jsonQuote(String(describing: v))
    }
    if items.isEmpty {
        return open + close
    }
    guard let indent else {
        return open + items.joined(separator: ",") + close
    }
    let inner = "\n" + String(repeating: indent, count: depth + 1)
    return open + inner + items.joined(separator: "," + inner) + "\n" + String(repeating: indent, count: depth) + close
}

private func jsonQuote(_ s: String) -> String {
    var out = "\""
    for u in s.unicodeScalars {
        switch u {
        case "\"":
            out += "\\\""
        case "\\":
            out += "\\\\"
        case "\u{08}":
            out += "\\b"
        case "\u{0C}":
            out += "\\f"
        case "\n":
            out += "\\n"
        case "\r":
            out += "\\r"
        case "\t":
            out += "\\t"
        default:
            if u.value < 0x20 {
                let hex = String(u.value, radix: 16)
                out += "\\u" + String(repeating: "0", count: 4 - hex.count) + hex
            } else {
                out.unicodeScalars.append(u)
            }
        }
    }
    return out + "\""
}

func ago(_ date: Date) -> String {
    let seconds = Int((Date().timeIntervalSince(date)).rounded())
    if seconds < 60 {
        return "just now"
    }
    if seconds < 3600 {
        return "\(seconds / 60)m ago"
    }
    if seconds < 86400 {
        return "\(seconds / 3600)h ago"
    }
    return "\(seconds / 86400)d ago"
}

func isoText(_ date: Date) -> String {
    date.formatted(Date.ISO8601FormatStyle(includingFractionalSeconds: true))
}

func clockText(_ d: Date) -> String {
    d.formatted(Date.VerbatimFormatStyle(format: "\(hour: .twoDigits(clock: .twentyFourHour, hourCycle: .zeroBased)):\(minute: .twoDigits):\(second: .twoDigits)", timeZone: .current, calendar: .current))
}

func trimmed(_ s: String) -> String {
    s.trimmingCharacters(in: .whitespacesAndNewlines)
}

extension Store {
    func taskColor(_ taskId: String) -> Color? {
        findTask(taskId).map { taskPalette[$0.color] }
    }
}

private struct PaneAccentKey: EnvironmentKey {
    static let defaultValue = Palette.accent
}

private struct InRightPaneKey: EnvironmentKey {
    static let defaultValue = false
}

extension EnvironmentValues {
    var paneAccent: Color {
        get {
            self[PaneAccentKey.self]
        }
        set {
            self[PaneAccentKey.self] = newValue
        }
    }

    var inRightPane: Bool {
        get {
            self[InRightPaneKey.self]
        }
        set {
            self[InRightPaneKey.self] = newValue
        }
    }
}

struct Copyable<Content: View>: View {
    let text: String
    @ViewBuilder let content: Content
    @ViewState private var hover = false
    @ViewState private var copied = false

    var body: some View {
        content
            .overlay(alignment: .topTrailing) {
                if hover {
                    Button {
                        NSPasteboard.general.clearContents()
                        NSPasteboard.general.setString(text, forType: .string)
                        copied = true
                        Task {
                            try? await Task.sleep(for: .milliseconds(1500))
                            copied = false
                        }
                    } label: {
                        Image(systemName: copied ? "checkmark" : "doc.on.doc")
                            .font(.system(size: 11))
                            .foregroundStyle(Palette.muted)
                            .padding(4)
                            .background(Palette.raised, in: RoundedRectangle(cornerRadius: 4))
                    }
                    .buttonStyle(.plain)
                    .help("Copy to the clipboard")
                    .padding(4)
                }
            }
            .onHover { hover = $0 }
    }
}

struct PreBox: View {
    let text: String
    var maxHeight: CGFloat? = 320
    var size: CGFloat = 12

    var body: some View {
        Copyable(text: text) {
            ScrollView {
                Text(verbatim: text)
                    .font(Fonts.font(size))
                    .textSelection(.enabled)
                    .frame(maxWidth: .infinity, alignment: .leading)
                    .padding(.horizontal, 8)
                    .padding(.vertical, 6)
            }
            .scrollBounceBehavior(.basedOnSize)
            .frame(maxHeight: maxHeight)
            .fixedSize(horizontal: false, vertical: true)
            .background(Palette.raised, in: RoundedRectangle(cornerRadius: 6))
            .overlay(RoundedRectangle(cornerRadius: 6).stroke(Palette.border))
        }
    }
}

struct Spinner: View {
    var color: Color
    @Environment(\.font) private var font
    @Environment(\.fontResolutionContext) private var fontContext

    var body: some View {
        Text("⠋")
            .hidden()
            .overlay {
                SpinnerGlyphs(font: (font ?? .body).resolve(in: fontContext).ctFont, color: color)
                    .allowsHitTesting(false)
            }
    }
}

private struct SpinnerGlyphs: NSViewRepresentable {
    let font: CTFont
    let color: Color

    func makeNSView(context: Context) -> SpinnerView {
        SpinnerView()
    }

    func updateNSView(_ v: SpinnerView, context: Context) {
        v.font = font
        v.color = color.resolve(in: context.environment).cgColor
        v.needsLayout = true
    }
}

private final class SpinnerView: NSView {
    private struct Key: Equatable {
        let size: CGSize
        let scale: CGFloat
        let font: CTFont
        let color: CGColor
    }

    private static let frames = Array("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏")
    var font: CTFont?
    var color: CGColor?
    private let glyph = CALayer()
    private var drawn: Key?

    override init(frame: NSRect) {
        super.init(frame: frame)
        wantsLayer = true
        layer?.addSublayer(glyph)
    }

    required init?(coder: NSCoder) {
        fatalError("init(coder:) is not supported")
    }

    override func viewDidChangeBackingProperties() {
        super.viewDidChangeBackingProperties()
        needsLayout = true
    }

    override func layout() {
        super.layout()
        guard let font, let color, let window, bounds.width > 0, bounds.height > 0 else {
            return
        }
        let key = Key(size: bounds.size, scale: window.backingScaleFactor, font: font, color: color)
        if key == drawn {
            return
        }
        drawn = key
        let images = Self.frames.map { render(String($0), key) }
        CATransaction.begin()
        CATransaction.setDisableActions(true)
        glyph.frame = bounds
        glyph.contentsScale = key.scale
        glyph.contents = images[0]
        let spin = CAKeyframeAnimation(keyPath: "contents")
        spin.values = images
        spin.keyTimes = (0...images.count).map { NSNumber(value: Double($0) / Double(images.count)) }
        spin.calculationMode = .discrete
        spin.duration = 0.08 * Double(images.count)
        spin.repeatCount = .infinity
        spin.isRemovedOnCompletion = false
        glyph.add(spin, forKey: "spin")
        CATransaction.commit()
    }

    private func render(_ s: String, _ key: Key) -> CGImage {
        let ctx = CGContext(data: nil, width: Int(ceil(key.size.width * key.scale)), height: Int(ceil(key.size.height * key.scale)), bitsPerComponent: 8, bytesPerRow: 0, space: CGColorSpace(name: CGColorSpace.sRGB)!, bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue)!
        ctx.scaleBy(x: key.scale, y: key.scale)
        let attrs: [NSAttributedString.Key: Any] = [
            NSAttributedString.Key(kCTFontAttributeName as String): key.font,
            NSAttributedString.Key(kCTForegroundColorAttributeName as String): key.color,
        ]
        let line = CTLineCreateWithAttributedString(NSAttributedString(string: s, attributes: attrs))
        var ascent: CGFloat = 0
        var descent: CGFloat = 0
        let width = CTLineGetTypographicBounds(line, &ascent, &descent, nil)
        ctx.textPosition = CGPoint(x: (key.size.width - width) / 2, y: (key.size.height - ascent - descent) / 2 + descent)
        CTLineDraw(line, ctx)
        return ctx.makeImage()!
    }
}

struct Badge: View {
    let count: Int

    var body: some View {
        Text("\(count)")
            .font(Fonts.font(11, weight: 700))
            .foregroundStyle(Palette.danger)
            .padding(.horizontal, 7)
            .background(Palette.dangerTint, in: Capsule())
    }
}

struct Muted: View {
    let text: String

    var body: some View {
        Text(text)
            .foregroundStyle(Palette.muted)
            .padding(32)
            .frame(maxWidth: .infinity)
            .multilineTextAlignment(.center)
    }
}

struct WebButtonStyle: ButtonStyle {
    var primary = false
    var danger = false

    func makeBody(configuration: ButtonStyleConfiguration) -> some View {
        WebButton(configuration: configuration, primary: primary, danger: danger)
    }
}

private struct WebButton: View {
    let configuration: ButtonStyleConfiguration
    let primary: Bool
    let danger: Bool
    @Environment(\.isEnabled) private var enabled
    @ViewState private var hover = false

    var body: some View {
        let fill = danger ? Palette.danger : Palette.accent
        configuration.label
            .font(Fonts.font(13, weight: primary ? 700 : 400))
            .foregroundStyle(primary ? Palette.bg : danger ? Palette.danger : Palette.text)
            .padding(.horizontal, 12)
            .padding(.vertical, 4)
            .background(primary ? fill : Palette.raised, in: RoundedRectangle(cornerRadius: 6))
            .overlay(RoundedRectangle(cornerRadius: 6).stroke(primary ? fill : hover && enabled ? Palette.muted : Palette.border))
            .opacity(enabled ? (configuration.isPressed ? 0.8 : 1) : 0.45)
            .contentShape(Rectangle())
            .onHover { hover = $0 }
    }
}

struct SmallLinkButtonStyle: ButtonStyle {
    var color = Palette.accent
    @Environment(\.isEnabled) private var enabled

    func makeBody(configuration: ButtonStyleConfiguration) -> some View {
        configuration.label
            .font(Fonts.font(11))
            .foregroundStyle(color)
            .padding(.horizontal, 6)
            .overlay(RoundedRectangle(cornerRadius: 4).stroke(Palette.border))
            .opacity(enabled ? 1 : 0.45)
            .contentShape(Rectangle())
    }
}

struct FieldStyle: ViewModifier {
    var accent: Color? = nil
    var focused = false

    func body(content: Content) -> some View {
        content
            .textFieldStyle(.plain)
            .padding(.horizontal, 10)
            .padding(.vertical, 6)
            .background(Palette.raised, in: RoundedRectangle(cornerRadius: 6))
            .overlay(RoundedRectangle(cornerRadius: 6).stroke(focused ? (accent ?? Palette.accent) : (accent ?? Palette.border)))
    }
}

struct HeaderBar: ViewModifier {
    func body(content: Content) -> some View {
        content
            .padding(.horizontal, 16)
            .padding(.vertical, 8)
            .frame(maxWidth: .infinity, alignment: .leading)
            .overlay(alignment: .bottom) {
                Rectangle().fill(Palette.border).frame(height: 1)
            }
    }
}

struct RangeTabButton: View {
    let label: String
    let active: Bool
    var help = ""
    let action: () -> Void
    @ViewState private var hover = false

    var body: some View {
        Button(action: action) {
            Text(label)
                .font(Fonts.font(12))
                .foregroundStyle(active || hover ? Palette.text : Palette.muted)
                .padding(.horizontal, 6)
                .padding(.top, 2)
                .padding(.bottom, 3)
                .overlay(alignment: .bottom) {
                    Rectangle().fill(active ? Palette.accent : .clear).frame(height: 2)
                }
                .contentShape(Rectangle())
        }
        .buttonStyle(.plain)
        .help(help)
        .onHover { hover = $0 }
    }
}

struct EmptyText: View {
    let text: String
    var error = false

    var body: some View {
        VStack {
            Text(text)
                .foregroundStyle(error ? Palette.danger : Palette.muted)
                .multilineTextAlignment(.center)
                .textSelection(.enabled)
                .padding(32)
                .frame(maxWidth: .infinity)
            Spacer(minLength: 0)
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
    }
}

struct StateDot: View {
    let filled: Color?

    var body: some View {
        Group {
            if let filled {
                Circle().fill(filled)
            } else {
                Circle().strokeBorder(Palette.muted, lineWidth: 1.5)
            }
        }
        .frame(width: 8, height: 8)
    }
}

struct StateMark: View {
    let state: TaskState
    let color: Color

    var body: some View {
        Group {
            switch state.kind {
            case .working, .merging:
                Spinner(color: color)
            case .answer:
                StateDot(filled: Palette.warn)
            case .error:
                StateDot(filled: Palette.danger)
            default:
                StateDot(filled: nil)
            }
        }
        .help(state.title)
    }
}

enum PatchLine {
    case hunk, add, del, meta, ctx

    init(_ l: String) {
        self = l.hasPrefix("@@") ? .hunk : l.hasPrefix("+") ? .add : l.hasPrefix("-") ? .del : l.hasPrefix("\\") ? .meta : .ctx
    }

    var background: Color {
        switch self {
        case .hunk: Palette.surface
        case .add: Palette.ok.opacity(0.14)
        case .del: Palette.danger.opacity(0.14)
        default: .clear
        }
    }

    var color: Color {
        self == .hunk || self == .meta ? Palette.muted : Palette.text
    }
}

struct StretchColumn: Layout {
    var minWidth: CGFloat = 0

    private func width(_ proposal: ProposedViewSize, _ subviews: Subviews) -> CGFloat {
        max(minWidth, proposal.width ?? 0, subviews.map { $0.sizeThatFits(.unspecified).width }.max() ?? 0)
    }

    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
        let w = width(ProposedViewSize(width: nil, height: nil), subviews)
        let h = subviews.reduce(0) { $0 + $1.sizeThatFits(ProposedViewSize(width: w, height: nil)).height }
        return CGSize(width: w, height: h)
    }

    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
        var y = bounds.minY
        for sub in subviews {
            let h = sub.sizeThatFits(ProposedViewSize(width: bounds.width, height: nil)).height
            sub.place(at: CGPoint(x: bounds.minX, y: y), proposal: ProposedViewSize(width: bounds.width, height: h))
            y += h
        }
    }
}

struct TrailingBubble: Layout {
    var fraction: CGFloat = 0.85

    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
        let width = proposal.width ?? 600
        let size = subviews[0].sizeThatFits(ProposedViewSize(width: width * fraction, height: nil))
        return CGSize(width: width, height: size.height)
    }

    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
        let size = subviews[0].sizeThatFits(ProposedViewSize(width: bounds.width * fraction, height: nil))
        subviews[0].place(at: CGPoint(x: bounds.maxX - size.width, y: bounds.minY), proposal: ProposedViewSize(size))
    }
}

struct FitWidth: Layout {
    let natural: CGSize

    private func scaled(_ width: CGFloat?) -> CGSize {
        let w = width ?? natural.width
        let scale = natural.width > 0 ? min(1, w / natural.width) : 1
        return CGSize(width: natural.width * scale, height: natural.height * scale)
    }

    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
        scaled(proposal.width)
    }

    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
        let size = scaled(bounds.width)
        subviews[0].place(at: bounds.origin, proposal: ProposedViewSize(size))
    }
}

struct FlowLayout: Layout {
    var spacing: CGFloat = 6

    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
        let rows = arrange(proposal.width ?? .infinity, subviews)
        let height = rows.last.map { $0.y + $0.height } ?? 0
        let width = rows.map(\.width).max() ?? 0
        return CGSize(width: proposal.width ?? width, height: height)
    }

    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
        for row in arrange(bounds.width, subviews) {
            for (i, x) in zip(row.items, row.xs) {
                subviews[i].place(at: CGPoint(x: bounds.minX + x, y: bounds.minY + row.y), proposal: .unspecified)
            }
        }
    }

    private struct Row {
        var items: [Int] = []
        var xs: [CGFloat] = []
        var y: CGFloat = 0
        var width: CGFloat = 0
        var height: CGFloat = 0
    }

    private func arrange(_ maxWidth: CGFloat, _ subviews: Subviews) -> [Row] {
        var rows: [Row] = []
        var row = Row()
        var y: CGFloat = 0
        for (i, sub) in subviews.enumerated() {
            let size = sub.sizeThatFits(.unspecified)
            if !row.items.isEmpty && row.width + spacing + size.width > maxWidth {
                rows.append(row)
                y += row.height + spacing
                row = Row(y: y)
            }
            let x = row.items.isEmpty ? 0 : row.width + spacing
            row.items.append(i)
            row.xs.append(x)
            row.width = x + size.width
            row.height = max(row.height, size.height)
        }
        if !row.items.isEmpty {
            rows.append(row)
        }
        return rows
    }
}

let overlayShadow = Color(nsColor: NSColor(name: nil) { appearance in
    appearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua ? NSColor(srgbRed: 0, green: 0, blue: 0, alpha: 0.5) : NSColor(srgbRed: 16 / 255, green: 24 / 255, blue: 40 / 255, alpha: 0.18)
})