package com.piercecorcoran.laserPower;

import net.minecraft.block.Block;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.Packet;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import cofh.api.energy.EnergyStorage;
import cofh.api.energy.IEnergyHandler;
import cofh.api.energy.TileEnergyHandler;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

public class TileEntityMachineLaser extends TileEnergyHandler {

    public boolean isTransmitter;
    public int maxRange = 100;
    public ForgeDirection direction = null;
    private boolean hasConnection;
    public int length;


    public TileEntityMachineLaser(boolean transmitter) {
        super();
        isTransmitter = transmitter;
        this.storage = new EnergyStorage(1000000,10000,10000);
    }

    @Override
    public void readFromNBT(NBTTagCompound nbt) {
        super.writeToNBT(nbt);
        isTransmitter = nbt.getBoolean("isTransmitter");
        direction = ForgeDirection.getOrientation(nbt.getInteger("direction"));
    }

    @Override
    public void writeToNBT(NBTTagCompound nbt) {
        super.writeToNBT(nbt);
        nbt.setBoolean("isTransmitter", isTransmitter);
        nbt.setInteger("direction", getDirectionFacing().ordinal());
    }

    public static TileEntity createTileEntity(World world, int meta, boolean transmitter)
    {
       return new TileEntityMachineLaser(transmitter);
    }

    public boolean shouldDrawBeam() {
        if(!isTransmitter) return false;
        if(hasConnection) return true;
        return false;
    }

    public ForgeDirection getDirectionFacing() {
        if(direction == null) return ForgeDirection.NORTH;
        return direction;
    }

    public void outputToAdjacent() {
        for(ForgeDirection d : ForgeDirection.VALID_DIRECTIONS){
            int targetX = this.xCoord + d.offsetX;
            int targetY = this.yCoord + d.offsetY;
            int targetZ = this.zCoord + d.offsetZ;
            TileEntity tile = this.worldObj.getTileEntity(targetX, targetY, targetZ);
            if(tile instanceof IEnergyHandler) {
                IEnergyHandler h = (IEnergyHandler) tile;
                int canProvide = this.storage.extractEnergy(this.storage.getMaxExtract(), true);
                int canReceive =    h.receiveEnergy(d.getOpposite(), canProvide, false);
                this.storage.extractEnergy(canReceive, false);
            }
        }
    }

    public void updateEntity() {
        if(isTransmitter) {
            Block b = null;
            hasConnection = false;

            for(int i = 1; i < maxRange; i++) {
                int x = xCoord;
                int y = yCoord;
                int z = zCoord;

                switch(getDirectionFacing())
                {
                case UP:
                    y = y + i;
                    break;
                case DOWN:
                    y = y - i;
                    break;
                case SOUTH:
                    z = z + i;
                    break;
                case NORTH:
                    z = z - i;
                    break;
                case EAST:
                    x = x + i;
                    break;
                case WEST:
                    x = x - i;
                    break;
                default:
                }
                if(!worldObj.isAirBlock(x,y,z)) {
                    b = this.worldObj.getBlock(x,y,z);
                    if(b.equals(LaserPowerMod.blockLaserReceiver)) {
                        hasConnection = true;
                        IEnergyHandler tile = (IEnergyHandler) this.worldObj.getTileEntity(x,y,z);
                        int canProvide = this.storage.extractEnergy(this.storage.getMaxExtract(), true);
                        int canReceive = tile.receiveEnergy(getDirectionFacing().getOpposite(), canProvide, false);
                        this.storage.extractEnergy(canReceive, false);
                        System.out.println("transferred " + canReceive + "RF");
                    }
                    break;
                }

                length = i;
            }
        } else {
            outputToAdjacent();
        }
    }

    @Override
    @SideOnly(Side.CLIENT)
    public double getMaxRenderDistanceSquared()
    {
        return 65536;
    }

    @Override
    @SideOnly(Side.CLIENT)
    public AxisAlignedBB getRenderBoundingBox()
    {
        return INFINITE_EXTENT_AABB;
    }
}