import Foundation
import Testing
@testable import OrgSwift

/// Tests for the element tree: `source → OrgDocument → {HTML, AttributedString}`.
///
/// The parse tests assert the tree carries structure faithfully. The renderer tests assert
/// the point of the split — that a second output format is a walk over the same tree rather
/// than a second parser. Corpus conformance is gated separately, in `ConformanceTests`.
struct ASTParseTests {

    @Test
    func headingCarriesTodoPriorityAndTags() {
        let doc = OrgParser.parse("* TODO [#A] Write the parser :work:rust:")
        guard case .heading(let heading) = doc.elements.first else {
            Issue.record("expected a heading"); return
        }
        #expect(heading.level == 1)
        #expect(heading.todo == "TODO")
        #expect(heading.priority == "A")
        #expect(heading.tags == ["work", "rust"])
        #expect(OrgParser.plain(heading.title) == "Write the parser")
    }

    @Test
    func emphasisNestsRatherThanFlattening() {
        // The point of a tree: bold containing italic is structure, not a markup string.
        let objects = OrgParser.parseInline("*bold /inner/ rest*")
        guard case .bold(let children) = objects.first else {
            Issue.record("expected bold"); return
        }
        #expect(children.contains { if case .italic = $0 { return true } else { return false } })
    }

    @Test
    func documentKeywordsAreMetadataNotContent() {
        let doc = OrgParser.parse("#+TITLE: My Doc\n#+AUTHOR: Someone\n\nBody.")
        #expect(doc.keyword("title") == "My Doc")
        #expect(doc.keyword("author") == "Someone")
        // Metadata does not appear as a body element.
        #expect(doc.elements.count == 1)
        guard case .paragraph = doc.elements.first else {
            Issue.record("expected a single paragraph"); return
        }
    }

    @Test
    func nestedListsBecomeNestedItems() {
        let doc = OrgParser.parse("""
        - outer
          - inner
            - deepest
        - second
        """)
        guard case .list(let list) = doc.elements.first else {
            Issue.record("expected a list"); return
        }
        #expect(list.items.count == 2)
        guard case .list(let inner)? = list.items[0].content.last else {
            Issue.record("expected a nested list"); return
        }
        #expect(inner.items.count == 1)
        guard case .list(let deepest)? = inner.items[0].content.last else {
            Issue.record("expected a twice-nested list"); return
        }
        #expect(deepest.items.count == 1)
    }

    @Test
    func tableKeepsRuleRowAndAlignments() {
        let doc = OrgParser.parse("""
        | Name  | Score |
        |:------+------:|
        | alpha |    10 |
        """)
        guard case .table(let table) = doc.elements.first else {
            Issue.record("expected a table"); return
        }
        #expect(table.rows.count == 3)
        #expect(table.headerRowCount == 1)
        #expect(table.alignments == [.left, .right])
        if case .rule = table.rows[1] {} else { Issue.record("row 1 should be the rule") }
    }

    @Test
    func timestampsAndLinksBecomeTypedObjects() {
        let objects = OrgParser.parseInline("due <2024-01-15 Mon 10:30> see [[id:abc][the thing]]")
        let hasTimestamp = objects.contains {
            if case .timestamp(let stamp) = $0 { return stamp.machineValue == "2024-01-15T10:30" }
            return false
        }
        #expect(hasTimestamp)
        let hasIDLink = objects.contains {
            if case .link(let link) = $0, case .id(let identifier) = link.target { return identifier == "abc" }
            return false
        }
        #expect(hasIDLink)
    }
}

struct ASTRendererTests {

    /// The payoff: one parse, two output formats, neither re-deriving the other's work.
    @Test
    func oneParseFeedsTwoRenderers() {
        let document = OrgParser.parse("A *bold* claim with ~code~ and a [[https://example.com][link]].")

        let html = OrgHTMLTreeRenderer().render(document)
        #expect(html.contains("<strong>bold</strong>"))
        #expect(html.contains("<code>code</code>"))
        #expect(html.contains(#"<a href="https://example.com">link</a>"#))

        let attributed = OrgAttributedStringRenderer().inline({
            if case .paragraph(let objects) = document.elements[0] { return objects }
            return []
        }())
        // Same content, native representation: no markup, real attributes.
        let plain = String(attributed.characters)
        #expect(plain == "A bold claim with code and a link.")
        #expect(!plain.contains("<"))

        let boldRun = attributed.runs.first { $0.inlinePresentationIntent == .stronglyEmphasized }
        #expect(boldRun != nil)
        let codeRun = attributed.runs.first { $0.inlinePresentationIntent == .code }
        #expect(codeRun != nil)
        let linkRun = attributed.runs.first { $0.link != nil }
        #expect(linkRun?.link?.absoluteString == "https://example.com")
    }

    /// The native renderer resolves and sanitizes exactly as the HTML one does, so a README
    /// rendered natively gets the same working links rather than raw relative paths.
    @Test
    func attributedStringResolvesRelativeLinksAndRejectsUnsafeOnes() {
        let renderer = OrgAttributedStringRenderer(options: OrgRenderOptions(
            host: "gitbay.org",
            owner: "krz",
            repositoryName: "org-swift",
            ref: "HEAD",
            readmePath: "README.org"
        ))

        let relative = renderer.inline(OrgParser.parseInline("[[./ARCHITECTURE.md][notes]]"))
        #expect(relative.runs.first { $0.link != nil }?.link?.absoluteString
            == "https://gitbay.org/krz/org-swift/blob/HEAD/ARCHITECTURE.md")

        // Without repository context there is nothing to resolve against, so an unsafe
        // scheme reaches the allowlist and the link degrades to its text — as in HTML.
        let unsafe = OrgAttributedStringRenderer().inline(OrgParser.parseInline("[[javascript:alert(1)][tap]]"))
        #expect(String(unsafe.characters) == "tap")
        #expect(unsafe.runs.allSatisfy { $0.link == nil })
        #expect(!OrgRenderer.renderToHTML("[[javascript:alert(1)][tap]]").lowercased().contains("javascript:"))
    }

    /// Footnote numbering is document-wide and order-of-use, and now shared with HTML, so
    /// both renderers agree on which note is number 1.
    @Test
    func attributedStringNumbersFootnotesInReferenceOrder() {
        let doc = OrgParser.parse("""
        First[fn:b] then second[fn:a] then first again[fn:b].

        [fn:a] note a
        [fn:b] note b
        """)
        guard case .paragraph(let objects) = doc.elements[0] else {
            Issue.record("expected a paragraph"); return
        }
        var notes = OrgFootnotes(document: doc)
        let text = String(OrgAttributedStringRenderer().inline(objects, &notes).characters)
        #expect(text == "First[1] then second[2] then first again[1].")
        #expect(notes.notes.map(\.label) == ["b", "a"])
    }

    /// Emphasis nests in org, and the HTML renderer nests it (`<strong>b <em>i</em></strong>`).
    /// Assigning the intent over the whole range instead of merging would flatten the inner
    /// one away.
    @Test
    func nestedEmphasisKeepsBothIntents() {
        let attributed = OrgAttributedStringRenderer().inline(
            OrgParser.parseInline("*bold /italic/ tail*")
        )
        func intent(_ text: String) -> InlinePresentationIntent? {
            attributed.runs.first { String(attributed[$0.range].characters).contains(text) }?
                .inlinePresentationIntent
        }
        #expect(intent("bold")?.contains(.stronglyEmphasized) == true)
        #expect(intent("italic")?.contains(.stronglyEmphasized) == true)
        #expect(intent("italic")?.contains(.emphasized) == true)
        // The outer run is bold only.
        #expect(intent("bold")?.contains(.emphasized) == false)
    }

    @Test
    func attributedStringCarriesRolesForNonStandardIntents() {
        let objects = OrgParser.parseInline("x^2 and <2024-01-15 Mon>")
        let attributed = OrgAttributedStringRenderer().inline(objects)
        let roles: [OrgRole] = attributed.runs.compactMap { $0[OrgRoleAttribute.self] }
        #expect(roles.contains(.superscript))
        #expect(roles.contains(.timestamp))
    }

    @Test
    func consecutiveListsOfDifferentKindsStaySeparate() {
        // An ordered list followed by a bullet list is two lists, not one with mixed items.
        let doc = OrgParser.parse("""
        1. first
        2. second

        - [ ] todo
        - [X] done
        """)
        let lists = doc.elements.compactMap { element -> OrgList? in
            if case .list(let list) = element { return list } else { return nil }
        }
        #expect(lists.count == 2)
        #expect(lists.first?.kind == .ordered)
        #expect(lists.last?.kind == .unordered)
        #expect(lists.last?.items.first?.checkbox == .off)

        let html = OrgHTMLTreeRenderer().render(doc)
        #expect(html.contains("</ol>"))
        #expect(html.contains("<ul>"))
    }

    @Test
    func inlineFootnoteDefinesItsNoteAtTheReference() {
        let doc = OrgParser.parse("A claim.[fn:x:defined right here]")
        let html = OrgHTMLTreeRenderer().render(doc)
        #expect(html.contains(##"href="#fn-1">1</a>"##))
        // Inline note text sits directly in the item; only reference-style notes get a <p>.
        #expect(html.contains(#"<li id="fn-1">defined right here "#))
        #expect(!html.contains(#"<li id="fn-1"><p>"#))
    }

    @Test
    func referenceStyleFootnoteKeepsItsParagraph() {
        let doc = OrgParser.parse("A claim.[fn:1]\n\n[fn:1] The definition.")
        let html = OrgHTMLTreeRenderer().render(doc)
        #expect(html.contains(#"<li id="fn-1"><p>The definition.</p>"#))
    }

    @Test
    func timestampRangesRenderAsTwoTimeElements() {
        // Same-day: the end shows only its time, since the start carries the date.
        let sameDay = OrgHTMLTreeRenderer().render(OrgParser.parse("Range <2024-01-15 Mon 10:00-11:45>."))
        #expect(sameDay.contains(#"datetime="2024-01-15T10:00">2024-01-15 10:00</time>"#))
        #expect(sameDay.contains("&#8211;"))
        #expect(sameDay.contains(#"datetime="2024-01-15T11:45">11:45</time>"#))

        // Multi-day: one timestamp carrying an end date, rendered as two stamps.
        let multiDay = OrgHTMLTreeRenderer().render(OrgParser.parse("Span <2024-01-15 Mon>--<2024-01-20 Sat>."))
        #expect(multiDay.contains(#"datetime="2024-01-15">2024-01-15</time>"#))
        #expect(multiDay.contains("&#8211;"))
        #expect(multiDay.contains(#"datetime="2024-01-20">2024-01-20</time>"#))
        // The `--` join is consumed, not left as stray text.
        #expect(!multiDay.contains("--"))
    }

    @Test
    func treeRendererProducesStructuralHTML() {
        let document = OrgParser.parse("""
        * Heading

        | a | b |
        |---+---|
        | 1 | 2 |

        - [ ] todo
        - [X] done
        """)
        let html = OrgHTMLTreeRenderer().render(document)
        #expect(html.contains("<h1>Heading</h1>"))
        #expect(html.contains("<thead>"))
        #expect(html.contains("<th>a</th>"))
        #expect(html.contains("<td>1</td>"))
        #expect(html.contains("<code>[&nbsp;]</code> todo"))
        #expect(html.contains("<code>[X]</code> done"))
    }
}

/// The render options, which the conformance corpus does not exercise because it renders with
/// no repository context. These were written as shipped-vs-tree equivalence checks during the
/// migration; now that the tree *is* the renderer, they assert the behaviour directly.
struct OrgRenderOptionsTests {

    /// gitbay's configuration: images resolve against `raw`, links against `blob`.
    private static let repositoryOptions = OrgRenderOptions(
        host: "gitbay.org",
        owner: "krz",
        repositoryName: "gitbay",
        ref: "HEAD",
        readmePath: "README.org",
        imagePathSegment: "raw",
        linkPathSegment: "blob"
    )

    @Test
    func resolvesRepositoryRelativeURLsAgainstTheirOwnSegment() {
        let html = OrgRenderer.renderToHTML("""
        A relative link to [[docs/DESIGN.org][the design]] and an absolute one to
        [[https://example.org][elsewhere]].

        [[file:docs/logo.png]]
        """, options: Self.repositoryOptions)

        #expect(html.contains("https://gitbay.org/krz/gitbay/raw/HEAD/docs/logo.png"))
        #expect(html.contains("https://gitbay.org/krz/gitbay/blob/HEAD/docs/DESIGN.org"))
        #expect(html.contains("https://example.org"))
    }

    @Test
    func leavesRelativeTargetsAloneWithoutRepositoryContext() {
        let html = OrgRenderer.renderToHTML("[[docs/DESIGN.org][the design]]\n\n[[file:logo.png]]")
        #expect(html.contains(#"href="docs/DESIGN.org""#))
        #expect(html.contains(#"src="logo.png""#))
    }

    @Test
    func emitsTheMetadataHeaderOnlyWhenAsked() {
        let source = "#+TITLE: My Doc\n#+AUTHOR: Someone\n\nBody."

        let withHeader = OrgRenderer.renderToHTML(source)
        #expect(withHeader.contains(#"<h1 class="org-title">My Doc</h1>"#))
        #expect(withHeader.contains(#"<p class="org-author">Someone</p>"#))

        let without = OrgRenderer.renderToHTML(source, options: OrgRenderOptions(metadataHeader: false))
        #expect(!without.contains("org-title"))
        #expect(!without.contains("My Doc"))
        #expect(without.contains("<p>Body.</p>"))
    }

    /// org's border rule: an emphasis body may not begin or end with whitespace. Without the
    /// trailing half, `=ssh.mode = "system"=` closed at the middle `=` and rendered as two
    /// verbatim spans with the quoted value loose between them.
    @Test
    func emphasisBodyCannotBeginOrEndWithWhitespace() {
        let objects = OrgParser.parseInline(#"=ssh.mode = "system"= to run"#)
        let verbatims = objects.compactMap { object -> String? in
            if case .verbatim(let text) = object { return text } else { return nil }
        }
        #expect(verbatims == [#"ssh.mode = "system""#])

        // A leading space means the marker never opens.
        #expect(OrgParser.parseInline("= not verbatim=") == [.text("= not verbatim=")])

        // The ordinary cases still work.
        #expect(OrgParser.parseInline("=plain=") == [.verbatim("plain")])
        let bold = OrgParser.parseInline("*bold* and *two words*")
        #expect(bold.contains(.bold([.text("bold")])))
        #expect(bold.contains(.bold([.text("two words")])))
    }

    /// The characters org allows around emphasis markers, matched to orgo — which is
    /// what the conformance corpus is generated from. The set was narrower here, so a
    /// closer against a dash or a bracket did not close.
    @Test
    func emphasisBoundaryCharactersMatchOrgo() {
        func verbatims(_ text: String) -> [String] {
            OrgParser.parseInline(text).compactMap {
                if case .verbatim(let t) = $0 { return t } else { return nil }
            }
        }
        // Newly closing: a dash or an opening bracket after the closer.
        #expect(verbatims("=verbatim=-adjacent") == ["verbatim"])
        #expect(verbatims("see =code=[1]") == ["code"])
        // Newly opening: a dash before the opener.
        #expect(verbatims("-=code= wrapped") == ["code"])

        // `]` is not a post character in org, so this does not close.
        #expect(verbatims("=code=] trailing").isEmpty)

        // Which is safe because a link's description is parsed as its own run, so a
        // closing `]` never actually follows the marker.
        let link = OrgParser.parseInline("[[https://example.com][=code=]]")
        guard case .link(let l) = link.first else {
            Issue.record("expected a link"); return
        }
        #expect(l.description ?? [] == [.verbatim("code")])
    }

    @Test
    func rejectsUnsafeSchemes() {
        let html = OrgRenderer.renderToHTML("[[javascript:alert(1)][click]]")
        #expect(!html.lowercased().contains("javascript:"))
        // The link degrades to its text rather than becoming a bad anchor.
        #expect(html.contains("click"))
    }

    /// A range whose halves are inactive timestamps is still a range. orgo applies the `--`
    /// rule to both bracket kinds, requiring only that the halves agree on activeness; the
    /// renderer this replaced joined active ranges only, so this is the one behaviour the
    /// swap deliberately changed.
    @Test
    func joinsInactiveTimestampRanges() {
        let html = OrgRenderer.renderToHTML("CLOCK: [2024-01-15 Mon 09:00]--[2024-01-15 Mon 10:00]")
        #expect(!html.contains("--"))
        #expect(html.contains("&#8211;"))
        #expect(html.contains(#"class="timestamp inactive""#))
    }
}

private func astCorpusCasesDir() -> URL? {
    if let env = ProcessInfo.processInfo.environment["ORG_CONFORMANCE_DIR"] {
        let cases = URL(fileURLWithPath: env).appendingPathComponent("cases")
        if FileManager.default.fileExists(atPath: cases.path) { return cases }
    }
    let pkgRoot = URL(fileURLWithPath: #filePath)
        .deletingLastPathComponent().deletingLastPathComponent().deletingLastPathComponent()
    let sibling = pkgRoot.deletingLastPathComponent()
        .appendingPathComponent("org-conformance").appendingPathComponent("cases")
    return FileManager.default.fileExists(atPath: sibling.path) ? sibling : nil
}

private func astCaseNames(_ dir: URL) -> [String] {
    let items = (try? FileManager.default.contentsOfDirectory(atPath: dir.path)) ?? []
    return items.filter { $0.hasSuffix(".org") }.map { String($0.dropLast(4)) }.sorted()
}