#pragma once

#include <unordered_map>
#include <asio.hpp>
#include <deque>
#include <memory.h>
#include <memory>
#include <thread>

#include "asio/io_context.hpp"
#include "net/tcp_connection.h"
#include "player.h"
#include "i_network_bridge.h"
#include "machine_manager.h"

class DatabaseManager;

struct CachedMachine {
  std::unique_ptr<Machine> machine;
  int ref_count = 0;
};

class NetworkManager : public INetworkBridge {
public:
  NetworkManager(const std::string& db_path);
  ~NetworkManager(void);

  void start(uint16_t port);
  void stop(void);

  Machine* get_machine_by_ip(const std::string& ip) override;
  void release_machine(long long machine_id) override;

private:
  void start_accept(void);
  void on_message(std::shared_ptr<net::TcpConnection> connection,
                  const std::string& message);
  void on_disconnect(std::shared_ptr<net::TcpConnection> connection);
  void _save_machine_vfs(Machine* machine);
  void _recursive_save_vfs(long long machine_id, vfs_node* node,
                           long long* parent_id);

  void _seed_npc_machines(void);

  asio::io_context _io_context;
  std::thread _context_thread;
  asio::ip::tcp::acceptor _acceptor;

  std::deque<std::shared_ptr<net::TcpConnection>> _connections;
  std::unordered_map<uint32_t, std::unique_ptr<Player>> _players;
  std::map<long long, CachedMachine> _active_machines;
  uint32_t _next_player_id  = 1;
  uint32_t _next_session_id = 1;

  std::unique_ptr<DatabaseManager> _db_manager;
  MachineManager _machine_manager;

protected:
  Machine* _get_or_load_machine(long long machine_id);
};