package net.minecraft.src;

import java.util.Random;

import org.lwjgl.input.Keyboard;

/**
 * PowerCraft's core mod class
 * 
 * @author MightyPork
 * @copy (c) 2012
 */
public class mod_PCcore extends PC_Module {

	public static mod_PCcore instance;
	public static PC_PropertyManager conf;

	/* mod version, shared by other modules */
	public static final String VERSION = "3.4";

	/**
	 * Get images directory, ending with slash
	 * 
	 * @return the directory
	 */
	public static String getImgDir() {
		return "/PowerCraft/core/";
	}

	/**
	 * Get terrain file path (png)
	 * 
	 * @return the file path
	 */
	public static String getTerrainFile() {
		return getImgDir() + "tiles.png";
	}

	// CORE must override this, others don't.
	@Override
	public String getPriorities() {
		return "before:*";
	}

	@Override
	public String getModuleName() {
		return "CORE";
	}





	// **** PROPERTIES ****

	/* settings for the crafting tool */
	public static Boolean recursive_crafting;
	public static Boolean survival_cheating;

	// property keys
	public static final String pk_ReverseKey = "key.reverse_placing";
	private static final String pk_RecRecyclation = "opt.new_recipes.recyclation";
	private static final String pk_RecSpawner = "opt.new_recipes.spawner";
	private static final String pk_craftingTool = "id.item.crafting_tool";
	private static final String pk_craft_recursive = "opt.crafting_tool.recursive";
	private static final String pk_craft_cheating = "opt.crafting_tool.cheat_in_survival";
	
	private static final String pk_crystalsInChunk = "worldgen.crystals.in_chunk";
	private static final String pk_crystalsDepositMaxCount = "worldgen.crystals.deposit_max_size";
	private static final String pk_crystalsMinY = "worldgen.crystals.min_y";
	private static final String pk_crystalsMaxY = "worldgen.crystals.max_y";
	
	private static final String pk_crystal = "id.block.power_crystal";

	private static final String pk_crystal_gen = "opt.worldgen.generate.power_crystals";
	private static final String pk_RecEasyCrystals = "opt.cheat.easy_crystals";
	private static final String pk_crystal_brightness = "brightness.power_crystal";
	
	private static final String pk_iactivator = "id.item.activation_crystal";
	private static final String pk_ipowerDust = "id.item.power_dust";
	private static final String pk_isniffer = "id.item.ore_sniffer";

	// init props
	static {

		conf = new PC_PropertyManager("/config/PowerCraft/module_core.cfg", "PowerCraft CORE module\nconfiguration file");

		conf.putKey(pk_ReverseKey, Keyboard.KEY_LCONTROL);
		conf.putBoolean(pk_RecRecyclation, true);
		conf.putBoolean(pk_RecSpawner, true);
		conf.putItem(pk_craftingTool, 19003);
		
		conf.putItem(pk_iactivator, 19001);
		conf.putItem(pk_ipowerDust, 19002);
		conf.putItem(pk_isniffer, 19004);
		conf.putBlock(pk_crystal, 232);

		conf.putBoolean(pk_crystal_gen, true, "Generate Power Crystals in the world?");
		conf.putInteger(pk_crystal_brightness, 15, "Power Crystal block brightness, scale 0-15.");

		conf.putBoolean(pk_RecEasyCrystals, false, "Get power crystals by smelting diamonds,\nchange crystals color by crafting.");
		conf.putInteger(pk_crystalsInChunk, 3, "Number of deposits in each 16x16 chunk.");
		conf.putInteger(pk_crystalsDepositMaxCount, 4, "Highest crystal count in one deposit");
		conf.putInteger(pk_crystalsMinY, 5, "Min Y coordinate of crystal deposits.");
		conf.putInteger(pk_crystalsMaxY, 15, "Max Y coordinate of crystal deposits.");

		//@formatter:off
		conf.putBoolean(pk_craft_recursive, false, 
				"Let's you craft using the Crafting Tool not only items you can atm,\n" +
				"but also items you could after crafting different items\n" +
				"(example: having torch, some redstone and few stones lets you craft\n" +
				"negated gates by one click, and the 'NOT' gate will be crafted silently in background)\n");
		conf.putBoolean(pk_craft_cheating, false, 
				"Makes the Crafting Tool work like TMI in Survival,\n" +
				"giving you everything with no resources consumed.");
		//@formatter:on

		conf.apply();

		recursive_crafting = conf.getBoolean(pk_craft_recursive);
		survival_cheating = conf.getBoolean(pk_craft_cheating);

	}

	




	// *** MODULE INIT ***

	@Override
	public void preInit() {
		instance = this;
		((PCmo_ItemOreSniffer) oreSniffer).initNames();
	}

	@Override
	public void registerEntities() {}

	@Override
	public void registerTileEntities() {}

	@Override
	public void registerBlockRenderers() {
		PC_Renderer.swapTerrainRenderer = ModLoader.getUniqueBlockModelID(this, true);
		PC_Renderer.rotatedBoxRenderer = ModLoader.getUniqueBlockModelID(this, true);
		rendererCrystal = ModLoader.getUniqueBlockModelID(this, true);
	}

	@Override
	public void registerBlocks() {
		ModLoader.registerBlock(powerCrystal);

		Item.itemsList[powerCrystal.blockID] = null;
		Item.itemsList[powerCrystal.blockID] = (new PCmo_ItemBlockPowerCrystal(powerCrystal.blockID - 256)).setItemName("PCcoPowerCrystal");
	}

	@Override
	public void registerTextures() {
		craftingTool.setIconIndex(ModLoader.addOverride("/gui/items.png", getImgDir() + "gatecrafter.png"));
		activator.setIconIndex(ModLoader.addOverride("/gui/items.png", getImgDir() + "activator.png"));
		oreSniffer.setIconIndex(ModLoader.addOverride("/gui/items.png", getImgDir() + "sniffer.png"));
	}

	@Override
	public void preloadTextures() {}

	@Override
	public void addNames() {
		ModLoader.addName(craftingTool, "PowerCraft's Crafting Tool");

		ModLoader.addName(activator, "Activation Crystal");
		ModLoader.addName(powerCrystal, "Power Crystal");
		ModLoader.addName(powerDust, "Power Dust");
		ModLoader.addName(oreSniffer, "Ore Sniffer");

		ModLoader.addLocalization("tile.PCcoPowerCrystal.color0.name", "\u03b1 Power Crystal");
		ModLoader.addLocalization("tile.PCcoPowerCrystal.color1.name", "\u03b2 Power Crystal");
		ModLoader.addLocalization("tile.PCcoPowerCrystal.color2.name", "\u03b3 Power Crystal");
		ModLoader.addLocalization("tile.PCcoPowerCrystal.color3.name", "\u03b4 Power Crystal");
		ModLoader.addLocalization("tile.PCcoPowerCrystal.color4.name", "\u03d1 Power Crystal");
		ModLoader.addLocalization("tile.PCcoPowerCrystal.color5.name", "\u03b6 Power Crystal");
		ModLoader.addLocalization("tile.PCcoPowerCrystal.color6.name", "\u03be Power Crystal");
		ModLoader.addLocalization("tile.PCcoPowerCrystal.color7.name", "\u03d7 Power Crystal");
	}

	@Override
	public void addRecipes() {
		//@formatter:off
		
		ModLoader.addRecipe(
				new ItemStack(craftingTool, 1, 0),
				new Object[] { " r ", "rIr", " r ",
					Character.valueOf('r'), Item.redstone, Character.valueOf('I'), Block.blockSteel });
		
		// new recyclation recipes
		if (conf.getBoolean(pk_RecRecyclation)) {
			ModLoader.addShapelessRecipe(new ItemStack(Block.sand, 4), new Object[] { Block.sandStone });
			ModLoader.addShapelessRecipe(new ItemStack(Block.planks, 6), new Object[] { Item.doorWood });
			ModLoader.addShapelessRecipe(new ItemStack(Block.planks, 8), new Object[] { Block.chest });
			ModLoader.addShapelessRecipe(new ItemStack(Block.planks, 4), new Object[] { Block.workbench });
			ModLoader.addShapelessRecipe(new ItemStack(Item.stick, 3), new Object[] { Block.fence });
			ModLoader.addShapelessRecipe(new ItemStack(Item.stick, 2), new Object[] { Block.ladder });
			ModLoader.addShapelessRecipe(new ItemStack(Block.planks, 6), new Object[] { Item.sign });
			ModLoader.addShapelessRecipe(new ItemStack(Item.ingotIron, 6), new Object[] { Item.doorSteel });
			ModLoader.addShapelessRecipe(new ItemStack(Item.ingotIron, 4), new Object[] { Item.compass });
			ModLoader.addShapelessRecipe(new ItemStack(Item.ingotGold, 4), new Object[] { Item.pocketSundial });
			ModLoader.addShapelessRecipe(new ItemStack(Block.cobblestone, 8), new Object[] { Block.stoneOvenIdle });
			ModLoader.addShapelessRecipe(new ItemStack(Block.blockSteel, 1, 0), new Object[] { craftingTool });
		}		

		// recipe for spawner
		if (conf.getBoolean(pk_RecSpawner)) {
			ModLoader.addRecipe(
					new ItemStack(Block.mobSpawner, 1),
					new Object[] { "SIS", "I I", "SIS", Character.valueOf('I'), Item.ingotIron, Character.valueOf('S'), Block.cobblestoneMossy });
			
		}
		
		
		
		if (conf.getBoolean(pk_RecEasyCrystals)) {
			ModLoader.addSmelting(Item.diamond.shiftedIndex, new ItemStack(powerCrystal, 1));
			ModLoader.addShapelessRecipe(
					new ItemStack(powerCrystal, 1, 1),
					new Object[] { new ItemStack(powerCrystal, 1, 0) });
			ModLoader.addShapelessRecipe(
					new ItemStack(powerCrystal, 1, 2),
					new Object[] { new ItemStack(powerCrystal, 1, 1) });
			ModLoader.addShapelessRecipe(
					new ItemStack(powerCrystal, 1, 3),
					new Object[] { new ItemStack(powerCrystal, 1, 2) });
			ModLoader.addShapelessRecipe(
					new ItemStack(powerCrystal, 1, 4),
					new Object[] { new ItemStack(powerCrystal, 1, 3) });
			ModLoader.addShapelessRecipe(
					new ItemStack(powerCrystal, 1, 5),
					new Object[] { new ItemStack(powerCrystal, 1, 4) });
			ModLoader.addShapelessRecipe(
					new ItemStack(powerCrystal, 1, 6),
					new Object[] { new ItemStack(powerCrystal, 1, 5) });
			ModLoader.addShapelessRecipe(
					new ItemStack(powerCrystal, 1, 7),
					new Object[] { new ItemStack(powerCrystal, 1, 6) });
			ModLoader.addShapelessRecipe(
					new ItemStack(powerCrystal, 1, 0),
					new Object[] { new ItemStack(powerCrystal, 1, 7) });
			
			// two crystals of any color -> two portions of PowerDust
			ModLoader.addShapelessRecipe(
					new ItemStack(powerDust, 48, 0),
					new Object[] { new ItemStack(powerCrystal, 1, -1),	new ItemStack( powerCrystal, 1, -1) });
			
		} else {
			
			// Normal recipe for powerdust
			ModLoader.addShapelessRecipe(new ItemStack(powerDust, 24, 0), new Object[] { new ItemStack(powerCrystal, 1, -1) });
		}
		
		// sniffer		
		ModLoader.addRecipe(
				new ItemStack(oreSniffer, 1, 0),
				new Object[] { " G ", "GCG", " G ",
					Character.valueOf('C'), new ItemStack(powerCrystal, 1, -1), Character.valueOf('G'), Item.ingotGold });

		// activator
		ModLoader.addRecipe(
				new ItemStack(activator, 1),
				new Object[] { "C", "I",
					Character.valueOf('C'), new ItemStack(powerCrystal, 1, -1), Character.valueOf('I'), Item.ingotIron });
		
		//@formatter:on
	}

	@Override
	public void postInit() {}



	//@formatter:off

	/** gate crafting tool */
	public static Item craftingTool = new PCco_ItemCraftingTool(conf.getInteger(pk_craftingTool))
			.setItemName("PCloGateCrafter");
	
	/** Activation Crystal item */
	public static Item activator = new PCmo_ItemActivator(conf.getInteger(pk_iactivator))
			.setIconIndex(37)
			.setItemName("PCmoActivatorItem");

	/** Power Dust item (fuel) */
	public static Item powerDust = new PCmo_ItemPowerDust(conf.getInteger(pk_ipowerDust))
			.setIconCoord(13, 9)
			.setItemName("PCmoPowerDust");

	/** Ore Sniffer item */
	public static Item oreSniffer = new PCmo_ItemOreSniffer(conf.getInteger(pk_isniffer))
			.setIconIndex(37)
			.setItemName("PCmoOreSnifferItem");

	/** Power Crystal block */
	public static Block powerCrystal = new PCmo_BlockPowerCrystal(conf.getInteger(pk_crystal), 49)
			.setHardness(0.5F)
			.setResistance(0.5F)
			.setBlockName("PCmoPowerCrystal")
			.setStepSound(Block.soundGlassFootstep)
			.setLightValue(conf.getInteger(pk_crystal_brightness) * 0.0625F);
	
	//@formatter:on

	
	// *** HANDLING RENDERERS ***

	@Override
	public boolean renderWorldBlock(RenderBlocks renderblocks, IBlockAccess blockAccess, int i, int j, int k, Block block, int rtype) {
		return PC_Renderer.renderBlockByType(renderblocks, blockAccess, i, j, k, block, rtype);
	}

	@Override
	public void renderInvBlock(RenderBlocks renderblocks, Block block, int i, int rtype) {
		PC_Renderer.renderInvBlockByType(renderblocks, block, i, rtype);
	}
	
	
	
	


	


	@Override
	public void generateSurface(World world, Random random, int chunkX, int chunkZ) {
		if (!conf.getBoolean(pk_crystal_gen)) { return; }

		int posX;
		int posY;
		int posZ;

		for (int q = 0; q < conf.getInteger(pk_crystalsInChunk); q++) {
			int maxBlocks = random.nextInt(MathHelper.clamp_int(conf.getInteger(pk_crystalsDepositMaxCount) - 1, 1, 10)) + 2;

			posX = chunkX + random.nextInt(16);
			posY = MathHelper.clamp_int(
					random.nextInt(MathHelper.clamp_int(conf.getInteger(pk_crystalsMaxY) - conf.getInteger(pk_crystalsMinY), 1, 200))
							+ conf.getInteger(pk_crystalsMinY), 1, 255);

			posZ = chunkZ + random.nextInt(16);

			logger.finest("Generating PowerCrystals deposit of size " + maxBlocks + " at coords [" + posX + ";" + posY + ";" + posZ + "]");

			new WorldGenMinable(powerCrystal.blockID, maxBlocks).generate(world, random, posX, posY, posZ);
		}
	}
	
	
	
	
	
	
	
	
	
	
	// FUEL
	@Override
	public int addFuel(int i, int j) {
		return (i == powerDust.shiftedIndex) ? 2200 : 0;
	}

}
