package me.torrent.Teleporters;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Random;
import java.util.logging.Logger;

import org.bukkit.Effect;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
import org.bukkit.block.Chest;
import org.bukkit.block.Furnace;
import org.bukkit.entity.Player;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerListener;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;

public class TeleportersPlayerListenerExtended extends PlayerListener
{
    /* Initialize logger */
    public final Logger logger = Logger.getLogger( "Minecraft" );

    /* Create HasMap for teleporters */
    public final HashMap<Block, Teleporter> Teleporters = new HashMap<Block, Teleporter>();

    /* Obvious */
    public static Teleporters plugin;

    /* Start the class */
    public TeleportersPlayerListenerExtended( Teleporters instance )
    {
        plugin = instance;
    }

    /* When player tries to interact with blocks, this event is fired, this is good event for handling teleporter activities */
    public void onPlayerInteract( PlayerInteractEvent event )
    {
        if( event.getAction() == Action.RIGHT_CLICK_BLOCK )
        {
            Player player = event.getPlayer();
            Block block = event.getClickedBlock();
            ItemStack itemInHand = player.getItemInHand();

            if( block.getType() == Material.OBSIDIAN )
            {
                if( isTeleporter( block ) )
                {
                    tryTeleport( block, player );
                }
                else
                {
                    /*
                        If player is holding redstone ore, he can "debug" the teleporter
                        It's good because then your chat won't be spammed with text each
                        time you mess with obsidian blocks.
                    */
                    boolean validTeleporter = false;

                    boolean debug = false;
                    if( itemInHand.getType() != Material.REDSTONE_ORE )
                        debug = true;
                    else
                        debug = false;

                    List<String> isValidReturn = isValidTeleporter( block );

                    if( isValidReturn.get( 0 ) != "isValid" )
                    {
                        validTeleporter = false;
                        if( debug )
                        {
                            for( int i = 0; i < isValidReturn.size(); i++ )
                            {
                                player.sendMessage( String.valueOf( i + 1 ) + " " + isValidReturn.get( i ) );
                            }
                        }
                    }
                    else
                        validTeleporter = true;

                    if( validTeleporter )
                    {
                        Teleporter teleporterInfo = new Teleporter();

                        teleporterInfo.creator = player;
                        teleporterInfo.chest = GetChest( block );
                        teleporterInfo.furnace = GetFurnace( block );
                        teleporterInfo.date = new Date();

                        Teleporters.put( block, teleporterInfo );

                        player.sendMessage( "Teleporter is now functional!" );
                    }
                }
            }
        }
    }

    /* Custom classes and functions */

    /*
        tryTeleport
    */
    public void tryTeleport( Block block, Player player )
    {
        boolean validTeleporter = true;
        boolean doTeleport = false;

        World world = block.getWorld();

        List<String> isValidReturn = isValidTeleporter( block );

        if( isValidReturn.get( 0 ) != "isValid" )
        {
            validTeleporter = false;

            for( int i = 0; i < isValidReturn.size(); i++ )
            {
                player.sendMessage( String.valueOf( i + 1 ) + " " + isValidReturn.get( i ) );
            }

            Teleporters.remove( block );
        }

        Furnace thisFurnace = GetFurnace( block );

        Inventory thisInventory = thisFurnace.getInventory();

        if( thisInventory.contains( Material.COAL, 10 ) )
        {
            ItemStack removeItem = new ItemStack( Material.COAL, 10 );
            thisInventory.removeItem( removeItem );
            doTeleport = true;
        }
        else
        {
            player.sendMessage( "Teleporters furnace doesn't have enough coal!" );
            doTeleport = false;
        }

        List<Block> teleportLocations = new ArrayList<Block>();
        String teleporterCode = GetTeleporterCode( block );

        if( validTeleporter )
        {
            for (Block loopBlock : Teleporters.keySet())
            {
                String loopBlockCode = GetTeleporterCode( loopBlock );
                if( teleporterCode.contains( loopBlockCode ) || loopBlockCode.contains( teleporterCode ) )
                {
                    if( !String.valueOf( loopBlock.getLocation() ).contains( String.valueOf( block.getLocation() ) ) ||
                            !String.valueOf( block.getLocation() ).contains( String.valueOf( loopBlock.getLocation() ) ) )
                    {
                        teleportLocations.add( loopBlock );
                    }
                }
            }
        }

        if( doTeleport )
        {
            Block teleportBlock = null;
            if( teleportLocations.size() <= 0 )
            {
                player.sendMessage( "There is nowhere to teleport!" );
            }
            else if( teleportLocations.size() == 1 )
            {
                teleportBlock = teleportLocations.get( 0 );
            }
            else
            {
                Random randomIntGen = new Random();

                int RandomInt = randomIntGen.nextInt( teleportLocations.size() );

                player.sendMessage( String.valueOf( RandomInt) );

                teleportBlock = teleportLocations.get( RandomInt );
            }

            Location teleportCoordinates = GetClearTeleport( teleportBlock, player );

            if( teleportCoordinates != null )
            {
                world.playEffect( thisFurnace.getBlock().getLocation(), Effect.CLICK2, 10);
                player.teleport( teleportCoordinates );

                byte note = (byte) 0xFA;
                player.playNote( player.getLocation(), note, (byte) 10);
            }
            else
            {
                player.sendMessage( "Connection failed, something is blocking teleport in the other side!" );
            }
        }
    }

    Location GetClearTeleport( Block block, Player player )
    {
        World world = block.getWorld();
        int bX = block.getLocation().getBlockX();
        int bY = block.getLocation().getBlockY();
        int bZ = block.getLocation().getBlockZ();

        boolean teleportNotFound = true;

        Location returnLocation = null;

        int i = 0;
        while( teleportNotFound )
        {
            if( i >= 10 )
            {
                break;
            }

            Block FirstBlock = world.getBlockAt( bX, bY + 1 * i, bZ );
            Block SecondBlock = world.getBlockAt( bX, bY + 2 * i, bZ );

            if( FirstBlock.getType() == Material.AIR && SecondBlock.getType() == Material.AIR )
            {
                teleportNotFound = false;
                returnLocation = SecondBlock.getLocation();
            }
            else
            {
                i++;
            }
        }

        return (Location) returnLocation;


    }

    /*
        TELEPORTER
            Each teleporter will be added to the Teleporters HasMap, key will be the obisian block thats the teleporter, and
            value will be that class, so each teleporter will have its own chest, where players can initialize "password" to connect
            to other telepoters, furnace where players put coal, so they can't teleport all the time for free, because that would make
            game boring, just like /home /sethome plugin did.
            And ofcourse date so i can limit the time between each teleport.
    */
    class Teleporter
    {
        public Chest chest;
        public Furnace furnace;
        public Player creator;
        public Date date;
    }

    /*
        isTeleporter
            This function will see if the obsidian block is registered teleporter, i think i have to redo that
    */
    public boolean isTeleporter( Block block )
    {
        if( Teleporters.containsKey( block ) )
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /*
        isValidTeleporter
            This function will see if block has everything to be an teleporter
    */

    public List<String> isValidTeleporter( Block block )
    {
        List<String> returnList = new ArrayList<String>();

        Furnace validFurnace = null;
        if( GetFurnace( block ) != null)
            validFurnace = GetFurnace( block );

        if( validFurnace == null )
        {
            returnList.add( "Teleporter is missing furnace or has too many of them!" );
        }

        Chest validChest = null;
        if( GetChest( block ) != null )
            validChest = GetChest( block );

        if( validChest == null )
        {
            returnList.add( "Teleporter is missing chest or has too many of them!" );
        }
        else
        {
            Inventory validInventory = validChest.getInventory();

            ItemStack codeOne = validInventory.getItem( 0 );
            ItemStack codeTwo = validInventory.getItem( 1 );
            ItemStack codeThree = validInventory.getItem( 2 );
            ItemStack codeFour = validInventory.getItem( 3 );

            if(     codeOne.getType() == Material.AIR
                    || codeTwo.getType() == Material.AIR
                    || codeThree.getType() == Material.AIR
                    || codeFour.getType() == Material.AIR
            )
            {
                returnList.add( "Code for the teleporter contains empty slots!" );
            }
        }

        if( returnList.size() <= 0 )
        {
            returnList.add( "isValid" );
        }

        return returnList;
    }

    /*
        GetFurnace
            This function will get furnace around the obisidan block
    */
    public Furnace GetFurnace( Block block )
    {
        World world = block.getWorld();

        int bX = block.getLocation().getBlockX();
        int bY = block.getLocation().getBlockY();
        int bZ = block.getLocation().getBlockZ();

        Block newBlock = null;
        BlockState theFurnace;

        newBlock = world.getBlockAt( bX, bY, bZ + 1 );
        if( newBlock.getType() == Material.FURNACE )
        {
            theFurnace = newBlock.getState();
        }
        else
        {
            newBlock = world.getBlockAt( bX, bY, bZ - 1 );
            if( newBlock.getType() == Material.FURNACE )
            {
                theFurnace = newBlock.getState();
            }
            else
            {
                newBlock = world.getBlockAt( bX + 1, bY, bZ );
                if( newBlock.getType() == Material.FURNACE )
                {
                    theFurnace = newBlock.getState();
                }
                else
                {
                    newBlock = world.getBlockAt( bX - 1, bY, bZ );
                    if( newBlock.getType() == Material.FURNACE )
                    {
                        theFurnace = newBlock.getState();
                    }
                    else
                    {
                        return (Furnace) null;
                    }
                }

            }
        }

        return (Furnace) theFurnace;
    }

    /*
        GetChest
            This function will get chest around the obisidan block
    */
    public Chest GetChest( Block block )
    {
        World world = block.getWorld();

        int bX = block.getLocation().getBlockX();
        int bY = block.getLocation().getBlockY();
        int bZ = block.getLocation().getBlockZ();

        Block newBlock = null;
        BlockState theChest;

        newBlock = world.getBlockAt( bX, bY, bZ + 1 );
        if( newBlock.getType() == Material.CHEST )
        {
            theChest = newBlock.getState();
        }
        else
        {
            newBlock = world.getBlockAt( bX, bY, bZ - 1 );
            if( newBlock.getType() == Material.CHEST )
            {
                theChest = newBlock.getState();
            }
            else
            {
                newBlock = world.getBlockAt( bX + 1, bY, bZ );
                if( newBlock.getType() == Material.CHEST )
                {
                    theChest = newBlock.getState();
                }
                else
                {
                    newBlock = world.getBlockAt( bX - 1, bY, bZ );
                    if( newBlock.getType() == Material.CHEST )
                    {
                        theChest = newBlock.getState();
                    }
                    else
                    {
                        return (Chest) null;
                    }
                }

            }
        }

        return (Chest) theChest;
    }

    public String GetTeleporterCode( Block block )
    {
        Chest codeChest = null;
        if( GetChest( block ) != null )
            codeChest = GetChest( block );

        Inventory codeInventory = codeChest.getInventory();

        ItemStack codeOne = codeInventory.getItem( 0 );
        ItemStack codeTwo = codeInventory.getItem( 1 );
        ItemStack codeThree = codeInventory.getItem( 2 );
        ItemStack codeFour = codeInventory.getItem( 3 );

        String codeString = "";

        codeString += String.valueOf( codeOne.getTypeId() );
        codeString += String.valueOf( codeTwo.getTypeId() );
        codeString += String.valueOf( codeThree.getTypeId() );
        codeString += String.valueOf( codeFour.getTypeId() );

        return codeString;
    }
}