import Foundation
import Markdown
import SwiftUI

// MARK: - hapiOpenURL environment

/// Link-open handler for everything the markdown renderer emits: regular
/// URLs (after `HrefPolicy` filtering) and `hapi-file://?path=&line=` file
/// references (decode with `FilePathLink(url:)`). The app decides what to do
/// (SFSafariViewController, session file viewer, confirm sheet for
/// `.confirmFirst` schemes); HapiUI never opens anything by itself.
public struct HapiOpenURLAction: Sendable {
    public typealias Handler = @Sendable (URL) -> Void

    private let handler: Handler

    public init(handler: @escaping Handler) {
        self.handler = handler
    }

    public func callAsFunction(_ url: URL) {
        handler(url)
    }
}

private struct HapiOpenURLKey: EnvironmentKey {
    static let defaultValue = HapiOpenURLAction { _ in }
}

public extension EnvironmentValues {
    /// Handler invoked for links tapped inside HapiUI markdown content.
    /// Defaults to a no-op; the app must install its own handler.
    var hapiOpenURL: HapiOpenURLAction {
        get { self[HapiOpenURLKey.self] }
        set { self[HapiOpenURLKey.self] = newValue }
    }
}

// MARK: - Block model

public struct MarkdownTableModel: Equatable, Sendable {
    public enum Alignment: Equatable, Sendable {
        case left
        case center
        case right
    }

    public var columnAlignments: [Alignment?]
    public var header: [AttributedString]
    public var rows: [[AttributedString]]

    public init(columnAlignments: [Alignment?], header: [AttributedString], rows: [[AttributedString]]) {
        self.columnAlignments = columnAlignments
        self.header = header
        self.rows = rows
    }
}

public struct MarkdownListModel: Equatable, Sendable {
    public struct Item: Equatable, Sendable {
        /// nil for plain list items; true/false for GFM task list items.
        public var checkbox: Bool?
        public var blocks: [MarkdownBlockNode]

        public init(checkbox: Bool? = nil, blocks: [MarkdownBlockNode]) {
            self.checkbox = checkbox
            self.blocks = blocks
        }
    }

    public var isOrdered: Bool
    public var startIndex: Int
    public var items: [Item]

    public init(isOrdered: Bool, startIndex: Int = 1, items: [Item]) {
        self.isOrdered = isOrdered
        self.startIndex = startIndex
        self.items = items
    }
}

/// Renderer-ready markdown block tree. Built from source text by
/// `MarkdownBlockTree.build(from:)`; pure data, so the conversion is unit
/// testable without rendering any view.
public indirect enum MarkdownBlockNode: Equatable, Sendable {
    case paragraph(AttributedString)
    case heading(level: Int, AttributedString)
    case codeBlock(language: String?, code: String)
    case blockquote([MarkdownBlockNode])
    case list(MarkdownListModel)
    case table(MarkdownTableModel)
    case thematicBreak
    /// Markdown image reference. Chat images arrive via tool results, not
    /// markdown, so this renders as a placeholder link row.
    case image(alt: String, destination: String?)
}

// MARK: - Block tree builder

public enum MarkdownBlockTree {
    /// Pre-processes the raw source (table repair + indented-code disable,
    /// mirroring the web's remark plugin order), parses it with
    /// swift-markdown (GFM tables/strikethrough/task lists; smart-quote
    /// substitution disabled to match remark output), and folds the tree
    /// into renderer-ready blocks.
    public static func build(from markdown: String) -> [MarkdownBlockNode] {
        let prepared = MarkdownTransforms.disableIndentedCode(
            MarkdownTransforms.repairTables(markdown)
        )
        let document = Document(parsing: prepared, options: [.disableSmartOpts])
        var builder = BlockBuilder()
        return builder.visit(document)
    }
}

struct BlockBuilder: MarkupVisitor {
    typealias Result = [MarkdownBlockNode]

    mutating func defaultVisit(_ markup: Markup) -> [MarkdownBlockNode] {
        // Unknown containers (custom blocks, directives): flatten children.
        markup.children.flatMap { visit($0) }
    }

    mutating func visitDocument(_ document: Document) -> [MarkdownBlockNode] {
        document.children.flatMap { visit($0) }
    }

    mutating func visitParagraph(_ paragraph: Paragraph) -> [MarkdownBlockNode] {
        let children = Array(paragraph.children)
        if children.count == 1, let image = children[0] as? Markdown.Image {
            var inline = InlineBuilder(insideLink: true)
            let alt = String(inline.content(of: image).characters)
            return [.image(alt: alt, destination: image.source)]
        }
        var inline = InlineBuilder()
        return [.paragraph(inline.content(of: paragraph))]
    }

    mutating func visitHeading(_ heading: Heading) -> [MarkdownBlockNode] {
        var inline = InlineBuilder()
        let level = min(max(heading.level, 1), 6)
        return [.heading(level: level, inline.content(of: heading))]
    }

    mutating func visitCodeBlock(_ codeBlock: CodeBlock) -> [MarkdownBlockNode] {
        var code = codeBlock.code
        if code.hasSuffix("\n") {
            code = String(code.dropLast())
        }
        // The fence info string may carry extra tokens ("swift lineNumbers");
        // only the first token is the language.
        var language: String? = nil
        if let info = codeBlock.language {
            let token = info.split(separator: " ").first.map(String.init) ?? info
            language = token.isEmpty ? nil : token
        }
        return [.codeBlock(language: language, code: code)]
    }

    mutating func visitHTMLBlock(_ html: HTMLBlock) -> [MarkdownBlockNode] {
        // The web drops raw HTML (react-markdown default). Showing the
        // literal source is the conservative visible choice on iOS.
        var raw = html.rawHTML
        if raw.hasSuffix("\n") {
            raw = String(raw.dropLast())
        }
        return [.paragraph(AttributedString(raw))]
    }

    mutating func visitBlockQuote(_ blockQuote: BlockQuote) -> [MarkdownBlockNode] {
        [.blockquote(blockQuote.children.flatMap { visit($0) })]
    }

    mutating func visitUnorderedList(_ unorderedList: UnorderedList) -> [MarkdownBlockNode] {
        [.list(makeList(from: unorderedList, ordered: false, start: 1))]
    }

    mutating func visitOrderedList(_ orderedList: OrderedList) -> [MarkdownBlockNode] {
        [.list(makeList(from: orderedList, ordered: true, start: Int(clamping: orderedList.startIndex)))]
    }

    mutating func visitThematicBreak(_ thematicBreak: ThematicBreak) -> [MarkdownBlockNode] {
        [.thematicBreak]
    }

    mutating func visitTable(_ table: Markdown.Table) -> [MarkdownBlockNode] {
        let columnCount = max(table.maxColumnCount, 1)
        var inline = InlineBuilder()

        var header: [AttributedString] = []
        for cell in table.head.cells {
            header.append(inline.content(of: cell))
        }
        while header.count < columnCount {
            header.append(AttributedString())
        }

        var rows: [[AttributedString]] = []
        for row in table.body.rows {
            var cells: [AttributedString] = []
            for cell in row.cells {
                cells.append(inline.content(of: cell))
            }
            while cells.count < columnCount {
                cells.append(AttributedString())
            }
            rows.append(cells)
        }

        var alignments: [MarkdownTableModel.Alignment?] = table.columnAlignments.map { alignment -> MarkdownTableModel.Alignment? in
            switch alignment {
            case .left: return .left
            case .center: return .center
            case .right: return .right
            case nil: return nil
            }
        }
        while alignments.count < columnCount {
            alignments.append(nil)
        }

        return [.table(MarkdownTableModel(
            columnAlignments: alignments,
            header: header,
            rows: rows
        ))]
    }

    private mutating func makeList(
        from container: some ListItemContainer,
        ordered: Bool,
        start: Int
    ) -> MarkdownListModel {
        var items: [MarkdownListModel.Item] = []
        for item in container.listItems {
            let checkbox: Bool? = item.checkbox.map { $0 == .checked }
            let blocks = item.children.flatMap { visit($0) }
            items.append(MarkdownListModel.Item(checkbox: checkbox, blocks: blocks))
        }
        return MarkdownListModel(isOrdered: ordered, startIndex: start, items: items)
    }
}

// MARK: - Inline builder

/// Folds inline markup into an `AttributedString`:
/// - bold / italic / strikethrough / inline code via
///   `InlinePresentationIntent` (theme styling is applied at render time),
/// - links via the `.link` attribute after `HrefPolicy` filtering (blocked
///   schemes render as plain text; scheme-less hrefs only survive as
///   workspace file links — anything else is inert, matching the web's
///   fail-closed rule),
/// - bare `scheme://` URLs and workspace file paths in plain text are
///   auto-linked (`MarkdownTransforms.detectAutolinkRanges` /
///   `detectFilePathRanges`); file references use `hapi-file://` URLs.
struct InlineBuilder: MarkupVisitor {
    typealias Result = AttributedString

    /// Inside a link (or alt text) no nested autolinking happens — mirrors
    /// the web plugin skipping `link` parents.
    var insideLink: Bool

    init(insideLink: Bool = false) {
        self.insideLink = insideLink
    }

    /// Concatenated visit of all children.
    mutating func content(of markup: Markup) -> AttributedString {
        var output = AttributedString()
        for child in markup.children {
            output += visit(child)
        }
        return output
    }

    mutating func defaultVisit(_ markup: Markup) -> AttributedString {
        content(of: markup)
    }

    mutating func visitText(_ text: Markdown.Text) -> AttributedString {
        insideLink ? AttributedString(text.string) : Self.linkified(text.string)
    }

    mutating func visitSoftBreak(_ softBreak: SoftBreak) -> AttributedString {
        AttributedString(" ")
    }

    mutating func visitLineBreak(_ lineBreak: LineBreak) -> AttributedString {
        AttributedString("\n")
    }

    mutating func visitInlineHTML(_ inlineHTML: InlineHTML) -> AttributedString {
        AttributedString(inlineHTML.rawHTML)
    }

    mutating func visitSymbolLink(_ symbolLink: SymbolLink) -> AttributedString {
        var piece = AttributedString(symbolLink.destination ?? "")
        piece.inlinePresentationIntent = .code
        return piece
    }

    mutating func visitEmphasis(_ emphasis: Emphasis) -> AttributedString {
        Self.addingIntent(.emphasized, to: content(of: emphasis))
    }

    mutating func visitStrong(_ strong: Strong) -> AttributedString {
        Self.addingIntent(.stronglyEmphasized, to: content(of: strong))
    }

    mutating func visitStrikethrough(_ strikethrough: Strikethrough) -> AttributedString {
        Self.addingIntent(.strikethrough, to: content(of: strikethrough))
    }

    mutating func visitInlineCode(_ inlineCode: InlineCode) -> AttributedString {
        var piece = AttributedString(inlineCode.code)
        piece.inlinePresentationIntent = .code
        if !insideLink,
           let fileLink = MarkdownTransforms.filePathLink(forInlineCode: inlineCode.code),
           let url = fileLink.url {
            piece.link = url
        }
        return piece
    }

    mutating func visitLink(_ link: Markdown.Link) -> AttributedString {
        let wasInsideLink = insideLink
        insideLink = true
        var label = content(of: link)
        insideLink = wasInsideLink

        var target = link.destination ?? ""
        var trailing: AttributedString? = nil

        // Angle autolinks (`<https://x，>`) have text == destination; strip
        // trailing CJK punctuation out of the link (remark-strip-cjk-autolink
        // parity — explicit `[text](url)` links are never modified).
        let plain = String(label.characters)
        if !target.isEmpty, plain == target,
           let split = MarkdownTransforms.splitTrailingCJKPunctuation(fromAutolink: target) {
            target = split.url
            label = AttributedString(split.url)
            trailing = AttributedString(split.trailing)
        }

        var result = label
        if target.isEmpty {
            // No destination — plain text.
        } else if !HrefPolicy.hasScheme(target) {
            // Scheme-less: only repo-relative workspace files become links;
            // everything else path-like renders inert (web #1452 rule; SPA
            // routes have no iOS equivalent).
            if let fileLink = MarkdownTransforms.fileLinkTarget(forExplicitHref: target),
               let url = fileLink.url {
                result.link = url
            }
        } else {
            switch HrefPolicy.classify(target) {
            case .blocked:
                break
            case .allowed, .confirmFirst:
                if let url = Self.makeURL(from: target) {
                    result.link = url
                }
            }
        }

        if let trailing {
            result += trailing
        }
        return result
    }

    mutating func visitImage(_ image: Markdown.Image) -> AttributedString {
        let wasInsideLink = insideLink
        insideLink = true
        let altText = content(of: image)
        insideLink = wasInsideLink

        let alt = String(altText.characters)
        let label = alt.isEmpty ? (image.source ?? "image") : alt
        var piece = AttributedString(label)
        if let source = image.source,
           HrefPolicy.hasScheme(source),
           HrefPolicy.classify(source) != .blocked,
           let url = Self.makeURL(from: source) {
            piece.link = url
        }
        return piece
    }

    // MARK: helpers

    static func addingIntent(
        _ intent: InlinePresentationIntent,
        to attributed: AttributedString
    ) -> AttributedString {
        // Rebuild run-by-run instead of mutating in place: attribute writes
        // count as mutations and would invalidate the run iterator.
        var output = AttributedString()
        for run in attributed.runs {
            var piece = AttributedString(attributed[run.range])
            let existing = run.inlinePresentationIntent ?? []
            piece.inlinePresentationIntent = existing.union(intent)
            output.append(piece)
        }
        return output
    }

    static func linkified(_ string: String) -> AttributedString {
        var output = AttributedString()
        var cursor = string.startIndex
        for hit in MarkdownTransforms.detectAutolinkRanges(in: string) {
            if hit.range.lowerBound > cursor {
                output += filePathLinked(String(string[cursor..<hit.range.lowerBound]))
            }
            var piece = AttributedString(hit.url)
            if HrefPolicy.classify(hit.url) != .blocked, let url = makeURL(from: hit.url) {
                piece.link = url
            }
            output += piece
            cursor = hit.range.upperBound
        }
        if cursor < string.endIndex {
            output += filePathLinked(String(string[cursor...]))
        }
        return output
    }

    static func filePathLinked(_ string: String) -> AttributedString {
        let hits = MarkdownTransforms.detectFilePathRanges(in: string)
        guard !hits.isEmpty else { return AttributedString(string) }
        var output = AttributedString()
        var cursor = string.startIndex
        for (range, link) in hits {
            if range.lowerBound > cursor {
                output += AttributedString(String(string[cursor..<range.lowerBound]))
            }
            var piece = AttributedString(String(string[range]))
            if let url = link.url {
                piece.link = url
            }
            output += piece
            cursor = range.upperBound
        }
        if cursor < string.endIndex {
            output += AttributedString(String(string[cursor...]))
        }
        return output
    }

    static func makeURL(from string: String) -> URL? {
        if let url = URL(string: string) { return url }
        guard let encoded = string.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) else {
            return nil
        }
        return URL(string: encoded)
    }
}

// MARK: - Theme application

/// Applies palette-dependent styling to a built inline string: inline-code
/// runs get the monospaced font + chip colors, link runs get the link color
/// and underline. Bold/italic/strikethrough render natively from
/// `InlinePresentationIntent`.
func hapiStyledText(_ source: AttributedString, theme: HapiTheme, typography: HapiTypography) -> AttributedString {
    var output = AttributedString()
    for run in source.runs {
        var piece = AttributedString(source[run.range])
        if let intent = run.inlinePresentationIntent, intent.contains(.code) {
            piece[AttributeScopes.SwiftUIAttributes.FontAttribute.self] = typography.inlineCodeFont
            piece[AttributeScopes.SwiftUIAttributes.ForegroundColorAttribute.self] = theme.inlineCodeForeground
            piece[AttributeScopes.SwiftUIAttributes.BackgroundColorAttribute.self] = theme.inlineCodeBackground
        }
        if run.link != nil {
            piece[AttributeScopes.SwiftUIAttributes.ForegroundColorAttribute.self] = theme.link
            piece[AttributeScopes.SwiftUIAttributes.UnderlineStyleAttribute.self] = .single
        }
        output.append(piece)
    }
    return output
}

// MARK: - Views

/// SwiftUI markdown renderer. Parses in `init` (cheap enough for chat-sized
/// content; streaming updates re-parse on each source change) and renders the
/// block tree. Link taps — including `hapi-file://` workspace references —
/// are delivered to `\.hapiOpenURL`.
public struct MarkdownView: View {
    private let blocks: [MarkdownBlockNode]
    @Environment(\.hapiOpenURL) private var hapiOpenURL

    public init(markdown: String) {
        self.blocks = MarkdownBlockTree.build(from: markdown)
    }

    public init(blocks: [MarkdownBlockNode]) {
        self.blocks = blocks
    }

    public var body: some View {
        let open = hapiOpenURL
        MarkdownBlockListView(blocks: blocks)
            .environment(\.openURL, OpenURLAction { url in
                // Route AttributedString link taps into the app handler.
                open(url)
                return .handled
            })
    }
}

struct MarkdownBlockListView: View {
    let blocks: [MarkdownBlockNode]

    var body: some View {
        VStack(alignment: .leading, spacing: 0) {
            ForEach(Array(blocks.enumerated()), id: \.offset) { index, block in
                MarkdownBlockView(block: block)
                    .padding(.top, Self.spacing(before: block, after: index > 0 ? blocks[index - 1] : nil))
            }
        }
    }

    // Pure layout calculation; does not need View's inferred MainActor isolation.
    nonisolated static func spacing(before block: MarkdownBlockNode, after previous: MarkdownBlockNode?) -> CGFloat {
        guard let previous else { return 0 }
        if case .heading = block { return 24 }
        if case .heading = previous { return 8 }
        return 12
    }
}

struct MarkdownBlockView: View {
    let block: MarkdownBlockNode
    @Environment(\.hapiTheme) private var theme
    @Environment(\.hapiTypography) private var typography

    var body: some View {
        switch block {
        case .paragraph(let text):
            SwiftUI.Text(hapiStyledText(text, theme: theme, typography: typography))
                .font(typography.bodyFont)
                .lineSpacing(typography.bodyLineSpacing)
                .fixedSize(horizontal: false, vertical: true)
                .foregroundStyle(theme.textPrimary)
                .textSelection(.enabled)
        case .heading(let level, let text):
            SwiftUI.Text(hapiStyledText(text, theme: theme, typography: typography))
                .font(typography.headingFont(level))
                .fixedSize(horizontal: false, vertical: true)
                .foregroundStyle(theme.textPrimary)
                .textSelection(.enabled)
        case .codeBlock(let language, let code):
            CodeBlockView(language: language, code: code)
        case .blockquote(let children):
            HStack(alignment: .top, spacing: 10) {
                RoundedRectangle(cornerRadius: 1.5)
                    .fill(theme.quoteBar)
                    .frame(width: 3)
                MarkdownBlockListView(blocks: children)
            }
            .fixedSize(horizontal: false, vertical: true)
            .padding(10)
            .background(theme.quoteBackground)
            .clipShape(RoundedRectangle(cornerRadius: 8, style: .continuous))
        case .list(let model):
            MarkdownListView(model: model)
        case .table(let model):
            MarkdownTableView(model: model)
        case .thematicBreak:
            Rectangle()
                .fill(theme.divider)
                .frame(height: 1)
                .padding(.vertical, 4)
        case .image(let alt, let destination):
            MarkdownImageRow(alt: alt, destination: destination)
        }
    }
}

struct MarkdownListView: View {
    let model: MarkdownListModel
    @Environment(\.hapiTheme) private var theme
    @Environment(\.hapiTypography) private var typography

    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            ForEach(Array(model.items.enumerated()), id: \.offset) { index, item in
                HStack(alignment: .firstTextBaseline, spacing: 8) {
                    marker(for: item, index: index)
                    MarkdownBlockListView(blocks: item.blocks)
                }
            }
        }
    }

    @ViewBuilder
    private func marker(for item: MarkdownListModel.Item, index: Int) -> some View {
        if let checked = item.checkbox {
            SwiftUI.Image(systemName: checked ? "checkmark.square.fill" : "square")
                .font(.system(size: typography.bodySize - 2))
                .foregroundStyle(checked ? theme.accent : theme.textHint)
                .accessibilityLabel(SwiftUI.Text(checked ? "Completed" : "Not completed"))
        } else if model.isOrdered {
            SwiftUI.Text("\(model.startIndex + index).")
                .font(typography.bodyFont.monospacedDigit())
                .foregroundStyle(theme.textHint)
        } else {
            SwiftUI.Text("•")
                .font(typography.bodyFont)
                .foregroundStyle(theme.textHint)
        }
    }
}

struct MarkdownTableView: View {
    let model: MarkdownTableModel
    @Environment(\.hapiTheme) private var theme
    @Environment(\.hapiTypography) private var typography

    var body: some View {
        ScrollView(.horizontal, showsIndicators: false) {
            Grid(alignment: .topLeading, horizontalSpacing: 0, verticalSpacing: 0) {
                GridRow {
                    ForEach(Array(model.header.enumerated()), id: \.offset) { index, cell in
                        SwiftUI.Text(hapiStyledText(cell, theme: theme, typography: typography))
                            .fontWeight(.semibold)
                            .font(typography.bodyFont)
                            .foregroundStyle(theme.textPrimary)
                            .padding(.horizontal, 10)
                            .padding(.vertical, 6)
                            .gridColumnAlignment(columnAlignment(index))
                            .background(theme.tableHeaderBackground)
                    }
                }
                ForEach(Array(model.rows.enumerated()), id: \.offset) { _, row in
                    Divider()
                    GridRow {
                        ForEach(Array(row.enumerated()), id: \.offset) { index, cell in
                            SwiftUI.Text(hapiStyledText(cell, theme: theme, typography: typography))
                                .font(typography.bodyFont)
                                .foregroundStyle(theme.textPrimary)
                                .padding(.horizontal, 10)
                                .padding(.vertical, 6)
                                .gridColumnAlignment(columnAlignment(index))
                        }
                    }
                }
            }
        }
        .background(theme.surface)
        .clipShape(RoundedRectangle(cornerRadius: 10, style: .continuous))
    }

    private func columnAlignment(_ index: Int) -> HorizontalAlignment {
        guard index < model.columnAlignments.count, let alignment = model.columnAlignments[index] else {
            return .leading
        }
        switch alignment {
        case .left: return .leading
        case .center: return .center
        case .right: return .trailing
        }
    }
}

struct MarkdownImageRow: View {
    let alt: String
    let destination: String?
    @Environment(\.hapiTheme) private var theme
    @Environment(\.hapiTypography) private var typography
    @Environment(\.hapiOpenURL) private var hapiOpenURL

    var body: some View {
        let label = alt.isEmpty ? (destination ?? "image") : alt
        let url: URL? = destination.flatMap { dest in
            guard HrefPolicy.hasScheme(dest), HrefPolicy.classify(dest) != .blocked else { return nil }
            return InlineBuilder.makeURL(from: dest)
        }

        HStack(spacing: 6) {
            SwiftUI.Image(systemName: "photo")
                .font(.system(size: typography.captionSize))
                .foregroundStyle(theme.textHint)
            if let url {
                Button {
                    hapiOpenURL(url)
                } label: {
                    SwiftUI.Text(label)
                        .font(typography.captionFont)
                        .foregroundStyle(theme.link)
                        .underline()
                        .lineLimit(1)
                }
                .buttonStyle(.plain)
            } else {
                SwiftUI.Text(label)
                    .font(typography.captionFont)
                    .foregroundStyle(theme.textSecondary)
                    .lineLimit(1)
            }
        }
        .padding(8)
        .background(theme.surface)
        .clipShape(RoundedRectangle(cornerRadius: 8, style: .continuous))
    }
}