// mcpp.ui — verb-style colored status output.
//
// All user-visible status lines from CLI / fetcher / build go through
// here. TTY auto-detect; MCPP_NO_COLOR / --no-color disables colors.

module;
#include <cstdio>      // fileno, stdout

export module mcpp.ui;

import std;
import mcpp.platform;

export namespace mcpp::ui {

// One-time initialization. Call once at program start.
void init();

// Force-disable color. Useful for --no-color flag handling.
void disable_color();

// Check if color is enabled.
bool is_color_enabled();

// Verb-style status ("Compiling foo v0.1.0" pattern).
//   verb        verb word, padded right-aligned in 12-char column
//   message     metadata after the verb
void status(std::string_view verb, std::string_view message);

// Cyan verb (Updating, Downloading, Cleaned).
void info(std::string_view verb, std::string_view message);

// Bold green Finished line.
void finished(std::string_view profile, std::chrono::milliseconds elapsed);

// "warning:" / "error:" prefix lines (yellow / red).
void warning(std::string_view message);
void error(std::string_view message);

// Multi-line Rust-style diagnostic (M4 #8.1).
// Renders as:
//
//   error[E0001]: <title>
//     --> path:line
//      |
//   <line> | <source line>
//      |   ^^^^ <span message>
//      |
//      = note: <note>
//      = help: <help>
//      = help: see `mcpp --explain E0001` for more details
//
// Empty fields are omitted.
struct Diagnostic {
    std::string                      code;          // e.g. "E0001" (optional)
    std::string                      title;
    std::filesystem::path           path;
    std::size_t                      line   = 0;
    std::size_t                      column = 0;
    std::string                      sourceLine;   // optional snippet
    std::string                      spanMessage;  // points at column
    std::vector<std::string>         notes;
    std::vector<std::string>         helps;
};
void diagnostic(const Diagnostic& d);

// Plain output (no verb), respecting -q flag.
void plain(std::string_view message);

// --- progress bar (single-line, \r-rewritten) ---
class ProgressBar {
public:
    ProgressBar(std::string_view verb, std::string_view label);
    ~ProgressBar();

    ProgressBar(const ProgressBar&) = delete;
    ProgressBar& operator=(const ProgressBar&) = delete;

    // Update progress; renders only once per ~50ms to avoid jitter.
    void update(std::size_t percent);
    // elapsed_sec, when > 0, drives a `~X.Y MB/s` average-rate suffix.
    void update_bytes(std::size_t current_bytes, std::size_t total_bytes,
                      double elapsed_sec = 0.0);

    // Finish: replaces progress with final-state line.
    void finish();
    void finish_with(std::string_view final_message);

private:
    void render_line(std::size_t percent, const std::string& info_text);

    std::string verb_;
    std::string label_;
    std::chrono::steady_clock::time_point lastDraw_;
    bool finished_ = false;
};

// --- quiet flag (suppresses status / info / finished) ---
void set_quiet(bool q);
bool is_quiet();

// --- path display ---
//
// Path shortening for status output. Long absolute paths under the project
// root, MCPP_HOME, or the user's home directory get rewritten to short
// relative forms so the user can see _what_ rather than _where_.
//
// Substitution rules (most specific wins):
//   <project_root>/x/y/z   →  x/y/z              (project-relative)
//   <mcpp_home>/x/y/z      →  @mcpp/x/y/z
//   <home>/x/y/z           →  ~/x/y/z
//   anything else          →  absolute path
//
// `project_root` is optional — leave empty when the caller doesn't have a
// project context (e.g. for `mcpp self env`).
struct PathContext {
    std::filesystem::path project_root;
    std::filesystem::path mcpp_home;
    std::filesystem::path home;
};
std::string shorten_path(const std::filesystem::path& p, const PathContext& ctx);

} // namespace mcpp::ui

namespace mcpp::ui {

namespace {

bool g_color  = false;
bool g_quiet  = false;
bool g_inited = false;

constexpr std::string_view kReset      = "\033[0m";
constexpr std::string_view kBold       = "\033[1m";
constexpr std::string_view kGreen      = "\033[32m";
constexpr std::string_view kBrightGreen= "\033[92m";
constexpr std::string_view kCyan       = "\033[36m";
constexpr std::string_view kBrightCyan = "\033[96m";
constexpr std::string_view kYellow     = "\033[33m";
constexpr std::string_view kRed        = "\033[31m";
constexpr std::string_view kBrightRed  = "\033[91m";

bool detect_color() {
    if (auto* e = std::getenv("MCPP_NO_COLOR"); e && *e == '1') return false;
    if (auto* e = std::getenv("NO_COLOR");      e && *e)        return false;
    return mcpp::platform::terminal::is_tty();
}

std::string with_color(std::string_view code, std::string_view text) {
    if (!g_color) return std::string(text);
    std::string out;
    out.reserve(code.size() + text.size() + kReset.size());
    out.append(code).append(text).append(kReset);
    return out;
}

std::string verb_padded(std::string_view verb) {
    constexpr std::size_t W = 12;
    if (verb.size() >= W) return std::string(verb);
    std::string s(W - verb.size(), ' ');
    s.append(verb);
    return s;
}

} // namespace

void init() {
    if (g_inited) return;
    g_color  = detect_color();
    g_inited = true;
}

void disable_color() { g_color = false; }
bool is_color_enabled() { return g_color; }

void set_quiet(bool q) { g_quiet = q; }
bool is_quiet()        { return g_quiet; }

void status(std::string_view verb, std::string_view message) {
    if (g_quiet) return;
    init();
    auto v = verb_padded(verb);
    if (g_color) {
        std::println("{}{}{}{} {}",
                     kBold, kBrightGreen, v, kReset, message);
    } else {
        std::println("{} {}", v, message);
    }
}

void info(std::string_view verb, std::string_view message) {
    if (g_quiet) return;
    init();
    auto v = verb_padded(verb);
    if (g_color) {
        std::println("{}{}{}{} {}",
                     kBold, kBrightCyan, v, kReset, message);
    } else {
        std::println("{} {}", v, message);
    }
}

void finished(std::string_view profile, std::chrono::milliseconds elapsed) {
    if (g_quiet) return;
    init();
    auto v = verb_padded("Finished");
    auto secs = static_cast<double>(elapsed.count()) / 1000.0;
    auto msg  = std::format("{} [optimized] in {:.2f}s", profile, secs);
    if (g_color) {
        std::println("{}{}{}{} {}",
                     kBold, kBrightGreen, v, kReset, msg);
    } else {
        std::println("{} {}", v, msg);
    }
}

void warning(std::string_view message) {
    init();
    if (g_color) {
        std::println(stderr, "{}{}warning:{} {}", kBold, kYellow, kReset, message);
    } else {
        std::println(stderr, "warning: {}", message);
    }
}

void error(std::string_view message) {
    init();
    if (g_color) {
        std::println(stderr, "{}{}error:{} {}", kBold, kBrightRed, kReset, message);
    } else {
        std::println(stderr, "error: {}", message);
    }
}

void plain(std::string_view message) {
    if (g_quiet) return;
    std::println("{}", message);
}

void diagnostic(const Diagnostic& d) {
    init();
    auto bold_red = [&](std::string_view s) {
        return g_color ? std::format("{}{}{}{}", kBold, kBrightRed, s, kReset)
                       : std::string(s);
    };
    auto blue = [&](std::string_view s) {
        return g_color ? std::format("{}{}{}{}", kBold, kBrightCyan, s, kReset)
                       : std::string(s);
    };
    std::string head = "error";
    if (!d.code.empty()) head += "[" + d.code + "]";
    head += ":";
    std::println(stderr, "{} {}", bold_red(head), d.title);

    if (!d.path.empty()) {
        if (d.line)
            std::println(stderr, "  {} {}:{}{}",
                blue("-->"), d.path.string(), d.line,
                d.column ? std::format(":{}", d.column) : "");
        else
            std::println(stderr, "  {} {}", blue("-->"), d.path.string());
    }

    if (!d.sourceLine.empty()) {
        std::println(stderr, "   {}", blue("|"));
        std::println(stderr, " {} {} {}",
            d.line ? std::format("{:>2}", d.line) : "  ", blue("|"), d.sourceLine);
        if (!d.spanMessage.empty()) {
            std::string caret(d.column ? d.column - 1 : 0, ' ');
            caret += "^";
            std::println(stderr, "   {} {} {}", blue("|"), caret, d.spanMessage);
        }
    }

    if (!d.notes.empty() || !d.helps.empty()) {
        std::println(stderr, "   {}", blue("|"));
    }
    for (auto& n : d.notes) {
        std::println(stderr, "   {} {}: {}", blue("="), blue("note"), n);
    }
    for (auto& h : d.helps) {
        std::println(stderr, "   {} {}: {}", blue("="), blue("help"), h);
    }
    if (!d.code.empty()) {
        std::println(stderr, "");
        std::println(stderr, "For more information on this error: `mcpp --explain {}`",
                     d.code);
    }
}

// --- ProgressBar ---

namespace {

std::string render_bar(std::size_t percent, std::size_t width = 20) {
    auto filled = (percent * width) / 100;
    if (filled > width) filled = width;
    std::string bar = "[";
    for (std::size_t i = 0; i < filled; ++i)        bar += "=";
    if (filled < width)                              bar += ">";
    for (std::size_t i = filled + 1; i < width; ++i) bar += " ";
    bar += "]";
    return bar;
}

std::string fmt_bytes(std::size_t b) {
    if (b < 1024)              return std::format("{} B",   b);
    if (b < 1024 * 1024)       return std::format("{} KB",  b / 1024);
    if (b < 1024UL*1024*1024)  return std::format("{:.1f} MB", static_cast<double>(b) / (1024.0*1024.0));
    return std::format("{:.2f} GB", static_cast<double>(b) / (1024.0*1024.0*1024.0));
}

// Best-effort terminal width. Tries TIOCGWINSZ first; on failure (e.g.,
// stdout is a pipe) honours $COLUMNS so users can clamp the width
// manually for testing or when running under CI loggers that don't
// propagate winsize. Falls back to 80 cols.
//
// 80 is the right safe default for a "fixed-shape" status line — we'd
// rather collapse the bar than wrap into a second row that `\r\033[2K`
// can't clean up later.
std::size_t terminal_cols() {
    return mcpp::platform::terminal::cols();
}

// Truncate a "visible" string (no ANSI codes inside) to `max` chars, replacing
// the last char with `…` when we cut. Used to keep the progress line under
// terminal width without wrapping into a second row.
std::string trunc_visible(std::string s, std::size_t max) {
    if (s.size() <= max) return s;
    if (max == 0) return std::string{};
    if (max == 1) { s.resize(1); return s; }
    s.resize(max - 1);
    s += "…";  // 3-byte UTF-8 char in a single visible column — harmless
    return s;
}

} // namespace

ProgressBar::ProgressBar(std::string_view verb, std::string_view label)
    : verb_(verb), label_(label),
      lastDraw_(std::chrono::steady_clock::now() - std::chrono::seconds(1))
{}

ProgressBar::~ProgressBar() {
    if (!finished_) finish();
}

// Render a single progress-bar frame. The verb is drawn separately (with
// optional color) so we can keep ANSI escapes out of the truncation budget.
// `cols` is the available terminal width; `info_text` is the trailing
// "%" / "X MB / Y MB / Z MB/s" suffix; `pct` drives the bar fill.
//
// Layout (visible chars only):
//   <verb-padded-12> <label> <bar> <info>
//
// The bar shrinks first when we run out of room, then `label` is truncated
// with an ellipsis. Result is always ≤ cols-1 chars so a `\r\033[2K{...}`
// write never wraps into a second row.
void ProgressBar::render_line(std::size_t pct, const std::string& info_text)
{
    init();
    constexpr std::size_t kVerbWidth = 12;
    constexpr std::size_t kBarMax    = 20;
    constexpr std::size_t kBarMin    = 6;

    auto cols = terminal_cols();
    if (cols < 30) cols = 30;             // pathological — give us a chance
    auto budget = cols - 1;               // leave one cell for cursor

    // Visible layout, accounting for `[…]` bracket chars on the bar:
    //   <verb-padded-12><space><label><space>[<bar-inner>]<space><info>
    //
    // Fixed cost = verbWidth + 3 spaces + 2 brackets + info.
    // Whatever's left in `contentBudget` is split between bar-inner and label.
    auto fixed = kVerbWidth + 3 + 2 + info_text.size();
    if (fixed >= budget) {
        // Truly tiny terminal — drop the bar entirely.
        auto labelBudget = budget > kVerbWidth + 1 + info_text.size() + 1
                         ? budget - kVerbWidth - 1 - info_text.size() - 1
                         : 0;
        auto lbl = trunc_visible(label_, labelBudget);
        if (g_color) {
            std::print("\r\033[2K{}{}{}{} {} {}",
                       kBold, kBrightCyan, verb_padded(verb_), kReset,
                       lbl, info_text);
        } else {
            std::print("\r\033[2K{} {} {}", verb_padded(verb_), lbl, info_text);
        }
        std::fflush(stdout);
        return;
    }
    auto contentBudget = budget - fixed;   // barInner + visible-label-cols

    std::size_t barW = std::min(kBarMax, contentBudget);
    std::size_t labelMax = contentBudget - barW;
    if (barW < kBarMin && labelMax > 0) {
        // Steal from label to keep at least a tiny bar.
        auto steal = std::min(kBarMin - barW, labelMax);
        barW += steal;
        labelMax -= steal;
    }
    auto bar = render_bar(pct, barW);
    auto lbl = trunc_visible(label_, labelMax);

    if (g_color) {
        std::print("\r\033[2K{}{}{}{} {} {} {}",
                   kBold, kBrightCyan, verb_padded(verb_), kReset,
                   lbl, bar, info_text);
    } else {
        std::print("\r\033[2K{} {} {} {}",
                   verb_padded(verb_), lbl, bar, info_text);
    }
    std::fflush(stdout);
}

void ProgressBar::update(std::size_t percent) {
    if (g_quiet || finished_) return;
    auto now = std::chrono::steady_clock::now();
    if (now - lastDraw_ < std::chrono::milliseconds(80) && percent < 100) return;
    lastDraw_ = now;
    render_line(percent, std::format("{}%", percent));
}

void ProgressBar::update_bytes(std::size_t current, std::size_t total,
                               double elapsed_sec) {
    if (g_quiet || finished_) return;
    auto now = std::chrono::steady_clock::now();
    auto pct = total ? (current * 100 / total) : 0;
    if (pct > 100) pct = 100;
    // Same throttle as update(): one render per ~80ms unless we hit 100%.
    if (now - lastDraw_ < std::chrono::milliseconds(80) && pct < 100) return;
    lastDraw_ = now;

    auto info = std::format("{} / {}", fmt_bytes(current), fmt_bytes(total));
    // Average rate since the download started. xlings only ships the
    // cumulative `elapsedSec`, so this is "since-start" rather than
    // a sliding-window instantaneous speed — accurate enough for UX.
    if (elapsed_sec > 0.5 && current > 0) {
        auto rate = static_cast<std::size_t>(
            static_cast<double>(current) / elapsed_sec);
        info += std::format("  {}/s", fmt_bytes(rate));
    }
    render_line(pct, info);
}

void ProgressBar::finish() {
    if (finished_) return;
    finished_ = true;
    if (g_quiet) return;
    // Clear the line and re-emit as a static info line.
    std::print("\r\033[2K");
    info(verb_, label_);
}

void ProgressBar::finish_with(std::string_view final_message) {
    if (finished_) return;
    finished_ = true;
    if (g_quiet) return;
    std::print("\r\033[2K");
    info(verb_, final_message);
}

std::string shorten_path(const std::filesystem::path& p, const PathContext& ctx) {
    namespace fs = std::filesystem;
    // Use a pure string-prefix comparison rather than fs::relative —
    // fs::relative internally canonicalises both arguments, which would
    // resolve symlinks. We want to display the path the user thinks they
    // are working with (e.g. `<MCPP_HOME>/registry/data/xpkgs/<pkg>` even
    // when xpkgs/ is symlinked to a system xlings cache), so we keep
    // every comparison purely lexical.
    auto can = p.lexically_normal().generic_string();

    auto rel_to = [&](const fs::path& base) -> std::optional<std::string> {
        if (base.empty()) return std::nullopt;
        auto bs = base.lexically_normal().generic_string();
        // Strip trailing slashes on the base so "/x/y" and "/x/y/" match
        // the same set of candidate paths.
        while (!bs.empty() && bs.back() == '/') bs.pop_back();
        if (bs.empty()) return std::nullopt;
        if (can == bs) return std::string{};
        if (can.size() > bs.size()
            && can.compare(0, bs.size(), bs) == 0
            && can[bs.size()] == '/') {
            return can.substr(bs.size() + 1);
        }
        return std::nullopt;
    };

    if (auto r = rel_to(ctx.project_root); r) {
        // Project-relative — print bare ("target/release/foo"), no prefix.
        return r->empty() ? std::string{"."} : *r;
    }
    if (auto r = rel_to(ctx.mcpp_home); r) {
        return r->empty() ? std::string{"@mcpp"} : "@mcpp/" + *r;
    }
    if (auto r = rel_to(ctx.home); r) {
        return r->empty() ? std::string{"~"} : "~/" + *r;
    }
    return can;
}

} // namespace mcpp::ui