package ihl.model;

import ihl.items_blocks.FlexibleCableItem;
import net.minecraft.client.Minecraft;
import net.minecraft.client.entity.EntityClientPlayerMP;
import net.minecraft.client.renderer.GLAllocation;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.client.renderer.entity.RenderPlayer;
import net.minecraft.item.ItemStack;
import net.minecraftforge.client.IItemRenderer;
import net.minecraftforge.common.util.ForgeDirection;

import org.lwjgl.opengl.GL11;

public class FlexibleCableItemRender implements IItemRenderer {
	private ModelTube model;
	private ModelTube modelThin;
	private ModelTube modelLong;
	private ModelTube modelThinLong;
	private final int segmentsAmount = 19;
	private final float spiralStepAngle = 1f;
	private final float scale = 1 / 32f;
	private final int[] displayListCache = new int[4];

	public FlexibleCableItemRender() {
		float vOffset = 16f;
		int longFragmensSize = 24;
		model = new ModelTube(null, 0, 0, -2F, -3F, -2F + vOffset, 4, 6, 4, 0f, 0.5f, 0.99f, ForgeDirection.UP);
		modelLong = new ModelTube(null, 0, 0, -2F, -3F, -2F + vOffset, 4, longFragmensSize, 4, 0f, 0f, 0.99f,
				ForgeDirection.UP);
		modelThin = new ModelTube(null, 0, 0, -1F, -3F, -1F + vOffset, 2, 6, 2, 0f, 0.5f, 0.99f, ForgeDirection.UP);
		modelThinLong = new ModelTube(null, 0, 0, -1F, -3F, -1F + vOffset, 2, longFragmensSize, 2, 0f, 0.5f, 0.99f,
				ForgeDirection.UP);
	}

	@Override
	public boolean handleRenderType(ItemStack item, ItemRenderType type) {
		switch (type) {
		case ENTITY:
			return true;
		case EQUIPPED:
			return true;
		case EQUIPPED_FIRST_PERSON:
			return true;
		case INVENTORY:
			return true;
		default:
			return false;
		}
	}

	@Override
	public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {
		return true;
	}

	@Override
	public void renderItem(ItemRenderType type, ItemStack stack, Object... data) {
		GL11.glPushMatrix();
		GL11.glEnable(GL11.GL_BLEND);
		GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
		GL11.glScalef(1F, -1F, -1F);
		switch (type) {
		case ENTITY:
			GL11.glTranslatef(0, -1.0F, 0);
			this.rendercoil(stack);
			break;
		case EQUIPPED:
			GL11.glTranslatef(0.25F, -2F, -0.75F);
			this.rendercoil(stack);
			break;
		case EQUIPPED_FIRST_PERSON:
			RenderPlayer var25;
			EntityClientPlayerMP var3 = Minecraft.getMinecraft().thePlayer;
			Minecraft.getMinecraft().getTextureManager().bindTexture(var3.getLocationSkin());
			var25 = (RenderPlayer) RenderManager.instance.getEntityRenderObject(Minecraft.getMinecraft().thePlayer);
			GL11.glRotatef(135F, 1.0F, 0.0F, 0.0F);
			GL11.glRotatef(35F, 0.0F, 1.0F, 0.0F);
			var25.renderFirstPersonArm(Minecraft.getMinecraft().thePlayer);
			GL11.glRotatef(-35F, 0.0F, 1.0F, 0.0F);
			GL11.glRotatef(-135F, 1.0F, 0.0F, 0.0F);
			GL11.glTranslatef(0.0F, 0.2F, 0F);
			GL11.glTranslatef(-0.25F, -1.0F, 0F);
			this.rendercoil(stack);
			break;
		case INVENTORY:
			GL11.glTranslatef(0.0F, -0.2F, 0F);
			this.rendercoil(stack);
			break;
		default:
		}
		GL11.glPopMatrix();
	}

	private void rendercoil(ItemStack stack) {
		int type = this.getCableType(stack);
		if (this.displayListCache[type] != 0) {
			GL11.glCallList(displayListCache[type]);
		} else {

			this.displayListCache[type] = GLAllocation.generateDisplayLists(1);
			GL11.glNewList(displayListCache[type], 4864 /* GL_COMPILE */);

			GL11.glDisable(GL11.GL_TEXTURE_2D);
			int saMax = this.segmentsAmount * 2 + this.segmentsAmount / 2;
			for (int i = 0; i <= saMax; i++) {
				GL11.glRotatef(-spiralStepAngle, 0f, 0f, 1f);
				GL11.glRotatef(360f / this.segmentsAmount, 1f, 0f, 0f);
				GL11.glTranslatef(0.004f, 0f, 0f);
				GL11.glRotatef(spiralStepAngle, 0f, 0f, 1f);
				if (((FlexibleCableItem) stack.getItem()).isDataCable) {
					GL11.glColor3f(1f, 0.2f, 0f);
				} else {
					GL11.glColor3f(1f, 1f, 1f);
				}
				if (i == 0) {
					if (isNoInsulation(stack)) {
						if (FlexibleCableItem.instance.yellowColoredWires
								.contains(FlexibleCableItem.instance.getMaterial(stack))) {
							GL11.glColor3f(1f, 0.75f, 0.1f);
						} else {
							GL11.glColor3f(0.65f, 0.65f, 0.67f);
						}
						this.modelThinLong.render(Tessellator.instance, scale);

					} else {
						this.modelLong.render(Tessellator.instance, scale);
					}
				} else if (i == saMax) {
					GL11.glTranslatef(0.0F, -0.55F, 0F);
					if (isNoInsulation(stack)) {
						if (FlexibleCableItem.instance.yellowColoredWires
								.contains(FlexibleCableItem.instance.getMaterial(stack))) {
							GL11.glColor3f(1f, 0.75f, 0.1f);
						} else {
							GL11.glColor3f(0.65f, 0.65f, 0.67f);
						}
						this.modelThinLong.render(Tessellator.instance, scale);

					} else {
						this.modelLong.render(Tessellator.instance, scale);
					}
					GL11.glTranslatef(0.0F, 0.55F, 0F);
				} else {
					if (isNoInsulation(stack)) {
						if (FlexibleCableItem.instance.yellowColoredWires
								.contains(FlexibleCableItem.instance.getMaterial(stack))) {
							GL11.glColor3f(1f, 0.75f, 0.1f);
						} else {
							GL11.glColor3f(0.65f, 0.65f, 0.67f);
						}
						this.modelThin.render(Tessellator.instance, scale);

					} else {
						this.model.render(Tessellator.instance, scale);
					}
				}
			}
			GL11.glEnable(GL11.GL_TEXTURE_2D);
			GL11.glEndList();
		}
	}

	private int getCableType(ItemStack stack) {
		if (((FlexibleCableItem) stack.getItem()).isDataCable) {
			return 3;
		} else if (isNoInsulation(stack)) {
			if (FlexibleCableItem.instance.yellowColoredWires.contains(FlexibleCableItem.instance.getMaterial(stack))) {
				return 1;
			} else {
				return 2;
			}
		}
		return 0;
	}

	private boolean isNoInsulation(ItemStack stack) {
		return stack.stackTagCompound != null && FlexibleCableItem.instance.getInsulationMaterial(stack).equals("null")
				&& !((FlexibleCableItem) stack.getItem()).isDataCable;
	}
}