#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_versions"
    dependency "sparkles:versions" version="*"
+/

import std.stdio : writeln;
import sparkles.versions.schemes.semver : SemVer;
import sparkles.versions.operations : satisfies;

void main()
{
    auto current = SemVer.parse("1.2.3").value;
    auto next = SemVer.parse("1.3.0-beta.1").value;
    writeln(current);
    writeln(next > current);

    // Loose parsing accepts a leading `v` and partial versions.
    writeln(SemVer.parseLoose("v1.2").value);

    // Range membership.
    auto range = SemVer.parseNativeRange("^1.2.0").value;
    writeln(current.satisfies(range));
}

#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_styled_templates"
    dependency "sparkles:base" version="*"
+/

import sparkles.base.styled_template;

void main()
{
    int cpu = 75;
    styledWriteln(i"CPU: {red $(cpu)%} Status: {green OK}");
    styledWriteln(i"{bold.red ERROR:} Connection refused");
    styledWriteln(i"{cyan Outer {bold.underline inner} just cyan}");
    styledWriteln(i"Press {bold.cyan q} to quit, {bold.cyan h} for help");
}

#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_pretty_printing"
    dependency "sparkles:base" version="*"
+/

import std.stdio : writeln;

import sparkles.base.prettyprint;

struct Server
{
    string name;
    string ip;
    int port;
}

struct Cluster
{
    string name;
    Server[] servers;
    bool active;
}

void main()
{
    auto cluster = Cluster(
        name: "Production",
        servers: [
            Server("web-01", "192.168.1.10", 80),
            Server("web-02", "192.168.1.11", 80),
            Server("db-01", "192.168.1.20", 5432),
        ],
        active: true,
    );

    writeln(prettyPrint(cluster, PrettyPrintOptions!void(colored: false)));
}

prettyPrint(value, PrettyPrintOptions!void(
    indentStep: 2,       // spaces per indent level
    maxDepth: 8,         // recursion limit
    maxItems: 32,        // max array/AA items shown
    softMaxWidth: 80,    // single-line threshold
    colored: true,     // ANSI color output
    useOscLinks: false,  // OSC 8 hyperlinks on type names
));

#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_terminal_styling"
    dependency "sparkles:base" version="*"
+/

import std.stdio : writeln;

import sparkles.base.term_style;

void main()
{
    // Runtime styling
    writeln("Error: ".stylize(Style.red) ~ "something went wrong");

    // Compile-time styling via fluent builder
    enum title = "Important".stylizedTextBuilder(true).bold.underline.red;
    writeln(title);
}

#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_tables"
    dependency "sparkles:core-cli" version="*"
+/

import std.stdio : writeln;

import sparkles.ui.components.table;

void main()
{
    drawTable([
        ["Name",    "Status",  "Load"],
        ["web-01",  "UP",      "23%"],
        ["web-02",  "UP",      "45%"],
        ["db-01",   "DOWN",    "0%" ],
    ]).writeln;
}

#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_table_spans"
    dependency "sparkles:core-cli" version="*"
+/

import std.stdio : write;

import sparkles.ui.components.table;
import sparkles.base.text.width : Align;

void main()
{
    drawTable([
        [Cell("Quarterly Sales", colSpan: 3)],
        [Cell("Region"), Cell("Q1"), Cell("Q2")],
        [Cell("North"), Cell("1200"), Cell("1350")],
        [Cell("South"), Cell("98"), Cell("110")],
    ], TableProps(
        columnAligns: [Align.left, Align.right, Align.right],
        headerRows: 2, // banner + column-label row
        headerCols: 1, // the Region stub column
    )).write;
}

#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_boxes"
    dependency "sparkles:core-cli" version="*"
+/

import std.stdio : writeln;

import sparkles.ui.components.box;

void main()
{
    drawBox(
        ["Build started at 14:32:01",
         "Compiling 42 modules...",
         "Linking executable...",
         "Build completed in 3.2s"],
        "Build Log",
        BoxProps(footer: "Success"),
    ).writeln;
}

#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_headers"
    dependency "sparkles:core-cli" version="*"
+/

import std.stdio : writeln;

import sparkles.ui.components.header;

void main()
{
    // Divider style:  ── Section Title ──
    "Section Title".drawHeader.writeln;

    // Banner style
    "Main Title".drawHeader(HeaderProps(
        style: HeaderStyle.banner,
        lineChar: '═',
        width: 40,
    )).writeln;
}

#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_osc_link"
    dependency "sparkles:core-cli" version="*"
+/

import std.stdio : writeln;

import sparkles.ui.components.osc_link;
import sparkles.base.term_style : Style;

void main()
{
    // Plain clickable link
    writeln(oscLink(text: "Example", uri: "https://example.com"));

    // Styled clickable link (blue text)
    writeln(oscLink(text: "D Language", uri: "https://dlang.org", style: Style.blue));
}

#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_meters"
    dependency "sparkles:core-cli" version="*"
+/

import std.stdio : writeln;

import sparkles.ui.components.meter : meter, ProgressBar;

void main()
{
    writeln("|", meter(0.33, 16), "|");
    writeln("|", meter(7, 9, 16), "|");
    writeln(ProgressBar(done: 5, total: 40, barWidth: 16));
}

#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_tree"
    dependency "sparkles:core-cli" version="*"
+/

import std.stdio : writeln;

import sparkles.ui.components.tree : renderTree, TreeNode;

void main()
{
    foreach (line; renderTree([
        TreeNode("apps", 0),
        TreeNode("ci", 1),
        TreeNode("release", 1),
        TreeNode("src", 2),
        TreeNode("libs", 0),
    ]))
        writeln(line);
}

#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_tasklist"
    dependency "sparkles:core-cli" version="*"
+/

import std.stdio : writeln;

import sparkles.ui.components.tasklist : renderTaskList, TaskItem, TaskStatus;
import sparkles.ui.components.theme : Theme;

void main()
{
    // The pure renderer (a real app drives TaskReporter over a LiveRegion —
    // see libs/core-cli/examples/live-tasklist.d for the animated version).
    auto items = [
        TaskItem(label: "fetch dependencies", status: TaskStatus.ok),
        TaskItem(label: "build", status: TaskStatus.running,
            tail: ["compiling module 11", "compiling module 12"]),
        TaskItem(label: "publish", status: TaskStatus.pending),
    ];
    foreach (line; renderTaskList(items, Theme(colors: false)))
        writeln(line);
}

#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_layout"
    dependency "sparkles:core-cli" version="*"
+/

import std.stdio : writeln;

import sparkles.ui.components.box : BoxProps, drawBox;
import sparkles.ui.components.layout : hjoin, kvList;

void main()
{
    auto receipt = kvList([
        ["tag", "v0.6.0 (annotated)"],
        ["pushed", "origin ✔"],
    ]);
    writeln(hjoin([
        drawBox(receipt, "released", BoxProps(footer: "next: publish")),
        "notes:\n2 feats\n1 fix",
    ]));
}

#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_prompts"
    dependency "sparkles:core-cli" version="*"
+/

import std.stdio : writefln;

import sparkles.core_cli.prompts;
import sparkles.base.term_caps : isTerminal, StdStream;

void main()
{
    // Interactive on a terminal; silently takes the defaults when piped
    // (which is how this example runs under CI).
    const policy = isTerminal(StdStream.stdin)
        ? PromptPolicy.interactive : PromptPolicy.takeDefault;
    auto io = stdioPromptIo();

    auto bump = select("Version bump:", [
        SelectOption("patch", "v0.5.0 → v0.5.1"),
        SelectOption("minor", "v0.5.0 → v0.6.0  (suggested)"),
        SelectOption("major", "v0.5.0 → v1.0.0"),
    ], 1, policy, io);
    auto go = confirm("Push to origin?", defaultYes: true, policy, io);
    writefln!"bump=%s push=%s"(bump.value + 1, go.value);
}

#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_logger"
    dependency "sparkles:base" version="*"
+/

import std.logger : log, LogLevel;

import sparkles.base.logger : initLogger;

void main()
{
    initLogger(LogLevel.trace);

    log(LogLevel.info, "Listening on port 8080");
    log(LogLevel.warning, "Disk usage above 80%");
    log(LogLevel.error, "Connection to database lost");
}

import sparkles.base.smallbuffer;

@safe pure nothrow @nogc
unittest {
    SmallBuffer!(char, 64) buf;
    buf ~= "Hello";
    buf ~= ' ';
    buf ~= "World";
    assert(buf[] == "Hello World");
    assert(!buf.onHeap);  // still using inline storage
}

import sparkles.base.lifetime;

@nogc void validate(int x) {
    if (x < 0)
        throw recycledInstance!Error("value must be non-negative");
}

#!/usr/bin/env dub
/+ dub.sdl:
    name "readme_test_runner"
    dependency "sparkles:test-runner" version="*"
+/
import sparkles.test_runner.attributes : benchmark, betterC, ctfe;
import sparkles.test_runner.bench : blackBox, computeStats;

@("digits.parity")
@betterC @safe pure nothrow @nogc
unittest // runs under `dub test` — and without druntime via `--better-c`
{
    int parity;
    foreach (c; "12345")
        parity ^= c - '0';
    assert(parity == 1);
}

@("digits.parity.ct")
@ctfe @safe pure nothrow @nogc
unittest // runs while the test build compiles; never at runtime
{
    assert((1 ^ 2 ^ 3 ^ 4 ^ 5) == 1);
}

void main()
{
    import std.stdio : writefln;

    // The statistics `--bench` reports, over hand-made ns/iter samples so
    // this example's output is deterministic:
    const stats = computeStats("demo", 1000, [22.0, 18.0, 20.0]);
    writefln!"median=%.0fns/iter min=%.0f max=%.0f over %s samples"(
        stats.nsPerIterMedian, stats.nsPerIterMin, stats.nsPerIterMax,
        stats.samples);

    // blackBox is the optimizer barrier used inside @benchmark tests.
    assert(blackBox(21) * 2 == 42);
}