GameState.h

#pragma once
#include <thread>
#include "Util.h"
#include "PhaseState.h"
#include "Socket.h"
#include "TableState.h"
using namespace Util;

struct Config {
    double Kp;
    double Kt;
    double Kpt;
};

class GameState {
    std::unique_ptr<Socket> m_socket = nullptr;
    Config m_config{};
    std::thread m_listen_thread;
    TableState m_game_table;
    PhaseState m_phase_state;
    std::string m_agent;
    std::shared_ptr<spdlog::logger> m_log;
    mutable std::mutex m_state_mutex;
    std::atomic<bool> m_listening{false};
    std::chrono::steady_clock::time_point m_game_start;

    [[nodiscard]] bool has_phases() const;
 
 
    [[nodiscard]] std::optional<std::string> get_next_best_phase();

    [[nodiscard]] double compute_potential(const Phase &phase_candidate) const;

    void update_phase_status(Phase &phase) const;

    [[nodiscard]] int time_remaining() const;

    void listen();

    void execute_init(const std::function<void()> &action);
 
public:
    GameState(TableState table_state, const Config &config, PhaseState phase_state);

    GameState(GameState &&other) noexcept;

    [[nodiscard]] static GameState connect_server(const std::string &game_state_config_path,
                                                  const std::string &table_state_config_path,
                                                  const std::string &phase_state_config_path);

    [[nodiscard]] static GameState connect_client(const std::string &ip, uint16_t port);

    void run(const std::unordered_map<std::string, std::function<void()> > &actions);

    void mutate_shared_state(const std::string &key, std::any value);

    template<typename T>
    T read_shared_state(const std::string &key) const;
};