#include "Chunk.h"
#include "World.h"

namespace Feather
{
	Chunk::Chunk(ChunkPos& pos, NBT::CompoundTag& tag) :
		pos(pos)
	{
		using namespace NBT;
		CompoundTag level = tag.GetCompound("Level");

		Log::Trace("Loading chunk ({}, {}) from NBT", pos.x, pos.z);

		if (pos.x != level.Get<int>("xPos") || pos.z != level.Get<int>("zPos"))
		{
			Log::Error("Tried to load chunk ({}, {}) from NBT but NBT says chunk pos is ({}, {})",
				pos.x, pos.z,
				level.Get<int>("xPos"), level.Get<int>("zPos")
			);
		}

		// TODO: Heightmaps

		ListTag<CompoundTag> sectionsList = level.GetList<CompoundTag>("Sections");

		int n = 0;
		for (CompoundTag& sectData : sectionsList)
		{
			//std::cout << sectData << "\n";


			int8_t y = sectData.Get<int8_t>("Y");
			if (y < 0 || y >= NUM_SECTIONS) {
				Log::Trace("Skipping section {}", y);
				continue;
			}

			Log::Trace("Loading section {}/{} at Y {}", n + 1, NUM_SECTIONS, y);

			if (n >= NUM_SECTIONS)
			{
				Log::Error("Chunk ({}, {}) has more than {} sections!", pos.x, pos.z, NUM_SECTIONS);
				break;
			}

			ChunkSection* section = &sections[y];

			// Palette

			ListTag<CompoundTag> palette = sectData.GetList<CompoundTag>("Palette");

			for (size_t i = 0; i < palette.GetLength(); i++)
			{
				CompoundTag state = palette[i];
				const char* name = state.Get<StringTag>("Name").GetValue();

				BlockState stateLookup(name);
				int id;

				// TODO: handle this in IdMapper
				try {
					id = World::GLOBAL_PALETTE.GetID(stateLookup);
				}
				catch (std::out_of_range& err) {
					(void)err;
					Log::Warn("Chunk Section Palette maps id {} to invalid block state with name '{}'", i, name);
					continue;
				}

				// TODO: could use Add()
				section->localPalette.AddMapping(i, id);

				Log::Trace("  {} -> {} {}", i, id, name);
			}

			// Block States

			LongArrayTag blockStates = sectData.Get<LongArrayTag>("BlockStates");

			if (!blockStates) {
				Log::Warn("Skipping section with no block states.");
				continue;
			}

			assert(blockStates.GetLength() < ChunkSection::MaximumLongCount);

			for (size_t i = 0; i < blockStates.GetLength(); i++)
				section->blockStates[i] = blockStates[i];

			section->bitsPerBlock = (blockStates.GetLength() * 64) / (16 * 16 * 16);

			n++;
		}



	}
}