/*
 * Copyright (c) 2022, Oleg Kosenkov <oleg@kosenkov.ca>
 * Copyright (c) 2022, the SerenityOS developers.
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include "ColorLines.h"
#include "HueFilter.h"
#include "Marble.h"
#include "MarbleBoard.h"
#include <AK/String.h>
#include <LibConfig/Client.h>
#include <LibGUI/MessageBox.h>
#include <LibGUI/Painter.h>
#include <LibGfx/Font/Emoji.h>

ColorLines::BitmapArray ColorLines::build_marble_color_bitmaps()
{
    auto marble_bitmap = MUST(Gfx::Bitmap::load_from_uri("resource://graphics/colorlines/colorlines.png"sv));
    float constexpr hue_degrees[Marble::number_of_colors] = {
        0,   // Red
        45,  // Brown/Yellow
        90,  // Green
        180, // Cyan
        225, // Blue
        300  // Purple
    };
    BitmapArray colored_bitmaps;
    colored_bitmaps.ensure_capacity(Marble::number_of_colors);
    for (int i = 0; i < Marble::number_of_colors; ++i) {
        auto bitmap = MUST(marble_bitmap->clone());
        HueFilter filter { hue_degrees[i] };
        filter.apply(*bitmap, bitmap->rect(), *marble_bitmap, marble_bitmap->rect());
        colored_bitmaps.append(bitmap);
    }
    return colored_bitmaps;
}

ColorLines::BitmapArray ColorLines::build_marble_trace_bitmaps()
{
    // Use "Paw Prints" Unicode Character (U+1F43E)
    auto trace_bitmap = NonnullRefPtr<Gfx::Bitmap const>(*Gfx::Emoji::emoji_for_code_point(0x1F43E));
    BitmapArray result;
    result.ensure_capacity(number_of_marble_trace_bitmaps);
    result.append(trace_bitmap);
    result.append(MUST(result.last()->rotated(Gfx::RotationDirection::Clockwise)));
    result.append(MUST(result.last()->rotated(Gfx::RotationDirection::Clockwise)));
    result.append(MUST(result.last()->rotated(Gfx::RotationDirection::Clockwise)));
    return result;
}

ColorLines::ColorLines(StringView app_name)
    : m_app_name { app_name }
    , m_game_state { GameState::Idle }
    , m_board { make<MarbleBoard>() }
    , m_marble_bitmaps { build_marble_color_bitmaps() }
    , m_trace_bitmaps { build_marble_trace_bitmaps() }
    , m_score_font { Gfx::BitmapFont::load_from_uri("resource://fonts/MarietaBold24.font"sv) }
{
    VERIFY(m_marble_bitmaps.size() == Marble::number_of_colors);
    set_font(Gfx::FontDatabase::default_fixed_width_font().bold_variant());
    m_high_score = Config::read_i32(m_app_name, m_app_name, "HighScore"sv, 0);
    reset();
}

void ColorLines::reset()
{
    set_game_state(GameState::StartingGame);
}

void ColorLines::mousedown_event(GUI::MouseEvent& event)
{
    if (m_game_state != GameState::Idle && m_game_state != GameState::MarbleSelected)
        return;
    auto const event_position = event.position().translated(
        -frame_inner_rect().x(),
        -frame_inner_rect().y() - board_vertical_margin);
    if (event_position.x() < 0 || event_position.y() < 0)
        return;
    auto const clicked_cell = Point { event_position.x() / board_cell_dimension.width(),
        event_position.y() / board_cell_dimension.height() };
    if (!MarbleBoard::in_bounds(clicked_cell))
        return;
    if (m_board->has_selected_marble()) {
        auto const selected_cell = m_board->selected_marble().position();
        if (selected_cell == clicked_cell) {
            m_board->reset_selection();
            set_game_state(GameState::Idle);
            return;
        }
        if (m_board->is_empty_cell_at(clicked_cell)) {
            if (m_board->build_marble_path(selected_cell, clicked_cell, m_marble_path))
                set_game_state(GameState::MarbleMoving);
            return;
        }
        if (m_board->select_marble(clicked_cell))
            set_game_state(GameState::MarbleSelected);
        return;
    }
    if (m_board->select_marble(clicked_cell))
        set_game_state(GameState::MarbleSelected);
}

void ColorLines::timer_event(Core::TimerEvent&)
{
    switch (m_game_state) {
    case GameState::GeneratingMarbles:
        update();
        if (--m_marble_animation_frame < AnimationFrames::marble_generating_end) {
            m_marble_animation_frame = AnimationFrames::marble_default;
            set_game_state(GameState::CheckingMarbles);
        }
        break;

    case GameState::MarbleSelected:
        m_marble_animation_frame = (m_marble_animation_frame + 1) % AnimationFrames::number_of_marble_bounce_frames;
        update();
        break;

    case GameState::MarbleMoving:
        m_marble_animation_frame = (m_marble_animation_frame + 1) % AnimationFrames::number_of_marble_bounce_frames;
        update();
        if (m_marble_path.remaining_steps() != 1 && m_marble_animation_frame != AnimationFrames::marble_at_top)
            break;
        if (auto const point = m_marble_path.next_point(); m_marble_path.is_empty()) {
            auto const color = m_board->selected_marble().color();
            m_board->reset_selection();
            m_board->set_color_at(point, color);
            if (m_board->check_and_remove_marbles())
                set_game_state(GameState::MarblesRemoving);
            else
                set_game_state(GameState::GeneratingMarbles);
        }
        break;

    case GameState::MarblesRemoving:
        update();
        if (++m_marble_animation_frame > AnimationFrames::marble_removing_end) {
            m_marble_animation_frame = AnimationFrames::marble_default;
            m_score += 2 * m_board->removed_marbles().size();
            set_game_state(GameState::Idle);
        }
        break;

    case GameState::StartingGame:
    case GameState::Idle:
    case GameState::CheckingMarbles:
        break;

    case GameState::GameOver: {
        stop_timer();
        update();
        StringBuilder text;
        text.appendff("Your score is {}", m_score);
        if (m_score > m_high_score) {
            text.append("\nThis is a new high score!"sv);
            Config::write_i32(m_app_name, m_app_name, "HighScore"sv, int(m_high_score = m_score));
        }
        GUI::MessageBox::show(window(),
            text.string_view(),
            "Game Over"sv,
            GUI::MessageBox::Type::Information);
        reset();
        break;
    }

    default:
        VERIFY_NOT_REACHED();
    }
}

void ColorLines::paint_event(GUI::PaintEvent& event)
{
    GUI::Frame::paint_event(event);
    GUI::Painter painter(*this);
    painter.add_clip_rect(frame_inner_rect());
    painter.add_clip_rect(event.rect());

    auto paint_cell = [&](GUI::Painter& painter, Gfx::IntRect rect, int color, int animation_frame) {
        painter.draw_rect(rect, Color::Black);
        rect.shrink(0, 2, 2, 0);
        painter.draw_line(rect.bottom_left(), rect.top_left(), Color::White);
        painter.draw_line(rect.top_left(), rect.top_right(), Color::White);
        painter.draw_line(rect.top_right(), rect.bottom_right(), Color::DarkGray);
        painter.draw_line(rect.bottom_right(), rect.bottom_left(), Color::DarkGray);
        rect.shrink(1, 1, 1, 1);
        painter.draw_line(rect.bottom_left(), rect.top_left(), Color::LightGray);
        painter.draw_line(rect.top_left(), rect.top_right(), Color::LightGray);
        painter.draw_line(rect.top_right(), rect.bottom_right(), Color::MidGray);
        painter.draw_line(rect.bottom_right(), rect.bottom_left(), Color::MidGray);
        painter.fill_rect(rect, tile_color);
        rect.shrink(1, 1, 1, 1);
        if (color >= 0 && color < Marble::number_of_colors) {
            auto const source_rect = Gfx::IntRect { animation_frame * marble_pixel_size, 0, marble_pixel_size, marble_pixel_size };
            painter.draw_scaled_bitmap(rect, *m_marble_bitmaps[color], source_rect,
                1.0f, Gfx::ScalingMode::BilinearBlend);
        }
    };

    painter.set_font(*m_score_font);

    // Draw board header with score, high score
    auto board_header_size = frame_inner_rect().size();
    board_header_size.set_height(board_vertical_margin);
    auto const board_header_rect = Gfx::IntRect { frame_inner_rect().top_left(), board_header_size };
    painter.fill_rect(board_header_rect, Color::Black);

    auto const text_margin = 8;

    // Draw score
    auto const score_text = MUST(String::formatted("{:05}"sv, m_score));
    auto text_width = static_cast<int>(ceilf(m_score_font->width(score_text)));
    auto const score_text_rect = Gfx::IntRect {
        frame_inner_rect().top_left().translated(text_margin),
        Gfx::IntSize { text_width, font().pixel_size_rounded_up() }
    };
    painter.draw_text(score_text_rect, score_text, Gfx::TextAlignment::CenterLeft, text_color);

    // Draw high score
    auto const high_score_text = MUST(String::formatted("{:05}"sv, m_high_score));
    text_width = m_score_font->width(high_score_text);
    auto const high_score_text_rect = Gfx::IntRect {
        frame_inner_rect().top_right().translated(-(text_margin + text_width) - 1, text_margin),
        Gfx::IntSize { text_width, font().pixel_size_rounded_up() }
    };
    painter.draw_text(high_score_text_rect, high_score_text, Gfx::TextAlignment::CenterLeft, text_color);

    auto const cell_rect
        = Gfx::IntRect(frame_inner_rect().top_left(), board_cell_dimension)
              .translated(0, board_vertical_margin);

    // Draw all cells and the selected marble if it exists
    for (int y = 0; y < MarbleBoard::board_size.height(); ++y)
        for (int x = 0; x < MarbleBoard::board_size.width(); ++x) {
            auto const& destination_rect = cell_rect.translated(
                x * board_cell_dimension.width(),
                y * board_cell_dimension.height());
            auto const point = Point { x, y };
            auto const animation_frame = m_game_state == GameState::MarbleSelected && m_board->has_selected_marble()
                    && m_board->selected_marble().position() == point
                ? m_marble_animation_frame
                : AnimationFrames::marble_default;
            paint_cell(painter, destination_rect, m_board->color_at(point), animation_frame);
        }

    // Draw preview marbles in the board
    for (auto const& marble : m_board->preview_marbles()) {
        auto const& point = marble.position();
        if (m_marble_path.contains(point) || !m_board->is_empty_cell_at(point))
            continue;
        auto const& destination_rect = cell_rect.translated(
            point.x() * board_cell_dimension.width(),
            point.y() * board_cell_dimension.height());
        auto get_animation_frame = [this]() -> int {
            switch (m_game_state) {
            case GameState::GameOver:
                return AnimationFrames::marble_default;
            case GameState::GeneratingMarbles:
            case GameState::CheckingMarbles:
                return m_marble_animation_frame;
            default:
                return AnimationFrames::marble_generating_start;
            }
        };
        paint_cell(painter, destination_rect, marble.color(), get_animation_frame());
    }

    // Draw preview marbles in the board header
    for (size_t i = 0; i < MarbleBoard::number_of_preview_marbles; ++i) {
        auto const& marble = m_board->preview_marbles()[i];
        auto const& destination_rect = cell_rect.translated(
                                                    int(i + 3) * board_cell_dimension.width(),
                                                    -board_vertical_margin)
                                           .shrunken(10, 10);
        paint_cell(painter, destination_rect, marble.color(), AnimationFrames::marble_preview);
    }

    // Draw moving marble
    if (!m_marble_path.is_empty()) {
        auto const point = m_marble_path.current_point();
        auto const& destination_rect = cell_rect.translated(
            point.x() * board_cell_dimension.width(),
            point.y() * board_cell_dimension.height());
        paint_cell(painter, destination_rect, m_board->selected_marble().color(), m_marble_animation_frame);
    }

    // Draw removing marble
    if (m_game_state == GameState::MarblesRemoving)
        for (auto const& marble : m_board->removed_marbles()) {
            auto const& point = marble.position();
            auto const& destination_rect = cell_rect.translated(
                point.x() * board_cell_dimension.width(),
                point.y() * board_cell_dimension.height());
            paint_cell(painter, destination_rect, marble.color(), m_marble_animation_frame);
        }

    // Draw marble move trace
    if (m_game_state == GameState::MarbleMoving && m_marble_path.remaining_steps() > 1) {
        auto const trace_size = Gfx::IntSize { m_trace_bitmaps.first()->width(), m_trace_bitmaps.first()->height() };
        auto const target_trace_size = Gfx::IntSize { 14, 14 };
        auto const source_rect = Gfx::FloatRect(Gfx::IntPoint {}, trace_size);
        for (size_t i = 0; i < m_marble_path.remaining_steps() - 1; ++i) {
            auto const& current_step = m_marble_path[i];
            auto const destination_rect = Gfx::IntRect(frame_inner_rect().top_left(), target_trace_size)
                                              .translated(
                                                  current_step.x() * board_cell_dimension.width(),
                                                  board_vertical_margin + current_step.y() * board_cell_dimension.height())
                                              .translated(
                                                  (board_cell_dimension.width() - target_trace_size.width()) / 2,
                                                  (board_cell_dimension.height() - target_trace_size.height()) / 2);
            auto get_direction_bitmap_index = [&]() -> size_t {
                auto const& previous_step = m_marble_path[i + 1];
                if (previous_step.x() > current_step.x())
                    return 3;
                if (previous_step.x() < current_step.x())
                    return 1;
                if (previous_step.y() > current_step.y())
                    return 0;
                return 2;
            };
            painter.draw_scaled_bitmap(destination_rect, *m_trace_bitmaps[get_direction_bitmap_index()], source_rect,
                1.0f, Gfx::ScalingMode::BilinearBlend);
        }
    }
}

void ColorLines::restart_timer(int milliseconds)
{
    stop_timer();
    start_timer(milliseconds);
}

void ColorLines::set_game_state(GameState state)
{
    m_game_state = state;
    switch (state) {
    case GameState::StartingGame:
        m_marble_path.reset();
        m_board->reset();
        m_score = 0;
        m_marble_animation_frame = AnimationFrames::marble_default;
        update();
        if (m_board->update_preview_marbles(false))
            set_game_state(GameState::GeneratingMarbles);
        else
            set_game_state(GameState::GameOver);
        break;
    case GameState::GeneratingMarbles:
        m_board->reset_selection();
        m_marble_animation_frame = AnimationFrames::marble_generating_start;
        update();
        if (m_board->ensure_all_preview_marbles_are_on_empty_cells())
            restart_timer(TimerIntervals::generating_marbles);
        else
            set_game_state(GameState::GameOver);
        break;
    case GameState::MarblesRemoving:
        m_marble_animation_frame = AnimationFrames::marble_removing_start;
        update();
        restart_timer(TimerIntervals::removing_marbles);
        break;
    case GameState::Idle:
        m_marble_animation_frame = AnimationFrames::marble_default;
        update();
        if (m_board->ensure_all_preview_marbles_are_on_empty_cells() && m_board->has_empty_cells())
            stop_timer();
        else
            set_game_state(GameState::GameOver);
        break;
    case GameState::MarbleSelected:
        restart_timer(TimerIntervals::selected_marble);
        m_marble_animation_frame = AnimationFrames::marble_default;
        update();
        break;
    case GameState::CheckingMarbles:
        m_marble_animation_frame = AnimationFrames::marble_default;
        update();
        if (!m_board->place_preview_marbles_on_board())
            set_game_state(GameState::GameOver);
        else if (m_board->check_and_remove_marbles())
            set_game_state(GameState::MarblesRemoving);
        else
            set_game_state(GameState::Idle);
        break;
    case GameState::MarbleMoving:
        restart_timer(TimerIntervals::moving_marble);
        m_board->clear_color_at(m_board->selected_marble().position());
        update();
        break;
    case GameState::GameOver:
        m_marble_animation_frame = AnimationFrames::marble_default;
        update();
        break;
    default:
        VERIFY_NOT_REACHED();
    }
}
