import Foundation
import Testing
@testable import OrgSwift

private func render(_ source: String, options: OrgRenderOptions = .init()) -> String {
    OrgRenderer.renderToHTML(source, options: options)
}

struct OrgRendererTests {

    @Test
    func orgDeepHeading() {
        let html = render("**** Level 4 Heading")

        #expect(html.contains("<h4>"))
    }

    @Test
    func orgCommentLinesIgnored() {
        let html = render("# This is a comment\nNormal text")

        #expect(!html.contains("This is a comment"))
        #expect(html.contains("Normal text"))
    }

    @Test
    func orgStrikethrough() {
        let html = render("+deleted text+")

        #expect(html.contains("<del>"))
    }

    @Test
    func orgExampleBlock() {
        let html = render("#+begin_example\nhello world\n#+end_example")

        // Example blocks are a bare <pre> (org's exporter uses no inner <code>).
        #expect(html.contains("<pre>hello world"))
        #expect(!html.contains("<pre><code>"))
    }

    @Test
    func orgTitleKeyword() {
        let html = render("#+TITLE: My Document\nBody text")

        #expect(html.contains("org-title"))
        #expect(html.contains("My Document"))
    }

    @Test
    func orgItalicDoesNotMatchURLPaths() {
        let html = render("[[https://example.com/path/to/file]]")

        #expect(!html.contains("<em>"))
    }

    @Test
    func orgWrappedBulletNormalizesLines() {
        let html = render("- First line\n  continues here")

        #expect(html.contains("<li>First line continues here</li>"))
    }

    @Test
    func orgHeaderKeywordsIgnored() {
        let html = render("""
        #+OPTIONS: toc:nil
        #+PROPERTY: header-args :results output
        Body text
        """)

        #expect(!html.contains("#+OPTIONS"))
        #expect(!html.contains("#+PROPERTY"))
        #expect(html.contains("<p>Body text</p>"))
    }

    @Test
    func orgVerseBlock() {
        let html = render("""
        #+begin_verse
        There is a line.
          And an indented line.
        #+end_verse
        """)

        // Verse renders as <p class="verse"> with <br> between lines, matching org.
        #expect(html.contains(#"<p class="verse">"#))
        #expect(html.contains("There is a line.<br>"))
        #expect(html.contains("And an indented line."))
        #expect(!html.contains("#+begin_verse"))
    }

    @Test
    func orgNamedBlockRendersCaption() {
        let html = render("""
        #+CAPTION: Build output
        #+NAME: build-log
        #+begin_example
        hello world
        #+end_example
        """)

        #expect(html.contains(#"<figure class="org-block" id="build-log">"#))
        #expect(html.contains("<figcaption>Build output</figcaption>"))
        #expect(!html.contains("#+CAPTION"))
        #expect(!html.contains("#+NAME"))
    }

    @Test
    func orgLinkedImageRenders() {
        let html = render("[[https://example.com][[https://img.cleberg.net/apps/hutch/screenshots/ipad/01_patch.jpg]]]")

        #expect(html.contains(#"<a href="https://example.com">"#))
        #expect(html.contains(#"<img src="https://img.cleberg.net/apps/hutch/screenshots/ipad/01_patch.jpg" alt="">"#))
    }

    @Test
    func orgLinkedRelativeImageRenders() {
        // In hutch this passed an explicit imageURLResolver closure; here the same
        // resolution is expressed through OrgRenderOptions (owner/repositoryName/host).
        let html = render(
            "[[https://example.com/docs][[./images/badge.svg]]]",
            options: OrgRenderOptions(owner: "~ccleberg", repositoryName: "Hutch")
        )

        #expect(html.contains(#"<a href="https://example.com/docs">"#))
        #expect(html.contains(#"<img src="https://git.sr.ht/~ccleberg/Hutch/blob/HEAD/images/badge.svg" alt="">"#))
    }

    @Test
    func orgNestedBulletListRendersNestedMarkup() {
        let html = render("""
        * Lists
        ** Unordered
        - First bullet
        - Second bullet
        - Third bullet with /italic/ and *bold*
        - Bullet with wrapped
          continuation line
        - Bullet with nested list
          - Nested child one
          - Nested child two
        - Bullet with inline code ~let x = 1~
        """)

        #expect(html.contains("<ul>"))
        #expect(html.contains("<li>Bullet with nested list\n<ul>"))
        #expect(html.contains("<li>Nested child one</li>"))
        #expect(html.contains("<li>Nested child two</li>"))
        #expect(html.contains("<li>Bullet with wrapped continuation line</li>"))
    }

    @Test
    func orgTableAlignmentRendersStyles() {
        let html = render("""
        | Left | Center | Right |
        |:-----+:-----:+------:|
        | a    | b      | c     |
        | 1    | 2      | 3     |
        """)

        #expect(html.contains("text-align: left;"))
        #expect(html.contains("text-align: center;"))
        #expect(html.contains("text-align: right;"))
    }

    @Test
    func metadataHeaderShownByDefault() {
        let html = render("#+TITLE: My Doc\n\nBody.")
        #expect(html.contains("<h1 class=\"org-title\">My Doc</h1>"))
    }

    @Test
    func metadataHeaderSuppressed() {
        let html = render("#+TITLE: My Doc\n\nBody.", options: OrgRenderOptions(metadataHeader: false))
        #expect(!html.contains("org-title"))
        #expect(!html.contains("My Doc"))
        #expect(html.contains("<p>Body.</p>"))
    }

    @Test
    func headingLevelOffsetShiftsAndClamps() {
        let base = render("* Top\n\n** Sub")
        #expect(base.contains("<h1>Top</h1>"))
        #expect(base.contains("<h2>Sub</h2>"))

        let shifted = render("* Top\n\n** Sub", options: OrgRenderOptions(headingLevelOffset: 1))
        #expect(shifted.contains("<h2>Top</h2>"))
        #expect(shifted.contains("<h3>Sub</h3>"))

        // A six-star heading with a +1 offset clamps to h6, never h7.
        let deep = render("****** Deep", options: OrgRenderOptions(headingLevelOffset: 1))
        #expect(deep.contains("<h6>Deep</h6>"))
        #expect(!deep.contains("<h7"))
    }

    @Test
    func timestampActiveAndInactive() {
        let html = render("An active <2024-01-15 Mon> and inactive [2024-01-15 Mon].")
        #expect(html.contains(#"<time class="timestamp" datetime="2024-01-15">2024-01-15</time>"#))
        #expect(html.contains(#"<time class="timestamp inactive" datetime="2024-01-15">2024-01-15</time>"#))
    }

    @Test
    func timestampWithTimeAndRanges() {
        #expect(render("At <2024-01-15 Mon 10:30>.").contains(
            #"<time class="timestamp" datetime="2024-01-15T10:30">2024-01-15 10:30</time>"#))

        let sameDay = render("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>"#))

        let multiDay = render("Span <2024-01-15 Mon>--<2024-01-20 Sat>.")
        #expect(multiDay.contains(#"datetime="2024-01-15">2024-01-15</time>"#))
        #expect(multiDay.contains(#"datetime="2024-01-20">2024-01-20</time>"#))
        #expect(multiDay.contains("&#8211;"))
    }

    @Test
    func timestampRepeaterDroppedAndNonTimestampsLiteral() {
        #expect(render("Repeats <2024-01-15 Mon +1w>.").contains(
            #"<time class="timestamp" datetime="2024-01-15">2024-01-15</time>"#))
        let literal = render("Compare 3 < 4 and [not a stamp].")
        #expect(!literal.contains("<time"))
        #expect(literal.contains("[not a stamp]"))
    }

    @Test
    func footnoteReferencesAndSection() {
        let html = render("""
        A claim.[fn:1] Another.[fn:2]

        [fn:1] First note.
        [fn:2] Second with /emphasis/.
        """)
        // References number in textual order and link to the section.
        #expect(html.contains(##"<sup class="footnote-ref"><a id="fnr-1" href="#fn-1">1</a></sup>"##))
        #expect(html.contains(##"<sup class="footnote-ref"><a id="fnr-2" href="#fn-2">2</a></sup>"##))
        // The section renders once, in order, with the definitions and back-links.
        #expect(html.contains(#"<section class="footnotes""#))
        #expect(html.contains(#"<li id="fn-1"><p>First note.</p>"#))
        #expect(html.contains("Second with <em>emphasis</em>"))
        #expect(html.contains(##"href="#fnr-2""##))
        // fn-1 must appear before fn-2 in the section.
        let firstIndex = html.range(of: #"id="fn-1""#)!.lowerBound
        let secondIndex = html.range(of: #"id="fn-2""#)!.lowerBound
        #expect(firstIndex < secondIndex)
    }

    @Test
    func inlineFootnoteNotWrappedInParagraph() {
        let html = render("See here.[fn:x:defined inline]")
        #expect(html.contains(##"href="#fn-1">1</a>"##))
        // Inline footnote content sits directly in the <li>, not wrapped in <p>.
        #expect(html.contains(#"<li id="fn-1">defined inline "#))
        #expect(!html.contains("<li id=\"fn-1\"><p>defined inline"))
    }

    @Test
    func propertyDrawerIsDropped() {
        let html = render("""
        * Heading
        :PROPERTIES:
        :CUSTOM_ID: first
        :OWNER: nobody
        :END:

        Body text.
        """)
        #expect(!html.contains("org-properties"))
        #expect(!html.contains("<dl"))
        #expect(!html.contains("CUSTOM_ID"))
        #expect(!html.contains("nobody"))
        #expect(html.contains("<h1>Heading</h1>"))
        #expect(html.contains("<p>Body text.</p>"))
    }

    @Test
    func headingTagsRenderAsSpans() {
        let html = render("* Write the parser :work:rust:")
        #expect(html.contains(#"<h1>Write the parser <span class="tag">work</span> <span class="tag">rust</span></h1>"#))
    }

    @Test
    func headingWithoutTagsIsUnchanged() {
        let html = render("* Just a heading")
        #expect(html.contains("<h1>Just a heading</h1>"))
        #expect(!html.contains("class=\"tag\""))
    }

    @Test
    func bareUrlBecomesLink() {
        let html = render("See https://example.com now.")
        #expect(html.contains(#"<a href="https://example.com">https://example.com</a>"#))
        // Trailing sentence punctuation stays outside the link.
        let end = render("End at https://example.com.")
        #expect(end.contains(#"<a href="https://example.com">https://example.com</a>."#))
    }

    @Test
    func taskCheckboxesRenderAsCode() {
        let html = render("""
        - [ ] todo
        - [X] done
        - [-] partial
        """)
        #expect(html.contains("<code>[&nbsp;]</code> todo"))
        #expect(html.contains("<code>[X]</code> done"))
        #expect(html.contains("<code>[-]</code> partial"))
        #expect(!html.contains("<input"))
    }

    @Test
    func bareFileImageIsImgInParagraph() {
        let html = render("[[file:diagram.png]]")
        #expect(html.contains(#"<p><img src="diagram.png" alt=""></p>"#))
    }

    @Test
    func describedFileImageIsALink() {
        // A description turns an image target into a link, not an inline image.
        let html = render("[[file:diagram.png][the diagram]]")
        #expect(html.contains(#"<a href="diagram.png">the diagram</a>"#))
        #expect(!html.contains("<img"))
    }

    @Test
    func imageDescriptionBecomesClickableImage() {
        // A build-badge: the description is itself an image, so it is the link's content.
        let badge = render("[[https://example.com/builds][file:https://example.com/badge.svg]]")
        #expect(badge.contains(#"<a href="https://example.com/builds"><img src="https://example.com/badge.svg" alt=""></a>"#))

        // The double-bracketed form works the same.
        let bracketed = render("[[https://example.com/builds][[https://example.com/badge.svg]]]")
        #expect(bracketed.contains(#"<a href="https://example.com/builds"><img"#))

        // A plain-text description that merely looks path-like stays text.
        let plain = render("[[https://example.com][see diagram.png]]")
        #expect(plain.contains(#"<a href="https://example.com">see diagram.png</a>"#))
        #expect(!plain.contains("<img"))
    }

    @Test
    func captionPromotesImageToFigure() {
        let html = render("""
        #+CAPTION: A /stylised/ chart
        [[file:chart.png]]
        """)
        #expect(html.contains("<figure><img src=\"chart.png\""))
        #expect(html.contains(#"<figcaption><span class="figure-number">Figure 1: </span>A <em>stylised</em> chart</figcaption>"#))
        // alt is the caption with markup stripped.
        #expect(html.contains(#"alt="A stylised chart""#))
    }

    @Test
    func attrHtmlPromotesImageToFigureWithoutCaption() {
        let html = render("""
        #+ATTR_HTML: :alt "a cat, sitting" :loading lazy
        [[file:cat.jpg]]
        """)
        #expect(html.contains("<figure><img src=\"cat.jpg\""))
        #expect(html.contains(#"alt="a cat, sitting""#))
        #expect(html.contains(#"loading="lazy""#))
        #expect(!html.contains("<figcaption"))
    }

    @Test
    func figuresNumberSequentially() {
        let html = render("""
        #+CAPTION: First
        [[file:a.png]]

        #+CAPTION: Second
        [[file:b.png]]
        """)
        #expect(html.contains("Figure 1: </span>First"))
        #expect(html.contains("Figure 2: </span>Second"))
    }

    @Test
    func threeDeepNestedList() {
        let html = render("""
        - outer
          - inner
            - deepest
          - second inner
        - second outer
        """)
        #expect(html.contains("<li>outer\n<ul>\n<li>inner\n<ul>\n<li>deepest</li>"))
        #expect(html.contains("<li>second inner</li>"))
        #expect(html.contains("<li>second outer</li>"))
    }

    @Test
    func nestedOrderedList() {
        let html = render("""
        1. first
        2. second
           1. point one
           2. point two
        3. third
        """)
        #expect(html.contains("<li>second\n<ol>\n<li>point one</li>"))
        #expect(html.contains("<li>third</li>"))
    }

    @Test
    func descriptionList() {
        let html = render("""
        - term one :: first definition
        - /marked/ term :: holds inline markup
        """)
        #expect(html.contains("<dl>"))
        #expect(html.contains("<dt>term one</dt>"))
        #expect(html.contains("<dd>first definition</dd>"))
        #expect(html.contains("<dt><em>marked</em> term</dt>"))
    }

    @Test
    func multiParagraphListItem() {
        let html = render("""
        - an item with two paragraphs

          the second paragraph

        - a plain sibling
        """)
        #expect(html.contains("<li><p>an item with two paragraphs</p>\n<p>the second paragraph</p></li>"))
        #expect(html.contains("<li>a plain sibling</li>"))
    }

    @Test
    func exportBlockHtmlPassesThroughLatexDropped() {
        let html = render("""
        #+BEGIN_EXPORT html
        <aside>raw</aside>
        #+END_EXPORT

        #+BEGIN_EXPORT latex
        \\emph{dropped}
        #+END_EXPORT
        """)
        #expect(html.contains("<aside>raw</aside>"))
        #expect(!html.contains("dropped"))
        #expect(!html.contains("BEGIN_EXPORT"))
    }

    @Test
    func specialBlockRendersAsNamedDiv() {
        let html = render("""
        #+BEGIN_NOTE
        Contents are *org*, not literal.
        #+END_NOTE
        """)
        #expect(html.contains(#"<div class="note">"#))
        #expect(html.contains("<p>Contents are <strong>org</strong>, not literal.</p>"))
    }

    @Test
    func superscriptRenders() {
        #expect(render("N^2 here.").contains("N<sup>2</sup>"))
        #expect(render("H^{2O} molecule.").contains("H<sup>2O</sup>"))
    }

    @Test
    func idLinkBecomesFragment() {
        let html = render("See [[id:abc-123]] and [[id:x][the x]].")
        #expect(html.contains(##"<a href="#abc-123">abc-123</a>"##))
        #expect(html.contains(##"<a href="#x">the x</a>"##))
    }

    @Test
    func unknownKeywordLinesAreDropped() {
        let html = render("#+FILETAGS: :sample:\n\nBody.")
        #expect(!html.contains("FILETAGS"))
        #expect(!html.contains("sample"))
        #expect(html.contains("<p>Body.</p>"))
    }

    @Test
    func relativeURLsResolveWithConfigurablePathSegments() {
        // gitbay serves raw bytes at /raw/<ref>/ and the file page at /blob/<ref>/, so an
        // image resolves against a different segment than a link.
        let options = OrgRenderOptions(
            host: "gitbay.org",
            owner: "krz",
            repositoryName: "gitbay",
            ref: "HEAD",
            readmePath: "README.org",
            imagePathSegment: "raw",
            linkPathSegment: "blob"
        )
        let html = render("""
        [[file:docs/logo.png]]

        See [[docs/DESIGN.org][the design]].
        """, options: options)
        #expect(html.contains(#"<img src="https://gitbay.org/krz/gitbay/raw/HEAD/docs/logo.png""#))
        #expect(html.contains(#"<a href="https://gitbay.org/krz/gitbay/blob/HEAD/docs/DESIGN.org">the design</a>"#))
    }
}