package net.minecraft.src;

import java.util.List;

import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;

/**
 * PowerCraft crafting tool GUI
 * 
 * @author Ondrej Hruska
 * @copy (c) 2012
 */
public class PCco_GuiCraftingTool extends GuiContainer {
	private int inventoryRows;

	private GuiButton prev, next;
	private static int page = 0;

	@Override
	@SuppressWarnings("unchecked")
	public void initGui() {
		prev = new GuiButton(0, width / 2 - 115, height / 2 + 30, "<<<");
		next = new GuiButton(1, width / 2 + 115 - 30, height / 2 + 30, ">>>");
		prev.width = next.width = 30;
		prev.enabled = page > 0;
		next.enabled = page < Math.ceil(((PCco_ContainerCraftingTool) inventorySlots).stacklist.size() / (13 * 7));
		controlList.add(prev);
		controlList.add(next);

		super.initGui();
	}

	@Override
	protected void actionPerformed(GuiButton guibutton) {
		if (!guibutton.enabled) { return; }

		if (guibutton.id == 0) {
			page--;
		}

		if (guibutton.id == 1) {
			page++;
		}

		((PCco_ContainerCraftingTool) inventorySlots).loadStacksForPage(page);

		prev.enabled = page > 0;
		next.enabled = page < Math.ceil(((PCco_ContainerCraftingTool) inventorySlots).stacklist.size() / (13 * 7));

	}



	/**
	 * Create Crafting tool GUI for player
	 * 
	 * @param player the player
	 */
	public PCco_GuiCraftingTool(EntityPlayer player) {
		super(new PCco_ContainerCraftingTool(player));
		inventoryRows = 0;
		allowUserInput = false;

		char c = '\336';
		int i = c - 108;
		inventoryRows = 7;
		ySize = i + inventoryRows * 18;
		xSize = 248;

		// achievement - open inventory
		player.addStat(AchievementList.openInventory, 1);
	}

	@Override
	protected void drawGuiContainerForegroundLayer() {
		fontRenderer.drawString("PowerCraft's crafting tool", 8, 6, 0x404040);
		fontRenderer.drawString(StatCollector.translateToLocal("container.inventory"), 100, (ySize - 96) + 2, 0x404040);
	}

	@Override
	protected void drawGuiContainerBackgroundLayer(float f, int i, int j) {
		int k = mc.renderEngine.getTexture("/PowerCraft/core/large-container.png");
		GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
		mc.renderEngine.bindTexture(k);
		int l = (width - xSize) / 2;
		int i1 = (height - ySize) / 2;
		drawTexturedModalRect(l, i1, 0, 0, xSize, inventoryRows * 18 + 17);
		drawTexturedModalRect(l, i1 + inventoryRows * 18 + 17, 0, 144, xSize, 96);
	}
	
	// OVERRIDE
	/**
	 * Draws an inventory slot
	 * @param slot the slot
	 */
	private void drawSlotInventoryCT(Slot slot) {
		int i = slot.xDisplayPosition;
		int j = slot.yDisplayPosition;
		ItemStack itemstack = slot.getStack();
		boolean isNull = false;
		int k = i;
		int l = j;
		zLevel = 100F;
		itemRenderer.zLevel = 100F;

		if (itemstack == null) {
			int i1 = slot.getBackgroundIconIndex();

			if (i1 >= 0) {
				GL11.glDisable(GL11.GL_LIGHTING);
				mc.renderEngine.bindTexture(mc.renderEngine.getTexture("/gui/items.png"));
				drawTexturedModalRect(k, l, (i1 % 16) * 16, (i1 / 16) * 16, 16, 16);
				GL11.glEnable(GL11.GL_LIGHTING);
				isNull = true;
			}
		}

		if (isNull || itemstack == null){
			if(slot instanceof PCco_SlotDirectCrafting){
				PCco_SlotDirectCrafting dirslot = (PCco_SlotDirectCrafting)slot;
				if(dirslot.product != null){
					itemRenderer.zLevel = 99F;
					zLevel = 99F;
					itemRenderer.renderItemIntoGUI(fontRenderer, mc.renderEngine, dirslot.product, k, l);
					itemRenderer.renderItemOverlayIntoGUI(fontRenderer, mc.renderEngine, dirslot.product, k, l);
					GL11.glDisable(GL11.GL_LIGHTING);
					GL11.glDisable(GL11.GL_DEPTH_TEST);
					int j1 = slot.xDisplayPosition;
					int k1 = slot.yDisplayPosition;
					drawGradientRect(j1, k1, j1 + 16, k1 + 16, 0x80999999, 0x80999999);
					GL11.glEnable(GL11.GL_LIGHTING);
					GL11.glEnable(GL11.GL_DEPTH_TEST);
					zLevel = 100F;
					itemRenderer.zLevel = 100F;
				}
				
			}
		}else{
			itemRenderer.renderItemIntoGUI(fontRenderer, mc.renderEngine, itemstack, k, l);
			itemRenderer.renderItemOverlayIntoGUI(fontRenderer, mc.renderEngine, itemstack, k, l);
		}

		itemRenderer.zLevel = 0.0F;
		zLevel = 0.0F;
	}

	/**
	 * Draws the screen and all the components in it.<br>
	 * This should be in all versions exactly the same as in GuiContainer, I copied it here to make it possible to override
	 * <b>drawSlotInventory<b>.
	 */
    /**
     * Draws the screen and all the components in it.
     */
    public void drawScreen(int par1, int par2, float par3)
    {
        drawDefaultBackground();
        int i = guiLeft;
        int j = guiTop;
        drawGuiContainerBackgroundLayer(par3, par1, par2);
        RenderHelper.enableGUIStandardItemLighting();
        GL11.glPushMatrix();
        GL11.glTranslatef(i, j, 0.0F);
        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
        GL11.glEnable(GL12.GL_RESCALE_NORMAL);
        Slot slot = null;
        int k = 240;
        int i1 = 240;
        OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, (float)k / 1.0F, (float)i1 / 1.0F);
        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);

        for (int l = 0; l < inventorySlots.inventorySlots.size(); l++)
        {
            Slot slot1 = (Slot)inventorySlots.inventorySlots.get(l);
            drawSlotInventoryCT(slot1);

            if (isMouseOverSlot(slot1, par1, par2))
            {
                slot = slot1;
                GL11.glDisable(GL11.GL_LIGHTING);
                GL11.glDisable(GL11.GL_DEPTH_TEST);
                int j1 = slot1.xDisplayPosition;
                int k1 = slot1.yDisplayPosition;
                drawGradientRect(j1, k1, j1 + 16, k1 + 16, 0x80ffffff, 0x80ffffff);
                GL11.glEnable(GL11.GL_LIGHTING);
                GL11.glEnable(GL11.GL_DEPTH_TEST);
            }
        }

        drawGuiContainerForegroundLayer();
        InventoryPlayer inventoryplayer = mc.thePlayer.inventory;

        if (inventoryplayer.getItemStack() != null)
        {
            GL11.glTranslatef(0.0F, 0.0F, 32F);
            zLevel = 200F;
            itemRenderer.zLevel = 200F;
            itemRenderer.renderItemIntoGUI(fontRenderer, mc.renderEngine, inventoryplayer.getItemStack(), par1 - i - 8, par2 - j - 8);
            itemRenderer.renderItemOverlayIntoGUI(fontRenderer, mc.renderEngine, inventoryplayer.getItemStack(), par1 - i - 8, par2 - j - 8);
            zLevel = 0.0F;
            itemRenderer.zLevel = 0.0F;
        }

        GL11.glDisable(GL12.GL_RESCALE_NORMAL);
        RenderHelper.disableStandardItemLighting();
        GL11.glDisable(GL11.GL_LIGHTING);
        GL11.glDisable(GL11.GL_DEPTH_TEST);

        if (inventoryplayer.getItemStack() == null && slot != null && slot.getHasStack())
        {
            ItemStack itemstack = slot.getStack();
            List list = itemstack.getItemNameandInformation();

            if (list.size() > 0)
            {
                int l1 = 0;

                for (int i2 = 0; i2 < list.size(); i2++)
                {
                    int k2 = fontRenderer.getStringWidth((String)list.get(i2));

                    if (k2 > l1)
                    {
                        l1 = k2;
                    }
                }

                int j2 = (par1 - i) + 12;
                int l2 = par2 - j - 12;
                int i3 = l1;
                int j3 = 8;

                if (list.size() > 1)
                {
                    j3 += 2 + (list.size() - 1) * 10;
                }

                zLevel = 300F;
                itemRenderer.zLevel = 300F;
                int k3 = 0xf0100010;
                drawGradientRect(j2 - 3, l2 - 4, j2 + i3 + 3, l2 - 3, k3, k3);
                drawGradientRect(j2 - 3, l2 + j3 + 3, j2 + i3 + 3, l2 + j3 + 4, k3, k3);
                drawGradientRect(j2 - 3, l2 - 3, j2 + i3 + 3, l2 + j3 + 3, k3, k3);
                drawGradientRect(j2 - 4, l2 - 3, j2 - 3, l2 + j3 + 3, k3, k3);
                drawGradientRect(j2 + i3 + 3, l2 - 3, j2 + i3 + 4, l2 + j3 + 3, k3, k3);
                int l3 = 0x505000ff;
                int i4 = (l3 & 0xfefefe) >> 1 | l3 & 0xff000000;
                drawGradientRect(j2 - 3, (l2 - 3) + 1, (j2 - 3) + 1, (l2 + j3 + 3) - 1, l3, i4);
                drawGradientRect(j2 + i3 + 2, (l2 - 3) + 1, j2 + i3 + 3, (l2 + j3 + 3) - 1, l3, i4);
                drawGradientRect(j2 - 3, l2 - 3, j2 + i3 + 3, (l2 - 3) + 1, l3, l3);
                drawGradientRect(j2 - 3, l2 + j3 + 2, j2 + i3 + 3, l2 + j3 + 3, i4, i4);

                for (int j4 = 0; j4 < list.size(); j4++)
                {
                    String s = (String)list.get(j4);

                    if (j4 == 0)
                    {
                        s = (new StringBuilder()).append("\247").append(Integer.toHexString(itemstack.getRarity().nameColor)).append(s).toString();
                    }
                    else
                    {
                        s = (new StringBuilder()).append("\2477").append(s).toString();
                    }

                    fontRenderer.drawStringWithShadow(s, j2, l2, -1);

                    if (j4 == 0)
                    {
                        l2 += 2;
                    }

                    l2 += 10;
                }

                zLevel = 0.0F;
                itemRenderer.zLevel = 0.0F;
            }
        }

        GL11.glPopMatrix();
        super.drawScreen(par1, par2, par3);
        GL11.glEnable(GL11.GL_LIGHTING);
        GL11.glEnable(GL11.GL_DEPTH_TEST);
    }

	// OVERRIDE
	/**
	 * Returns if the passed mouse position is over the specified slot.
	 * @param par1Slot the slot
	 * @param par2 mouse x
	 * @param par3 mouse y
	 * @return is over
	 */
	private boolean isMouseOverSlot(Slot par1Slot, int par2, int par3) {
		int i = guiLeft;
		int j = guiTop;
		par2 -= i;
		par3 -= j;
		return par2 >= par1Slot.xDisplayPosition - 1 && par2 < par1Slot.xDisplayPosition + 16 + 1 && par3 >= par1Slot.yDisplayPosition - 1
				&& par3 < par1Slot.yDisplayPosition + 16 + 1;
	}
}
