dependencies {
    implementation(libs.markdown.parser)
    implementation(libs.markdown.runtime)
    implementation(libs.markdown.renderer)
}

import com.hrm.markdown.renderer.Markdown
import com.hrm.markdown.renderer.MarkdownTheme
import com.hrm.codehigh.theme.OneDarkProTheme

@Composable
fun MyScreen() {
    Markdown(
        markdown = """
            # Hello World
            
            This is a paragraph with **bold** and *italic* text.
            
            - Item 1
            - Item 2
            
            ```kotlin
            fun hello() = println("Hello")
            ```
        """.trimIndent(),
        modifier = Modifier.fillMaxSize(),
        theme = MarkdownTheme.auto(), // Follows system light/dark mode
        codeTheme = OneDarkProTheme,  // Optional: pass a codehigh theme directly
    )
}

Markdown(
    markdown = """
Custom syntax:

!VIDEO[Demo](https://cdn.example.com/a.mp4){poster=https://cdn.example.com/a.jpg}
    """.trimIndent(),
    directivePlugins = listOf(VideoDirectivePlugin),
)

object VideoDirectivePlugin : MarkdownDirectivePlugin {
    override val id: String = "video"

    override val inputTransformers = listOf(VideoSyntaxTransformer())

    override val blockDirectiveRenderers = mapOf(
        "video" to { scope ->
            VideoPlayer(
                url = scope.args.getValue("url"),
                poster = scope.args["poster"],
                title = scope.args["title"],
            )
        }
    )
}

class VideoSyntaxTransformer : MarkdownInputTransformer {
    override val id: String = "video-syntax"

    override fun transform(input: String): MarkdownTransformResult {
        val normalized = input.replace(
            Regex("""!VIDEO\[(.*?)\]\((.*?)\)\{poster=(.*?)\}""")
        ) { match ->
            val title = match.groupValues[1]
            val url = match.groupValues[2]
            val poster = match.groupValues[3]
            """{% video title="$title" url="$url" poster="$poster" %}"""
        }
        return MarkdownTransformResult(markdown = normalized)
    }
}

val html = MarkdownHtml.render(
    markdown = markdown,
    directivePlugins = listOf(VideoDirectivePlugin),
)

var text by remember { mutableStateOf("") }
var isStreaming by remember { mutableStateOf(true) }

LaunchedEffect(Unit) {
    llmTokenFlow.collect { token ->
        text += token
    }
    isStreaming = false
}

Markdown(
    markdown = text,
    isStreaming = isStreaming, // Enables incremental parsing + 5fps throttled rendering
)

// Built-in themes
Markdown(markdown = text, theme = MarkdownTheme.light())  // GitHub Light
Markdown(markdown = text, theme = MarkdownTheme.dark())   // GitHub Dark
Markdown(markdown = text, theme = MarkdownTheme.auto())   // Auto-detect

// Full customization (30+ properties)
Markdown(
    markdown = text,
    theme = MarkdownTheme(
        headingStyles = listOf(
            TextStyle(fontSize = 32.sp, fontWeight = FontWeight.Bold),
            // h2 ~ h6 ...
        ),
        bodyStyle = TextStyle(fontSize = 16.sp),
        codeBlockBackground = Color(0xFFF5F5F5),
        // ...and much more
    ),
    onLinkClick = { url -> /* handle click */ },
)

import com.hrm.codehigh.theme.DraculaProTheme
import com.hrm.codehigh.theme.LocalCodeTheme
import com.hrm.codehigh.theme.OneDarkProTheme

// Option 1: Pass codehigh theme per Markdown call
Markdown(
    markdown = text,
    theme = MarkdownTheme.auto(),
    codeTheme = OneDarkProTheme,
)

// Option 2: Provide a default codehigh theme globally via CompositionLocal
CompositionLocalProvider(
    LocalCodeTheme provides DraculaProTheme
) {
    Markdown(
        markdown = text,
        theme = MarkdownTheme.auto(),
    )
}

val parser = MarkdownParser(enableLinting = true)
val document = parser.parse(markdown)

document.diagnostics.forEach { diagnostic ->
    println("Line ${diagnostic.line}: [${diagnostic.severity}] ${diagnostic.message}")
}

// Strict CommonMark — no extensions
val doc = MarkdownParser(CommonMarkFlavour).parse(input)

// GFM — CommonMark + tables, strikethrough, autolinks
val doc = MarkdownParser(GFMFlavour).parse(input)

// Extended (default) — everything enabled
val doc = MarkdownParser().parse(input)

// One-shot HTML rendering
val html = HtmlRenderer.renderMarkdown(input, flavour = CommonMarkFlavour)

Markdown(
    markdown = markdownText,
    imageContent = { data, modifier ->
        // data.url, data.altText, data.width, data.height available
        AsyncImage(
            model = data.url,
            contentDescription = data.altText,
            modifier = modifier,
        )
    },
)