#include <td/game/World.h>

#include <td/simulation/WorldTicker.h>
#include <td/protocol/packet/PacketSerialize.h>

namespace td {
namespace game {

class ColorTileVisitor : public TileHandler {
  private:
	const World& m_World;
	const Color* m_Result;

  public:
	ColorTileVisitor(const World& a_World) : m_World(a_World), m_Result(nullptr) {}

	virtual void Handle(const EmptyTile& a_Tile) override {}

	virtual void Handle(const TowerTile& a_Tile) override {
		m_Result = &m_World.GetTowerTileColorPalette()[a_Tile->m_ColorPaletteRef];
	}

	virtual void Handle(const WalkableTile& a_Tile) override {
		m_Result = &m_World.GetWalkableTileColor();
	}

	virtual void Handle(const DecorationTile& a_Tile) override {
		m_Result = &m_World.GetDecorationPalette()[a_Tile->m_ColorPaletteRef];
	}

	const Color* GetResult() {
		return m_Result;
	}
};

World::World() : m_CurrentState(std::make_shared<sim::WorldSnapshot>()), m_NextState(m_CurrentState) {}

const Color* World::GetTileColor(const TilePtr& tile) const {
	ColorTileVisitor visitor(*this);
	tile->Dispatch(visitor);
	return visitor.GetResult();
}

bool World::LoadMap(const protocol::pdata::WorldHeader& a_WorldHeader) {
	m_TowerPlacePalette = a_WorldHeader.m_TowerPlacePalette;
	m_WalkablePalette = a_WorldHeader.m_WalkablePalette;
	m_DecorationPalette = a_WorldHeader.m_DecorationPalette;
	m_Background = a_WorldHeader.m_Background;

	GetRedTeam().GetSpawn() = a_WorldHeader.m_RedSpawn;
	GetBlueTeam().GetSpawn() = a_WorldHeader.m_BlueSpawn;

	m_SpawnColorPalette = a_WorldHeader.m_SpawnColorPalette;

	GetRedTeam().GetCastle() = a_WorldHeader.m_RedCastle;
	// GetRedTeam().GetCastle().SetTeam(&GetRedTeam());

	GetBlueTeam().GetCastle() = a_WorldHeader.m_BlueCastle;
	// GetBlueTeam().GetCastle().SetTeam(&GetBlueTeam());

	m_TilePalette = a_WorldHeader.m_TilePalette;

	return true;
}

protocol::packets::WorldHeaderPacket World::GetPacketHeader() const {
	return protocol::packets::WorldHeaderPacket(m_TowerPlacePalette, m_WalkablePalette, m_DecorationPalette, m_Background,
		m_SpawnColorPalette, m_TilePalette, GetRedTeam().GetSpawn(), GetBlueTeam().GetSpawn(), GetRedTeam().GetCastle(),
		GetBlueTeam().GetCastle());
}

protocol::packets::WorldDataPacket World::GetPacketData() const {
	return protocol::packets::WorldDataPacket(m_Chunks);
}

bool World::LoadMap(const protocol::pdata::WorldData& a_WorldData) {
	m_Chunks = a_WorldData.m_Chunks;
	return true;
}

const std::shared_ptr<sim::WorldSnapshot>& World::Tick(const protocol::LockStep& a_LockStep, FpFloat a_Delta) {
	m_CurrentState = m_NextState;
	m_NextState = std::make_shared<sim::WorldSnapshot>(m_Ticker.NextStep(*this, *m_NextState, a_LockStep, a_Delta));
	return m_CurrentState;
}

void World::ResetSnapshots(std::shared_ptr<sim::WorldSnapshot>& a_Current, std::shared_ptr<sim::WorldSnapshot>& a_Next) {
	m_CurrentState = a_Current;
	m_NextState = a_Next;
}

}  // namespace game
}  // namespace td