package WayofTime.alchemicalWizardry.common.tileEntity;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.Constants;
import net.minecraftforge.common.util.ForgeDirection;
import WayofTime.alchemicalWizardry.ModBlocks;
import WayofTime.alchemicalWizardry.common.Int3;
import WayofTime.alchemicalWizardry.common.block.BlockTeleposer;
import WayofTime.alchemicalWizardry.common.demonVillage.BuildingSchematic;
import WayofTime.alchemicalWizardry.common.demonVillage.DemonBuilding;
import WayofTime.alchemicalWizardry.common.demonVillage.DemonCrosspath;
import WayofTime.alchemicalWizardry.common.demonVillage.DemonVillagePath;
import WayofTime.alchemicalWizardry.common.demonVillage.GridSpace;
import WayofTime.alchemicalWizardry.common.demonVillage.GridSpaceHolder;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class TEDemonPortal extends TileEntity
{
	public static int buildingGridDelay = 25;
	public static int roadGridDelay = 10;
	
	public static List<DemonBuilding> buildingList = new ArrayList();
	public Random rand = new Random();
	private GridSpace[][] area;
	
	private int negXRadius; //These variables indicate how much the grid has expanded from the 1x1
	private int posXRadius; //matrix in each direction
	private int negZRadius;
	private int posZRadius;
	
	private boolean isInitialized;
	
	public int houseCooldown;
	public int roadCooldown;
	public int tier; //Tier of the demon portal - Should select buildings 2 below to this
	public int totalPoints;
	
	public TEDemonPortal()
	{
		super();
		
		negXRadius = posXRadius = negZRadius = posZRadius = 1;
		
		area = new GridSpace[negXRadius + posXRadius + 1][negZRadius + posZRadius + 1];
		for(int xIndex = -negXRadius; xIndex <= posXRadius; xIndex++)
		{
			for(int zIndex = -negZRadius; zIndex <= posZRadius; zIndex++)
			{
				if(Math.abs(xIndex) == 1 || Math.abs(zIndex) == 1)
				{
					this.setGridSpace(xIndex, zIndex, new GridSpace(GridSpace.ROAD,4));
				}else
				{
					this.setGridSpace(xIndex, zIndex, new GridSpace());
				}
			}
		}
		
		isInitialized = false;
		
		this.setGridSpace(0, 0, new GridSpace(GridSpace.MAIN_PORTAL, yCoord));
		
		this.houseCooldown = 0;
		this.roadCooldown = 0;
	}
	
	public void initialize()
	{
		if(isInitialized)
		{
			return;
		}
		
		for(int xIndex = -negXRadius; xIndex <= posXRadius; xIndex++)
		{
			for(int zIndex = -negZRadius; zIndex <= posZRadius; zIndex++)
			{
				if(Math.abs(xIndex) == 1 || Math.abs(zIndex) == 1)
				{
					this.setGridSpace(xIndex, zIndex, new GridSpace(GridSpace.ROAD,yCoord));
				}else if(xIndex == 0 && zIndex == 0)
				{
					this.setGridSpace(0, 0, new GridSpace(GridSpace.MAIN_PORTAL, yCoord));
				}else
				{
					this.setGridSpace(xIndex, zIndex, new GridSpace());
				}
			}
		}
		
		this.houseCooldown = TEDemonPortal.buildingGridDelay;
		this.roadCooldown = TEDemonPortal.roadGridDelay;
		
		isInitialized = true;
	}
	
	@Override
	public void updateEntity()
	{
		if(!isInitialized)
		{
			return;
		}
		
		if(this.roadCooldown <= 0)
		{
			int roadsMade = this.createRandomRoad();
			if(roadsMade > 0)
			{
				this.roadCooldown = TEDemonPortal.roadGridDelay * roadsMade;
			}
		}
		else if(this.houseCooldown <= 0)
		{
			int gridsUsed = this.createRandomBuilding(0, 0);
			if(gridsUsed > 0)
			{
				this.houseCooldown = TEDemonPortal.buildingGridDelay * gridsUsed;
			}
		}
		
		this.houseCooldown = Math.max(0, this.houseCooldown - 1);
		this.roadCooldown = Math.max(0, this.roadCooldown - 1);
	}
	
	@Override
    public void readFromNBT(NBTTagCompound par1NBTTagCompound)
    {
        super.readFromNBT(par1NBTTagCompound);
        this.negXRadius = par1NBTTagCompound.getInteger("negXRadius");
        this.negZRadius = par1NBTTagCompound.getInteger("negZRadius");
        this.posXRadius = par1NBTTagCompound.getInteger("posXRadius");
        this.posZRadius = par1NBTTagCompound.getInteger("posZRadius");
        this.houseCooldown = par1NBTTagCompound.getInteger("houseCooldown");
        this.roadCooldown = par1NBTTagCompound.getInteger("roadCooldown");
        
        area = new GridSpace[negXRadius + posXRadius + 1][negZRadius + posZRadius + 1];
        
        NBTTagList tagList = par1NBTTagCompound.getTagList("Grid",Constants.NBT.TAG_COMPOUND);

        for (int i = 0; i < tagList.tagCount(); i++)
        {
        	int length = (negZRadius+posZRadius+1);
        	
        	int x = i/length;
        	int z = i%length;
        	
            NBTTagCompound tag = (NBTTagCompound) tagList.getCompoundTagAt(i);
            GridSpace space = GridSpace.getGridFromTag(tag);
            
            area[x][z] = space;
        }
        
        this.isInitialized = par1NBTTagCompound.getBoolean("init");
        
        this.tier = par1NBTTagCompound.getInteger("tier");
        this.totalPoints = par1NBTTagCompound.getInteger("totalPoints");
    }
	
	@Override
    public void writeToNBT(NBTTagCompound par1NBTTagCompound)
    {
        super.writeToNBT(par1NBTTagCompound);
        par1NBTTagCompound.setInteger("negXRadius", negXRadius);
        par1NBTTagCompound.setInteger("negZRadius", negZRadius);
        par1NBTTagCompound.setInteger("posXRadius", posXRadius);
        par1NBTTagCompound.setInteger("posZRadius", posZRadius);
        par1NBTTagCompound.setInteger("houseCooldown", houseCooldown);
        par1NBTTagCompound.setInteger("roadCooldown", roadCooldown);

        NBTTagList gridList = new NBTTagList();

        for(int i=0; i<=negXRadius+posXRadius; i++)
        {
        	for(int j=0; j<=negZRadius+posZRadius; j++)
        	{
        		int index = i + (negZRadius+posZRadius+1)*j;
        		
        		GridSpace space = area[i][j];
        		NBTTagCompound nextTag;
        		
        		if(space == null)
        		{
        			nextTag = new GridSpace().getTag();
        		}else
        		{
        			nextTag = space.getTag();
        		}
        		
        		gridList.appendTag(nextTag);
        	}
        }

        par1NBTTagCompound.setTag("Grid", gridList);
        
        par1NBTTagCompound.setBoolean("init", isInitialized);
        par1NBTTagCompound.setInteger("tier", this.tier);
        par1NBTTagCompound.setInteger("totalPoints", this.totalPoints);
    }
	
	public int createRandomRoad() //Return the number of road spaces
	{
		int next = rand.nextInt(4);
		ForgeDirection dir;
		
		switch(next)
		{
		case 0:
			dir = ForgeDirection.NORTH;
			break;
		case 1:
			dir = ForgeDirection.SOUTH;
			break;
		case 2:
			dir = ForgeDirection.EAST;
			break;
		case 3:
			dir = ForgeDirection.WEST;
			break;
		default:
			dir = ForgeDirection.NORTH;
		}
		
		int length = 5;
		
		Int3 road = findRoadSpaceFromDirection(dir, (rand.nextInt(negXRadius + negZRadius + posXRadius + posZRadius))+1);
		
		int x = road.xCoord;
		int yLevel = road.yCoord;
		int z = road.zCoord;
		
		System.out.println("X: " + x + " Z: " + z + " Direction: " + dir.toString());
		
		List<ForgeDirection> directions = this.findValidExtentionDirection(x, z);
		
		if(directions.size() <= 0)
		{
			return 0;
		}
		
		int maxDistance = 5;
		
		int distance = 0;
		ForgeDirection dominantDirection = null;
		
		for(ForgeDirection direction: directions)
		{
			int amt = this.getLength(direction, maxDistance, x, z);
			if(amt > distance)
			{
				distance = amt;
				dominantDirection = direction;
			}else if(amt == distance && rand.nextBoolean())
			{
				dominantDirection = direction;
			}
		}
		
		if(dominantDirection == null)
		{
			return 0;
		}
		System.out.println("I got here!");
		System.out.println("Distance: " + distance + " Direction: " + dominantDirection.toString() + " yLevel: " + yLevel);
		
		this.createGriddedRoad(x, yLevel, z, dominantDirection, distance+1, true);
		
		return distance;
	}
	
	public List<ForgeDirection> findValidExtentionDirection(int x, int z)
	{
		List<ForgeDirection> directions = new LinkedList();
		
		if(this.getGridSpace(x, z) == null || !this.getGridSpace(x, z).isRoadSegment())
		{
			return directions;
		}
		
		GridSpace nextGrid = this.getGridSpace(x+1, z);
		if(nextGrid.isEmpty())
		{
			directions.add(ForgeDirection.EAST);
		}
		
		nextGrid = this.getGridSpace(x-1, z);
		if(nextGrid.isEmpty())
		{
			directions.add(ForgeDirection.WEST);
		}
		
		nextGrid = this.getGridSpace(x, z+1);
		if(nextGrid.isEmpty())
		{
			directions.add(ForgeDirection.SOUTH);
		}
		
		nextGrid = this.getGridSpace(x, z-1);
		if(nextGrid.isEmpty())
		{
			directions.add(ForgeDirection.NORTH);
		}
		
		return directions;
	}
	
	public int getLength(ForgeDirection dir, int maxLength, int x, int z) //Number of spaces forward
	{
		for(int i=1; i<=maxLength; i++)
		{
			GridSpace space = this.getGridSpace(x + i*dir.offsetX, z + i*dir.offsetZ);
			if(space.isEmpty())
			{
				for(int k=1; k<=this.getRoadSpacer(); k++)
				{
					GridSpace space1 = this.getGridSpace(x + i*dir.offsetX + dir.offsetZ*k, z + i*dir.offsetZ + dir.offsetX*k);
					GridSpace space2 = this.getGridSpace(x + i*dir.offsetX - dir.offsetZ*k, z + i*dir.offsetZ - dir.offsetX*k);

					if(space1.isRoadSegment() || space2.isRoadSegment())
					{
						return i-1;
					}
				}
				
				continue;
			}
			if(space.isRoadSegment())
			{
				return i;
			}else
			{
				return i-1;
			}
		}
		return maxLength;
	}
	
	public Int3 findRoadSpaceFromDirection(ForgeDirection dir, int amount)
	{
		int index = 0;
		if(dir == ForgeDirection.NORTH)
		{
			System.out.print("NORTH!");
			for(int i=0; i<= negZRadius + posZRadius; i++)
			{
				for(int j=0; j<= negXRadius + posXRadius; j++)
				{
					GridSpace space = area[j][i];
					if(space.isRoadSegment())
					{
						index++;
						if(index >= amount)
						{
							return new Int3(j-negXRadius,space.getYLevel(),i-negZRadius);
						}
					}
				}
			}
		}else if(dir == ForgeDirection.SOUTH)
		{
			for(int i=negZRadius + posZRadius; i >= 0 ; i--)
			{
				for(int j=0; j<= negXRadius + posXRadius; j++)
				{
					GridSpace space = area[j][i];
					if(space.isRoadSegment())
					{
						index++;
						if(index >= amount)
						{
							return new Int3(j-negXRadius,space.getYLevel(),i-negZRadius);
						}
					}
				}
			}
		}else if(dir == ForgeDirection.EAST)
		{				
			for(int i=negXRadius + posXRadius; i >= 0; i--)
			{
				for(int j=0; j <= negZRadius + posZRadius ; j++)
				{
					GridSpace space = area[i][j];
					if(space.isRoadSegment())
					{
						index++;
						if(index >= amount)
						{
							return new Int3(i-negXRadius,space.getYLevel(),j-negZRadius);
						}
					}
				}
			}
		}else if(dir == ForgeDirection.WEST)
		{
			for(int i=0; i <= negXRadius + posXRadius; i++)
			{
				for(int j=0; j <= negZRadius + posZRadius ; j++)
				{
					GridSpace space = area[i][j];
					if(space.isRoadSegment())
					{
						index++;
						if(index >= amount)
						{
							return new Int3(i-negXRadius,space.getYLevel(),j-negZRadius);
						}
					}
				}
			}
		}
		
		return new Int3(0,0,0);
	}
	
	public Int3 findEmptySpaceNearRoad(ForgeDirection dir, int amount, int closeness)
	{
		int index = 0;
		if(dir == ForgeDirection.NORTH)
		{
			System.out.print("NORTH!");
			for(int i=0; i<= negZRadius + posZRadius; i++)
			{
				for(int j=0; j<= negXRadius + posXRadius; j++)
				{
					GridSpace space = area[j][i];
					if(space.isEmpty())
					{
						int yLevel = this.findNearestRoadYLevel(j-negXRadius, i-negZRadius, closeness);
						if(yLevel == -1)
						{
							continue;
						}
						index++;
						if(index >= amount)
						{
							return new Int3(j-negXRadius,yLevel,i-negZRadius);
						}
					}
				}
			}
		}else if(dir == ForgeDirection.SOUTH)
		{
			for(int i=negZRadius + posZRadius; i >= 0 ; i--)
			{
				for(int j=0; j<= negXRadius + posXRadius; j++)
				{
					GridSpace space = area[j][i];
					int yLevel = this.findNearestRoadYLevel(j-negXRadius, i-negZRadius, closeness);
					if(yLevel == -1)
					{
						continue;
					}
					if(space.isEmpty())
					{
						index++;
						if(index >= amount)
						{
							return new Int3(j-negXRadius,yLevel,i-negZRadius);
						}
					}
				}
			}
		}else if(dir == ForgeDirection.EAST)
		{				
			for(int i=negXRadius + posXRadius; i >= 0; i--)
			{
				for(int j=0; j <= negZRadius + posZRadius ; j++)
				{
					GridSpace space = area[i][j];
					int yLevel = this.findNearestRoadYLevel(i-negXRadius, j-negZRadius, closeness);
					if(yLevel == -1)
					{
						continue;
					}
					if(space.isEmpty())
					{
						index++;
						if(index >= amount)
						{
							return new Int3(i-negXRadius,yLevel,j-negZRadius);
						}
					}
				}
			}
		}else if(dir == ForgeDirection.WEST)
		{
			for(int i=0; i <= negXRadius + posXRadius; i++)
			{
				for(int j=0; j <= negZRadius + posZRadius ; j++)
				{
					GridSpace space = area[i][j];
					int yLevel = this.findNearestRoadYLevel(i-negXRadius, j-negZRadius, closeness);
					if(yLevel == -1)
					{
						continue;
					}
					if(space.isEmpty())
					{
						index++;
						if(index >= amount)
						{
							return new Int3(i-negXRadius,yLevel,j-negZRadius);
						}
					}
				}
			}
		}
		
		return new Int3(0,0,0);
	}
	
	public Int3 findEmptySpaceFromDirection(ForgeDirection dir, int amount)
	{
		int index = 0;
		if(dir == ForgeDirection.NORTH)
		{
			System.out.print("NORTH!");
			for(int i=0; i<= negZRadius + posZRadius; i++)
			{
				for(int j=0; j<= negXRadius + posXRadius; j++)
				{
					GridSpace space = area[j][i];
					if(space.isEmpty())
					{
						index++;
						if(index >= amount)
						{
							return new Int3(j-negXRadius,space.getYLevel(),i-negZRadius);
						}
					}
				}
			}
		}else if(dir == ForgeDirection.SOUTH)
		{
			for(int i=negZRadius + posZRadius; i >= 0 ; i--)
			{
				for(int j=0; j<= negXRadius + posXRadius; j++)
				{
					GridSpace space = area[j][i];
					if(space.isEmpty())
					{
						index++;
						if(index >= amount)
						{
							return new Int3(j-negXRadius,space.getYLevel(),i-negZRadius);
						}
					}
				}
			}
		}else if(dir == ForgeDirection.EAST)
		{				
			for(int i=negXRadius + posXRadius; i >= 0; i--)
			{
				for(int j=0; j <= negZRadius + posZRadius ; j++)
				{
					GridSpace space = area[i][j];
					if(space.isEmpty())
					{
						index++;
						if(index >= amount)
						{
							return new Int3(i-negXRadius,space.getYLevel(),j-negZRadius);
						}
					}
				}
			}
		}else if(dir == ForgeDirection.WEST)
		{
			for(int i=0; i <= negXRadius + posXRadius; i++)
			{
				for(int j=0; j <= negZRadius + posZRadius ; j++)
				{
					GridSpace space = area[i][j];
					if(space.isEmpty())
					{
						index++;
						if(index >= amount)
						{
							return new Int3(i-negXRadius,space.getYLevel(),j-negZRadius);
						}
					}
				}
			}
		}
		
		return new Int3(0,0,0);
	}
	
	public void createGriddedRoad(int gridXi, int yi, int gridZi, ForgeDirection dir, int gridLength, boolean convertStarter) //Total grid length
	{	
		if(gridLength == 0 || gridLength == 1)
		{
			return;
		}
		
		if(convertStarter)
		{
			
		}
		
		int initGridX = gridXi;
		int initGridZ = gridZi;
		int initY = yi;
		
		if(convertStarter)
		{
			this.setGridSpace(initGridX, initGridZ, new GridSpace(GridSpace.CROSSROAD,initY));
			
			DemonCrosspath crosspath = new DemonCrosspath(xCoord + initGridX*5, initY, zCoord + initGridZ*5);
			crosspath.createCrosspath(worldObj);
		}
		
		for(int index=0; index<gridLength-1; index++)
		{
			DemonVillagePath path = new DemonVillagePath(xCoord + initGridX*5, initY, zCoord + initGridZ*5, dir, 6);
			
			Int3 next = path.constructFullPath(worldObj, this.getRoadStepClearance(), this.getRoadBlock(), this.getRoadMeta());
			
			if(next != null)
			{
				initY = next.yCoord;
				System.out.println("" + initY);
			}
			
			initGridX += dir.offsetX;
			initGridZ += dir.offsetZ;
			
			if(!this.getGridSpace(initGridX, initGridZ).isRoadSegment())
			{
				this.setGridSpace(initGridX, initGridZ, new GridSpace(GridSpace.ROAD,initY));
			}	
		}
	}
	
	public void expandAreaInNegX()
	{
		GridSpace[][] newGrid = new GridSpace[negXRadius + posXRadius + 2][negZRadius + posZRadius + 1];
		for(int i=0; i<=negZRadius + posZRadius; i++)
		{
			newGrid[0][i] = new GridSpace();
		}
		
		for(int i=0; i<=negXRadius + posXRadius; i++)
		{
			for(int j=0; j<=negZRadius + posZRadius; j++)
			{
				newGrid[i+1][j] = area[i][j];
			}
		}
		
		area = newGrid;
		negXRadius += 1;
	}
	
	public void expandAreaInPosX()
	{
		GridSpace[][] newGrid = new GridSpace[negXRadius + posXRadius + 2][negZRadius + posZRadius + 1];
		
		for(int i=0; i<=negZRadius + posZRadius; i++)
		{
			newGrid[negXRadius + posXRadius + 1][i] = new GridSpace();
		}
		
		for(int i=0; i<=negXRadius + posXRadius; i++)
		{
			for(int j=0; j<=negZRadius + posZRadius; j++)
			{
				newGrid[i][j] = area[i][j];
			}
		}
		
		area = newGrid;
		posXRadius += 1;
	}
	
	public void expandAreaInNegZ()
	{
		GridSpace[][] newGrid = new GridSpace[negXRadius + posXRadius + 1][negZRadius + posZRadius + 2];
		
		System.out.println("x " + newGrid.length + "z " + newGrid[0].length);
		
		for(int i=0; i<=negXRadius + posXRadius; i++)
		{
			newGrid[i][0] = new GridSpace();
		}
		
		for(int i=0; i<=negXRadius + posXRadius; i++)
		{
			for(int j=0; j<=negZRadius + posZRadius; j++)
			{
				newGrid[i][j+1] = area[i][j];
			}
		}
		
		area = newGrid;
		negZRadius += 1;
	}
	
	public void expandAreaInPosZ()
	{
		GridSpace[][] newGrid = new GridSpace[negXRadius + posXRadius + 1][negZRadius + posZRadius + 2];
		
		for(int i=0; i<=negXRadius + posXRadius; i++)
		{
			newGrid[i][negZRadius + posZRadius + 1] = new GridSpace();
		}
		
		for(int i=0; i<=negXRadius + posXRadius; i++)
		{
			for(int j=0; j<=negZRadius + posZRadius; j++)
			{
				newGrid[i][j] = area[i][j];
			}
		}
		
		area = newGrid;
		posZRadius += 1;
	}
	
	public GridSpace getGridSpace(int x, int z)
	{
		if(x > posXRadius|| x < -negXRadius || z > posZRadius || z < -negZRadius)
		{
			return new GridSpace();
		}else
		{
			return (area[x + negXRadius][z + negZRadius]);
		}
	}
	
	public void setGridSpace(int x, int z, GridSpace space)
	{
		if(x > posXRadius)
		{
			this.expandAreaInPosX();
			this.setGridSpace(x, z, space);
			return;
		}else if(x < -negXRadius)
		{
			this.expandAreaInNegX();
			this.setGridSpace(x, z, space);
			return;
		}else if(z > posZRadius)
		{
			this.expandAreaInPosZ();
			this.setGridSpace(x, z, space);
			return;
		}else if(z < -negZRadius)
		{
			this.expandAreaInNegZ();
			this.setGridSpace(x, z, space);
			return;
		}else
		{
			area[x + negXRadius][z + negZRadius] = space;
		}
	}
	
	public void rightClickBlock(EntityPlayer player, int side)
	{
		if(worldObj.isRemote)
		{
			return;
		}
		
		this.initialize();
		
		if(ForgeDirection.getOrientation(side) == ForgeDirection.UP)
		{
			this.createRandomBuilding(DemonBuilding.BUILDING_HOUSE, 0);
		}else if(ForgeDirection.getOrientation(side) == ForgeDirection.DOWN)
		{
			this.createRandomBuilding(DemonBuilding.BUILDING_PORTAL, 0);
		}else
		{
			this.createRandomRoad();
		}
	}
	
	public int createRandomBuilding(int type, int tier)
	{
		switch(type)
		{
		case DemonBuilding.BUILDING_HOUSE:
			return this.createRandomHouse(tier);
		case DemonBuilding.BUILDING_PORTAL:
			return this.createPortalBuilding(tier);
		}
		
		return 0;
	}
	
	public int createPortalBuilding(int buildingTier)
	{
		int x = 0;
		int z = 0;
		
		GridSpace home = this.getGridSpace(x, z);
		int yLevel = home.getYLevel();
		
		GridSpaceHolder grid = this.createGSH();
		
		List<ForgeDirection> directions = new ArrayList();
		
		for(int i=2; i<6; i++)
		{
			ForgeDirection testDir = ForgeDirection.getOrientation(i);
			//if(this.getGridSpace(x + testDir.offsetX, z + testDir.offsetZ).isEmpty())
			{
				directions.add(testDir);
			}
		}
		
		if(directions.isEmpty())
		{
			return 0;
		}
					
		HashMap<ForgeDirection, List<DemonBuilding>> schemMap = new HashMap();
		
		for(ForgeDirection nextDir : directions)
		{
			for(DemonBuilding build : TEDemonPortal.buildingList)
			{
				if(build.buildingType != DemonBuilding.BUILDING_PORTAL)
				{
					continue;
				}
				if(schemMap.containsKey(nextDir))
				{
					schemMap.get(nextDir).add(build);
				}else
				{
					schemMap.put(nextDir, new ArrayList());
					schemMap.get(nextDir).add(build);
				}
			}
		}
		
		if(schemMap.keySet().isEmpty())
		{
			return 0;
		}
		
		ForgeDirection chosenDirection = (ForgeDirection) schemMap.keySet().toArray()[new Random().nextInt(schemMap.keySet().size())];
		DemonBuilding build = schemMap.get(chosenDirection).get(new Random().nextInt(schemMap.get(chosenDirection).size()));
					
		build.destroyAllInField(worldObj, xCoord + (x)*5, yLevel, zCoord + (z)*5, chosenDirection.getOpposite());
		
		Int3 portalSpace = build.getDoorSpace(chosenDirection);
		int yOffset = portalSpace.yCoord;
		
		for(int i=0; i<256; i++)
		{
			Block block = worldObj.getBlock(xCoord + (x)*5, i, zCoord + (z)*5);
			if(block == ModBlocks.blockDemonPortal)
			{
				BlockTeleposer.swapBlocks(worldObj, worldObj, xCoord, i, zCoord, xCoord, yLevel + yOffset, zCoord);
				break;
			}
		}
		
		build.buildAll(worldObj, xCoord + (x)*5, yLevel, zCoord + (z)*5, chosenDirection.getOpposite());
		build.setAllGridSpaces(x, z, yLevel, chosenDirection.getOpposite(), GridSpace.MAIN_PORTAL, grid);
		this.loadGSH(grid);
		
		return build.getNumberOfGridSpaces();
	}
	
	public int createRandomHouse(int buildingTier)
	{
		int next = rand.nextInt(4);
		ForgeDirection dir;
		
		switch(next)
		{
		case 0:
			dir = ForgeDirection.NORTH;
			break;
		case 1:
			dir = ForgeDirection.SOUTH;
			break;
		case 2:
			dir = ForgeDirection.EAST;
			break;
		case 3:
			dir = ForgeDirection.WEST;
			break;
		default:
			dir = ForgeDirection.NORTH;
		}
		
		boolean newProtocol = true;
		
		if(newProtocol)
		{
			Int3 space = this.findRoadSpaceFromDirection(dir, 1*(rand.nextInt(negXRadius + negZRadius + posXRadius + posZRadius))+1);
			
			int x = space.xCoord;
			int z = space.zCoord;
			int yLevel = space.yCoord;
			
			System.out.println("Road space - x: " + x + " z: " + z);
			
			GridSpaceHolder grid = this.createGSH();
			
			if(!this.getGridSpace(x, z).isRoadSegment())
			{
				return 0;
			}
						
			List<ForgeDirection> directions = new ArrayList();
			
			for(int i=2; i<6; i++)
			{
				ForgeDirection testDir = ForgeDirection.getOrientation(i);
				if(this.getGridSpace(x + testDir.offsetX, z + testDir.offsetZ).isEmpty())
				{
					directions.add(testDir);
				}
			}
			
			if(directions.isEmpty())
			{
				return 0;
			}
						
			HashMap<ForgeDirection, List<DemonBuilding>> schemMap = new HashMap();
			
			for(ForgeDirection nextDir : directions)
			{
				for(DemonBuilding build : TEDemonPortal.buildingList)
				{
					if(build.buildingTier != buildingTier || build.buildingType != DemonBuilding.BUILDING_HOUSE)
					{
						continue;
					}
					Int3 offsetSpace = build.getGridOffsetFromRoad(nextDir, yLevel);
					int xOff = offsetSpace.xCoord;
					int zOff = offsetSpace.zCoord;
					
					if(build.isValid(grid, x + xOff, z + zOff, nextDir.getOpposite()))
					{
						if(schemMap.containsKey(nextDir))
						{
							schemMap.get(nextDir).add(build);
						}else
						{
							schemMap.put(nextDir, new ArrayList());
							schemMap.get(nextDir).add(build);
						}
					}else
					{
						System.out.println("This ISN'T valid!");
					}
				}
			}
			
			if(schemMap.keySet().isEmpty())
			{
				return 0;
			}
			
			ForgeDirection chosenDirection = (ForgeDirection) schemMap.keySet().toArray()[new Random().nextInt(schemMap.keySet().size())];
			DemonBuilding build = schemMap.get(chosenDirection).get(new Random().nextInt(schemMap.get(chosenDirection).size()));
			
			Int3 offsetSpace = build.getGridOffsetFromRoad(chosenDirection, yLevel);
			int xOff = offsetSpace.xCoord;
			int zOff = offsetSpace.zCoord;
						
			build.destroyAllInField(worldObj, xCoord + (x + xOff)*5, yLevel, zCoord + (z + zOff)*5, chosenDirection.getOpposite());
			build.buildAll(worldObj, xCoord + (x + xOff)*5, yLevel, zCoord + (z + zOff)*5, chosenDirection.getOpposite());
			build.setAllGridSpaces(x + xOff, z + zOff, yLevel, chosenDirection.getOpposite(), GridSpace.HOUSE, grid);
			this.loadGSH(grid);
			
			return build.getNumberOfGridSpaces();
		}else
		{
			Int3 space = findEmptySpaceNearRoad(dir, 3*(rand.nextInt(negXRadius + negZRadius + posXRadius + posZRadius))+1, 2);
			
			int x = space.xCoord;
			int z = space.zCoord;
			int yLevel = space.yCoord;
	
			GridSpace newSpace = this.getGridSpace(x, z);
			if(!newSpace.isEmpty())
			{
				return 0;
			}
			
			if(yLevel == -1)
			{
				return 0;
			}
			
			GridSpaceHolder grid = this.createGSH();
			
			ForgeDirection chosenDirection = ForgeDirection.NORTH;
			
			HashMap<ForgeDirection,List<DemonBuilding>> bigList = new HashMap();
			
			for(DemonBuilding build : TEDemonPortal.buildingList)
			{
				for(int i=2; i<6; i++)
				{
					chosenDirection = ForgeDirection.getOrientation(i);
					System.out.println("" + chosenDirection.toString());
					if(build.isValid(grid, x, z, chosenDirection))
					{
						System.out.println("Valid!");
						if(bigList.containsKey(chosenDirection))
						{
							bigList.get(chosenDirection).add(build);
						}else
						{
							bigList.put(chosenDirection, new ArrayList());
							bigList.get(chosenDirection).add(build);
						}
					}
				}		
			}
			
			chosenDirection = ForgeDirection.getOrientation(new Random().nextInt(4) + 2); //Change to favour a direction with a road nearby
			
			List<DemonBuilding> buildingList = bigList.get(chosenDirection);
			DemonBuilding build;
	
			if(buildingList != null && buildingList.size() > 0)
			{
				build = buildingList.get(new Random().nextInt(buildingList.size()));
			}else
			{
				return 0;
			}
			//TODO: Finish the selection algorythm
			//TODO: Should favour those directions that have a road right next to them.
			
			build.buildAll(worldObj, xCoord + x*5, yLevel, zCoord + z*5, chosenDirection);
			build.setAllGridSpaces(x, z, yLevel, chosenDirection, GridSpace.HOUSE, grid);
			this.loadGSH(grid);
			
			return build.getNumberOfGridSpaces();
//			System.out.println("X: " + x + " Z: " + z + " Direction: " + chosenDirection.toString());
		}
	}
	
	public int findNearestRoadYLevel(int xCoord, int zCoord, int maxDistance)
	{
		for(int l=1; l<=maxDistance; l++)
		{
			for(int i=-l; i<=l; i++)
			{
				for(int j=-l; j<=l; j++)
				{
					if(Math.abs(i)!=l && Math.abs(j)!=l)
					{
						continue;
					}
					
					if(this.getGridSpace(xCoord + i, zCoord + j).isRoadSegment())
					{
						return this.getGridSpace(xCoord + i, zCoord + j).getYLevel();
					}
				}
			}
		}
		
		return -1;
	}

	public void createRoad(int xi, int yi, int zi, ForgeDirection dir, int length, boolean doesNotDrop)
	{
		int curX = xi;
		int curY = yi;
		int curZ = zi;
		int roadRadius = this.getRoadRadius();
		
		if(dir.offsetY != 0)
		{
			return;
		}
		
		DemonVillagePath path = new DemonVillagePath(xi, yi, zi, dir, length);
		
		path.constructFullPath(worldObj, this.getRoadStepClearance(), this.getRoadBlock(), this.getRoadMeta());
	}
	
	public int placeMaterialOnNextAvailable()
	{
		return 0;
	}
	
	public int getRoadRadius()
	{
		return 1;
	}
	
	public Block getRoadBlock()
	{
		return Blocks.nether_brick;
	}
	
	public int getRoadMeta()
	{
		return 0;
	}
	
	public int getRoadStepClearance()
	{
		return 10;
	}
	
	public int getRoadSpacer()
	{
		return 1;
	}
	
	public GridSpaceHolder createGSH()
	{
		GridSpaceHolder grid = new GridSpaceHolder();
		grid.area = this.area;
		grid.negXRadius = this.negXRadius;
		grid.negZRadius = this.negZRadius;
		grid.posXRadius = this.posXRadius;
		grid.posZRadius = this.posZRadius;
		
		return grid;
	}
	
	public void loadGSH(GridSpaceHolder grid)
	{
		this.area = grid.area;
		this.negXRadius = grid.negXRadius;
		this.negZRadius = grid.negZRadius;
		this.posXRadius = grid.posXRadius;
		this.posZRadius = grid.posZRadius;
	}
	
	public static void loadBuildingList()
	{
		String folder = "config/BloodMagic/schematics";
		Gson gson = new GsonBuilder().setPrettyPrinting().create();
		
		File file = new File(folder);
		File[] files = file.listFiles();
		BufferedReader br;

		try{
			for(File f : files)
			{
				br = new BufferedReader(new FileReader(f));
				BuildingSchematic schema = gson.fromJson(br, BuildingSchematic.class);
				TEDemonPortal.buildingList.add(new DemonBuilding(schema));
			}
		}catch(FileNotFoundException e)
		{
			e.printStackTrace();
		}
//		
//		try {
//			br = new BufferedReader(new FileReader(folder + "test3.json"));
//			BuildingSchematic schema = gson.fromJson(br, BuildingSchematic.class);
//			TEDemonPortal.buildingList.add(new DemonBuilding(schema));
//		} catch (FileNotFoundException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
		
		
	}
	
	public int getTotalPoints()
	{
		return this.totalPoints;
	}
	
	public void addToPoints(int addition)
	{
		this.totalPoints += addition;
	}
}