#include "core/rendering/notifier.hpp"

#include <algorithm>
#include <numeric>
#include <utility>

#include "core/rendering/hud_constants.hpp"
#include "core/rendering/screen.hpp"
#include "core/rendering/text.hpp"
#include "core/ui/ui_config.hpp"
#include "utils/defines.hpp"

namespace {

    // Parteix `text` en una llista de línies que caben cadascuna dins
    // Trenca una "paraula" llarga (sense espais) en trossos contigus
    // que càpiguen a `max_width`. Si un sol caràcter ja excedeix
    // (font enorme), el deixa sol per garantir progrés. La part final
    // que encara cap queda a `current` per a fusionar-se amb paraules
    // posteriors via espai.
    void hardWrapWord(const std::string& word, int max_width, const Text& font, int kerning, std::vector<std::string>& lines, std::string& current) {
        std::string buf;
        for (char c : word) {
            std::string candidate = buf;
            candidate += c;
            if (buf.empty() || font.length(candidate, kerning) <= max_width) {
                buf = std::move(candidate);
            } else {
                lines.push_back(buf);
                buf = std::string(1, c);
            }
        }
        current = std::move(buf);
    }

    // Posa la `word` a la `current` line si hi cap (amb separador
    // implícit si current no està buida), o fa flush + reintenta a
    // línia neta. Si tampoc cap sola, hard-wrap caràcter a caràcter.
    void appendWord(const std::string& word, int max_width, const Text& font, int kerning, std::vector<std::string>& lines, std::string& current) {
        if (!current.empty()) {
            std::string candidate = current;
            candidate += ' ';
            candidate += word;
            if (font.length(candidate, kerning) <= max_width) {
                current = std::move(candidate);
                return;
            }
            lines.push_back(current);
            current.clear();
        }
        if (font.length(word, kerning) <= max_width) {
            current = word;
        } else {
            hardWrapWord(word, max_width, font, kerning, lines, current);
        }
    }

    // `max_width`. Tall per espais; les paraules més llargues que
    // `max_width` (rutes, URLs...) es trenquen caràcter a caràcter
    // — sense això, una caixa que excedís el canvas faria que
    // `fillRect` rebés rangs invertits i petés.
    auto wrapToWidth(const std::string& text, int max_width, const Text& font, int kerning) -> std::vector<std::string> {
        std::vector<std::string> lines;
        if (text.empty()) {
            lines.emplace_back();
            return lines;
        }

        std::string current;
        std::size_t i = 0;
        while (i < text.size()) {
            const std::size_t SPACE_POS = text.find(' ', i);
            const bool LAST = (SPACE_POS == std::string::npos);
            const std::string WORD = text.substr(i, LAST ? std::string::npos : SPACE_POS - i);
            appendWord(WORD, max_width, font, kerning, lines, current);
            if (LAST) { break; }
            i = SPACE_POS + 1;
        }

        if (!current.empty()) { lines.push_back(current); }
        return lines;
    }

}  // namespace

auto Notifier::get() -> Notifier& {
    static Notifier instance_;
    return instance_;
}

Notifier::~Notifier() = default;

void Notifier::init(std::shared_ptr<Text> text, const Palette& ui_palette) {
    text_ = std::move(text);
    ui_palette_ = ui_palette;
}

void Notifier::update(int delta_ms) {
    const auto& geo = UiConfig::get().notifier();
    switch (status_) {
        case Status::RISING: {
            slide_elapsed_ms_ += delta_ms;
            if (slide_elapsed_ms_ >= geo.slide_ms) {
                y_ = slide_y_on_;
                status_ = Status::ACTIVE;
            } else {
                const float T = static_cast<float>(slide_elapsed_ms_) / static_cast<float>(geo.slide_ms);
                const float K = geo.slide_in_curve(T);
                y_ = slide_y_off_ + ((slide_y_on_ - slide_y_off_) * K);
            }
            break;
        }
        case Status::ACTIVE:
            remaining_ms_ -= delta_ms;
            if (remaining_ms_ <= 0) {
                slide_elapsed_ms_ = 0;
                status_ = Status::VANISHING;
            }
            break;
        case Status::VANISHING: {
            slide_elapsed_ms_ += delta_ms;
            if (slide_elapsed_ms_ >= geo.slide_ms) {
                y_ = slide_y_off_;
                status_ = Status::HIDDEN;
            } else {
                const float T = static_cast<float>(slide_elapsed_ms_) / static_cast<float>(geo.slide_ms);
                const float K = geo.slide_out_curve(T);
                y_ = slide_y_on_ + ((slide_y_off_ - slide_y_on_) * K);
            }
            break;
        }
        default:
            break;
    }
}

void Notifier::render() {
    if (status_ == Status::HIDDEN || text_ == nullptr || current_lines_.empty()) { return; }

    const auto& geo = UiConfig::get().notifier();
    const int BOX_X = (GameCanvas::WIDTH - current_box_w_) / 2;
    const int BOX_Y = static_cast<int>(y_);

    // Fons sòlid amb la paleta UI que ens ha injectat el caller a init()
    // (ARGB directe al canvas, sense tocar cap surface paletada).
    Screen::get().fillRect(BOX_X, BOX_Y, current_box_w_, current_box_h_, ui_palette_[current_bg_color_]);

    // Vora externa: 4 línies d'1 px del color del text, paral·leles a cada
    // costat i una mica fora de la caixa. Cada segment es queda dins del
    // rang del costat corresponent perquè les cantonades no es cobrisquen.
    const std::uint32_t BORDER_ARGB = ui_palette_[current_text_color_];
    Screen::get().fillRect(BOX_X, BOX_Y - geo.border_px, current_box_w_, geo.border_px, BORDER_ARGB);
    Screen::get().fillRect(BOX_X, BOX_Y + current_box_h_, current_box_w_, geo.border_px, BORDER_ARGB);
    Screen::get().fillRect(BOX_X - geo.border_px, BOX_Y, geo.border_px, current_box_h_, BORDER_ARGB);
    Screen::get().fillRect(BOX_X + current_box_w_, BOX_Y, geo.border_px, current_box_h_, BORDER_ARGB);

    const int LINE_STEP = Rendering::Hud::FONT_SIZE_PX + geo.line_gap;
    int line_y = BOX_Y + geo.padding_top;
    for (const auto& line : current_lines_) {
        text_->writeDX(Text::CENTER_FLAG | Text::COLOR_FLAG,
            GameCanvas::CENTER_X,
            line_y,
            line,
            1,
            current_text_color_);
        line_y += LINE_STEP;
    }
}

void Notifier::notify(const std::string& text, Uint8 text_color, Uint8 bg_color, int time_ms) {
    // Política simple: la nova notificació reemplaça la que hi havia. Per
    // gestionar-ne una cua, canviar ací per una FIFO quan calga.
    if (text_ == nullptr) { return; }

    const auto& geo = UiConfig::get().notifier();
    const int MAX_TEXT_WIDTH = GameCanvas::WIDTH - (2 * SIDE_MARGIN) - (2 * geo.padding_h);
    current_lines_ = wrapToWidth(text, MAX_TEXT_WIDTH, *text_, 1);

    // Amplada = max de les línies + padding. Alçada = N*glif + (N-1)*gap + padding asimètric.
    const int MAX_LINE_W = std::accumulate(current_lines_.begin(), current_lines_.end(), 0, [this](int acc, const std::string& s) { return std::max(acc, text_->length(s, 1)); });
    current_box_w_ = MAX_LINE_W + (2 * geo.padding_h);

    const int N = static_cast<int>(current_lines_.size());
    current_box_h_ = (N * Rendering::Hud::FONT_SIZE_PX) + ((N - 1) * geo.line_gap) + geo.padding_top + geo.padding_bottom;

    current_text_color_ = text_color;
    current_bg_color_ = bg_color;
    remaining_ms_ = time_ms;

    // Posicions extremes en y (top-left de la caixa). Off = totalment fora
    // del canvas per dalt; On = posició final amb la vora respectada.
    slide_y_off_ = static_cast<float>(-current_box_h_ - geo.border_px - geo.margin_top);
    slide_y_on_ = static_cast<float>(geo.margin_top + geo.border_px);
    slide_elapsed_ms_ = 0;
    y_ = slide_y_off_;
    status_ = Status::RISING;
}