#include "ItemRenderer.h"
#include "tileRenderer.h"
#include "entityRenderDispatcher.h"
//#include "ItemFrame"
#include "ItemFrameRenderer.h"
#include "TextureAtlas.h"

#include "..\Minecraft.World\JavaMath.h"
#include "..\Minecraft.World\net.minecraft.world.entity.Item.h"
#include "..\Minecraft.World\net.minecraft.world.Item.h"
#include "..\Minecraft.World\net.minecraft.world.Item.alchemy.h"
#include "..\Minecraft.World\net.minecraft.world.level.tile.h"
#include "..\Minecraft.World\StringHelpers.h"
#include "Minecraft.h"
#include "..\Minecraft.World\Item.h"
#include "..\Minecraft.World\net.minecraft.world.h"
#include "..\Minecraft.World\net.minecraft.h"
#include "CompassTexture.h"
#include "Minimap.h"

ResourceLocation ItemFrameRenderer::MAP_BACKGROUND_LOCATION = ResourceLocation(TN_MISC_MAPBG);

void ItemFrameRenderer::registerTerrainTextures(IconRegister *iconRegister)
{
	backTexture = iconRegister->registerIcon(L"itemframe_back");
}

void ItemFrameRenderer::render(shared_ptr<Entity>  _itemframe, double x, double y, double z, float rot, float a) 
{
	// 4J - original version used generics and thus had an input parameter of type EnderCrystal rather than shared_ptr<Entity>  we have here - 
	// do some casting around instead
	shared_ptr<ItemFrame> itemFrame = dynamic_pointer_cast<ItemFrame>(_itemframe);

	glPushMatrix();
	float xOffs = static_cast<float>(itemFrame->x - x) - 0.5f;
	float yOffs = static_cast<float>(itemFrame->y - y) - 0.5f;
	float zOffs = static_cast<float>(itemFrame->z - z) - 0.5f;

	int xt = itemFrame->xTile + Direction::STEP_X[itemFrame->dir];
	int yt = itemFrame->yTile;
	int zt = itemFrame->zTile + Direction::STEP_Z[itemFrame->dir];

	glTranslatef(static_cast<float>(xt) - xOffs, static_cast<float>(yt) - yOffs, static_cast<float>(zt) - zOffs);

	bool containsMap = false;
        
    if (shared_ptr<ItemInstance> item = itemFrame->getItem()) 
    {
        if (item->id == Item::map_Id) 
            containsMap = true;
    }

	if (containsMap)
		drawBlockFrame(itemFrame);
	else
		drawFrame(itemFrame);

		drawItem(itemFrame);

	glPopMatrix();
}

void ItemFrameRenderer::drawBlockFrame(shared_ptr<ItemFrame> itemFrame) 
{
	Minecraft *pMinecraft=Minecraft::GetInstance();

	glPushMatrix();
	entityRenderDispatcher->textures->bindTexture(&TextureAtlas::LOCATION_BLOCKS);
	glRotatef(itemFrame->yRot, 0, 1, 0);

	Tile *wood = Tile::wood;

	// Back
	glPushMatrix();

	tileRenderer->setFixedShape(0, 0.0625F, 0.0625F, 0.0625F, 0.9375F, 0.9375F);
	tileRenderer->setFixedTexture(backTexture);
	tileRenderer->renderTile(wood, 0, 1);
	tileRenderer->clearFixedTexture();
	tileRenderer->clearFixedShape();
	glPopMatrix();

	tileRenderer->setFixedTexture(Tile::wood->getTexture(Facing::UP, TreeTile::BIRCH_TRUNK));

	// Bottom
	glPushMatrix();
	tileRenderer->setFixedShape(0, 0, 0, 0.062600002F, 0.0625F, 1);
	tileRenderer->renderTile(wood, 0, 1);
	glPopMatrix();

	// Top
	glPushMatrix();
	tileRenderer->setFixedShape(0, 0.9375F, 0, 0.062600002F, 1, 1);
	tileRenderer->renderTile(wood, 0, 1);
	glPopMatrix();

	// Right
	glPushMatrix();
	tileRenderer->setFixedShape(0, 0, 0, 0.0625F, 1, 0.0625F);
	tileRenderer->renderTile(wood, 0, 1);
	glPopMatrix();

	// Left
	glPushMatrix();
	tileRenderer->setFixedShape(0, 0, 0.9375F, 0.0625F, 1, 1);
	tileRenderer->renderTile(wood, 0, 1);
	glPopMatrix();

	tileRenderer->clearFixedShape();
	tileRenderer->clearFixedTexture();

	glPopMatrix();
}

void ItemFrameRenderer::drawFrame(shared_ptr<ItemFrame> itemFrame) 
{
	Minecraft *pMinecraft=Minecraft::GetInstance();

	glPushMatrix();
	entityRenderDispatcher->textures->bindTexture(&TextureAtlas::LOCATION_BLOCKS);
	glRotatef(itemFrame->yRot, 0, 1, 0);

	Tile *wood = Tile::wood;
	constexpr float depth = 1.0f / 16.0f;
	constexpr float width = 12.0f / 16.0f;
	constexpr float widthHalf = width / 2.0f;

	// Back
	glPushMatrix();

	tileRenderer->setFixedShape(0, 0.5f - widthHalf + depth, 0.5f - widthHalf + depth, depth * .5f, 0.5f + widthHalf - depth, 0.5f + widthHalf - depth);
	tileRenderer->setFixedTexture(backTexture);
	tileRenderer->renderTile(wood, 0, 1);
	tileRenderer->clearFixedTexture();
	tileRenderer->clearFixedShape();
	glPopMatrix();

	tileRenderer->setFixedTexture(Tile::wood->getTexture(Facing::UP, TreeTile::BIRCH_TRUNK));

	// Bottom
	glPushMatrix();
	tileRenderer->setFixedShape(0, 0.5f - widthHalf, 0.5f - widthHalf, depth + 0.0001f, depth + 0.5f - widthHalf, 0.5f + widthHalf);
	tileRenderer->renderTile(wood, 0, 1);
	glPopMatrix();

	// Top
	glPushMatrix();
	tileRenderer->setFixedShape(0, 0.5f + widthHalf - depth, 0.5f - widthHalf, depth + 0.0001f, 0.5f + widthHalf, 0.5f + widthHalf);
	tileRenderer->renderTile(wood, 0, 1);
	glPopMatrix();

	// Right
	glPushMatrix();
	tileRenderer->setFixedShape(0, 0.5f - widthHalf, 0.5f - widthHalf, depth, 0.5f + widthHalf, depth + 0.5f - widthHalf);
	tileRenderer->renderTile(wood, 0, 1);
	glPopMatrix();

	// Left
	glPushMatrix();
	tileRenderer->setFixedShape(0, 0.5f - widthHalf, 0.5f + widthHalf - depth, depth, 0.5f + widthHalf, 0.5f + widthHalf);
	tileRenderer->renderTile(wood, 0, 1);
	glPopMatrix();

	tileRenderer->clearFixedShape();
	tileRenderer->clearFixedTexture();

	glPopMatrix();
}

void ItemFrameRenderer::drawItem(shared_ptr<ItemFrame> entity) 
{
	Minecraft *pMinecraft=Minecraft::GetInstance();

	shared_ptr<ItemInstance> instance = entity->getItem();
	if (instance == nullptr) return;

	shared_ptr<ItemEntity> itemEntity = std::make_shared<ItemEntity>(entity->level, 0, 0, 0, instance);
	itemEntity->getItem()->count = 1;
	itemEntity->bobOffs = 0;

	glPushMatrix();

	glTranslatef((-7.25f / 16.0f) * Direction::STEP_X[entity->dir], -0.18f, (-7.25f / 16.0f) * Direction::STEP_Z[entity->dir]);
	glRotatef(180 + entity->yRot, 0, 1, 0);
	glRotatef(-90 * entity->getRotation(), 0, 0, 1);

	switch (entity->getRotation()) 
	{
	case 1:
		glTranslatef(-0.16f, -0.16f, 0);
		break;
	case 2:
		glTranslatef(0, -0.32f, 0);
		break;
	case 3:
		glTranslatef(0.16f, -0.16f, 0);
		break;
	}

	if (itemEntity->getItem()->getItem() == Item::map) 
	{
		glRotatef(180, 0, 1, 0);
		glRotatef(180, 0, 0, 1);
		glScalef(0.0078125f, 0.0078125f, 0.0078125f);

		switch (entity->getRotation())
		{
		case 0:
			glTranslatef(-64.0f, -87.0f, -3.0f);
			break;

		case 1:
			glTranslatef(-66.5f, -84.5f, -3.0f);
			break;

		case 2:
			glTranslatef(-64.0f, -82.0f, -3.0f);
			break;

		case 3:
			glTranslatef(-61.5f, -84.5f, -3.0f);
			break;
		}

		glNormal3f(0, 0, -1);
		glTranslatef(0.0f, -0.25f, 0.0f);

		auto data = Item::map->getSavedData(itemEntity->getItem(), entity->level);
		if (data != nullptr)
			entityRenderDispatcher->itemInHandRenderer->minimap->render(nullptr, entityRenderDispatcher->textures, data, entity->entityId);
	} 
	else 
	{
		if (itemEntity->getItem()->getItem() == Item::compass)
		{
			CompassTexture *ct = CompassTexture::instance;
			double compassRot = ct->rot;
			double compassRotA = ct->rota;
			ct->rot = 0;
			ct->rota = 0;
			ct->updateFromPosition(entity->level, entity->x, entity->z, Mth::wrapDegrees( static_cast<float>(180 + entity->dir * 90) ), false, true);
			ct->rot = compassRot;
			ct->rota = compassRotA;
		}

		EntityRenderDispatcher::instance->render(itemEntity, 0, 0, 0, 0, 0, true);

		if (itemEntity->getItem()->getItem() == Item::compass)
		{
			CompassTexture *ct = CompassTexture::instance;
			ct->cycleFrames();
		}
	}
	
	glPopMatrix();
}