/*  Starshatter: The Open Source Project
    Copyright (c) 2021-2024, Starshatter: The Open Source Project Contributors
    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
    Copyright (c) 1997-2006, Destroyer Studios LLC.

    AUTHOR:       John DiCamillo


    OVERVIEW
    ========
    View class for Quantum Destination HUD Overlay
*/

#include "QuantumView.h"
#include "QuantumDrive.h"
#include "HUDView.h"
#include "Ship.h"
#include "Element.h"
#include "Sim.h"
#include "StarSystem.h"
#include "FormatUtil.h"

#include "Color.h"
#include "Window.h"
#include "Video.h"
#include "Screen.h"
#include "Scene.h"
#include "Font.h"
#include "FontMgr.h"
#include "Keyboard.h"
#include "Mouse.h"
#include "Clock.h"
#include "ContentBundle.h"
#include "Menu.h"

static Color  hud_color = Color::Black;

// +====================================================================+
//
// QUANTUM DRIVE DESTINATION MENU:
//

static Menu*         quantum_menu   = 0;
static bool          show_menu      = false;

void
QuantumView::Initialize()
{
    static int initialized = 0;
    if (initialized) return;

    quantum_menu = new Menu(ContentBundle::GetInstance()->GetText("QuantumView.menu"));

    initialized = 1;
}

void
QuantumView::Close()
{
    delete quantum_menu;
}

// +====================================================================+

QuantumView* QuantumView::quantum_view = 0;

QuantumView::QuantumView(Window* c)
: View(c), sim(0), ship(0), font(0)
{
    quantum_view  = this;
    sim         = Sim::GetSim();

    width       = window->Width();
    height      = window->Height();
    xcenter     = (width  / 2.0) - 0.5;
    ycenter     = (height / 2.0) + 0.5;
    font        = FontMgr::Find("HUD");

    HUDView* hud = HUDView::GetInstance();
    if (hud)
    SetColor(hud->GetTextColor());
}

QuantumView::~QuantumView()
{
    quantum_view = 0;
}

void
QuantumView::OnWindowMove()
{
    width       = window->Width();
    height      = window->Height();
    xcenter     = (width  / 2.0) - 0.5;
    ycenter     = (height / 2.0) + 0.5;
}

// +--------------------------------------------------------------------+

bool
QuantumView::Update(SimObject* obj)
{
    if (obj == ship)
    ship = 0;

    return SimObserver::Update(obj);
}

const char*
QuantumView::GetObserverName() const
{
    return "QuantumView";
}

// +--------------------------------------------------------------------+

void
QuantumView::Refresh()
{
    sim = Sim::GetSim();

    if (sim && ship != sim->GetPlayerShip()) {
        ship = sim->GetPlayerShip();

        if (ship) {
            if (ship->Life() == 0 || ship->IsDying() || ship->IsDead()) {
                ship = 0;
            }
            else {
                Observe(ship);
            }
        }
    }

    if (IsMenuShown()) {
        Rect menu_rect(width-115, 10, 115, 12);

        font->SetColor(hud_color);
        font->SetAlpha(1);
        font->DrawText(quantum_menu->GetTitle(), 0, menu_rect, DT_CENTER);

        menu_rect.y += 15;

        ListIter<MenuItem> item = quantum_menu->GetItems();
        while (++item) {
            item->SetEnabled(true);

            font->DrawText(item->GetText(), 0, menu_rect, DT_LEFT);
            menu_rect.y += 10;
        }
    }
}

// +--------------------------------------------------------------------+

void
QuantumView::ExecFrame()
{
    HUDView* hud = HUDView::GetInstance();
    if (hud) {
        if (hud_color != hud->GetTextColor()) {
            hud_color = hud->GetTextColor();
            SetColor(hud_color);
        }
    }

    static double time_til_change = 0;

    if (time_til_change > 0)
    time_til_change -= Clock::GetInstance()->GuiDelta();

    if (time_til_change <= 0) {
        time_til_change = 0;

        if (show_menu) {
            QuantumDrive* quantum_drive = 0;

            if (ship)
            quantum_drive = ship->GetQuantumDrive();

            if (quantum_drive && quantum_drive->ActiveState() != QuantumDrive::ACTIVE_READY) {
                show_menu = false;
                return;
            }

            int max_items = quantum_menu->NumItems();

            for (int i = 0; i < max_items; i++) {
                if (Keyboard::KeyDown('1' + i)) {
                    MenuItem* item = quantum_menu->GetItem(i);
                    if (item && item->GetEnabled()) {

                        SimRegion*  rgn = (SimRegion*) item->GetData();

                        if (rgn) {
                            quantum_drive->SetDestination(rgn, Point(0,0,0));
                            quantum_drive->Engage();
                        }

                        show_menu = false;
                        time_til_change = 0.3;
                        break;
                    }
                }
            }
        }
    }
}

// +--------------------------------------------------------------------+

void
QuantumView::SetColor(Color c)
{
    hud_color = c;
}

// +--------------------------------------------------------------------+

bool
QuantumView::IsMenuShown()
{
    return show_menu;
}

void
QuantumView::ShowMenu()
{
    if (!ship) return;

    if (!show_menu) {
        if (ship->IsStarship() && ship->GetQuantumDrive()) {
            GetQuantumMenu(ship);
            show_menu = true;
        }

        for (int i = 0; i < 10; i++) {
            if (Keyboard::KeyDown('1' + i)) {
                // just need to clear the key down flag
                // so we don't process old keystrokes
                // as valid menu picks...
            }
        }
    }
}

void
QuantumView::CloseMenu()
{
    show_menu = false;
}

// +--------------------------------------------------------------------+

Menu*
QuantumView::GetQuantumMenu(Ship* s)
{
    if (s && sim) {
        if (s->IsStarship()) {
            quantum_menu->ClearItems();

            SimRegion*  current_region = ship->GetRegion();

            if (!current_region) return 0;

            StarSystem* current_system = current_region->System();

            List<SimRegion> rgn_list;

            ListIter<SimRegion> iter = sim->GetRegions();
            while (++iter) {
                SimRegion*  rgn = iter.value();
                StarSystem* rgn_system = rgn->System();

                if (rgn != ship->GetRegion() && !rgn->IsAirSpace() &&
                        rgn_system == current_system) {
                    rgn_list.append(rgn);
                }
            }

            // sort local regions by distance from star:
            rgn_list.sort();

            // now add regions in other star systems:
            iter.reset();
            while (++iter) {
                SimRegion*  rgn = iter.value();
                StarSystem* rgn_system = rgn->System();

                if (rgn != ship->GetRegion() && rgn->Type() != SimRegion::AIR_SPACE &&
                        rgn_system != current_system && current_region->Links().contains(rgn)) {
                    rgn_list.append(rgn);
                }
            }

            int n = 1;
            iter.attach(rgn_list);
            while (++iter) {
                SimRegion*  rgn = iter.value();
                StarSystem* rgn_system = rgn->System();
                char text[64];

                if (rgn_system != current_system)
                sprintf_s(text, "%d. %s/%s", n++, rgn_system->Name(), rgn->Name());
                else
                sprintf_s(text, "%d. %s", n++, rgn->Name());

                quantum_menu->AddItem(text, (DWORD) rgn);
            }

            return quantum_menu;
        }
    }

    return 0;
}