#pragma once

#include <vector>
#include <queue>
#include <string>

#include <iostream>

#include <glm/vec2.hpp>

#include "missile.hpp"

// TODO:
// give points for equipment / better weapons / more energy when:
// - player discovers the universe
//
// - the shot which made a kill was much longer than the direkt line between
//   player and his target
//
// - add wormholes
// - add blackholes
// - shoot through suns which add a fire mantle to the rocket to make it more
//   thick and dangerous but it gets destroyed after some time.

namespace game {
    // forward declarations
    class Command;
    class Player;
    class Planet;
    class Ship;
    class Trace;
    class Explosion;

    class State {
    public:
        /*************************************************************************/
        /* State management */
        /*************************************************************************/

        // called to setup the state (randomize planets, kill
        // traces/missiles/ships etc.)
        void init();

        // main method to advance the simulation by the given timestamp in
        // seconds.
        void advance(float dt);

        /*************************************************************************/
        /* Network / Input */
        /*************************************************************************/

        // The upper layer (network/renderer) calling these three functions
        // should keep id's unique and give one (network) input an id.
        int addPlayer();
        void clear(int playerId);
        void setName(int playerId, std::string name);
        void setSpeed(int playerId, double speed);
        void quitPlayer(int playerId);
        void commandForPlayer(int playerId, Command *cmd);

        // lookup. return nullptr on invalid playerId
        Player *playerForId(int playerId);

        /*************************************************************************/
        /* Mixed stuff */

        // distance after which missiles get lost in space (and explode)
        float maxMissileDistance() const { return m_maxMissileDistance; }

        // each ship has the same radius
        float shipRadius()         const { return m_shipRadius; }

        // add a trace to the list of traces.
        void addTrace(Trace *trace);

        // delete traces with this command
        void deleteTrace(Trace *trace); // using a pointer
        void deleteTrace(size_t index); // using an index

        /*************************************************************************/
        /* Rendering */
        /*************************************************************************/

        // Game items which should be rendered are here:
        // (access missiles by iterating over player's missiles attribute)
        std::vector<Planet*>    planets;
        std::vector<Ship*>      ships;
        std::vector<Player*>    players;
        std::vector<Trace*>     traces;
        std::vector<Explosion*> explosions;

    private:
        /*************************************************************************/
        /* Internal */
        /*************************************************************************/

        void playerKillsPlayer(Player *killer, Player *victim);

        void addExplosionFromHit(const Missile::Event *evt);

        void advanceExplosions(float dt);
        void advancePlayerShipSpawns(float dt);
        void advancePlayerCommands(float dt);
        void advancePlayerMissiles(float dt);

        // try to spawn a ship for this player.
        // return true on success, false on failure to find a spot.
        bool spawnShipForPlayer(Player *player);

        // find some place where nothing is placed nearby (ships/planets).
        // usefule for spanwing things
        bool findFreePositionWithRadius(float r, glm::vec2 &pos);

        float m_maxMissileDistance;
        float m_playerRespawnTime;
        float m_shipRadius;
        float m_defaultEnergy;
        int m_nextId=0;
        int   m_maxNumTraces;
    };
};