package WayofTime.bloodmagic.inversion;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.soul.EnumDemonWillType;

public class InversionPillarHandler
{
    public static final double farthestDistanceSquared = 16 * 16;
    public static Map<Integer, Map<EnumDemonWillType, List<BlockPos>>> pillarMap = new HashMap<Integer, Map<EnumDemonWillType, List<BlockPos>>>();
    public static Map<Integer, Map<EnumDemonWillType, Map<BlockPos, List<BlockPos>>>> nearPillarMap = new HashMap<Integer, Map<EnumDemonWillType, Map<BlockPos, List<BlockPos>>>>();

    public static boolean addPillarToMap(World world, EnumDemonWillType type, BlockPos pos)
    {
        int dim = world.provider.getDimension();
        if (pillarMap.containsKey(dim))
        {
            Map<EnumDemonWillType, List<BlockPos>> willMap = pillarMap.get(dim);
            if (willMap.containsKey(type))
            {
                if (!willMap.get(type).contains(pos))
                {
                    willMap.get(type).add(pos);
                    onPillarAdded(world, type, pos);
                    return true;
                } else
                {
                    return false;
                }
            } else
            {
                List<BlockPos> posList = new ArrayList<BlockPos>();
                posList.add(pos);
                willMap.put(type, posList);
                onPillarAdded(world, type, pos);
                return true;
            }
        } else
        {
            Map<EnumDemonWillType, List<BlockPos>> willMap = new HashMap<EnumDemonWillType, List<BlockPos>>();
            List<BlockPos> posList = new ArrayList<BlockPos>();
            posList.add(pos);

            willMap.put(type, posList);
            pillarMap.put(dim, willMap);
            onPillarAdded(world, type, pos);
            return true;
        }
    }

    public static boolean removePillarFromMap(World world, EnumDemonWillType type, BlockPos pos)
    {
        int dim = world.provider.getDimension();
        if (pillarMap.containsKey(dim))
        {
            Map<EnumDemonWillType, List<BlockPos>> willMap = pillarMap.get(dim);
            if (willMap.containsKey(type))
            {
                if (willMap.get(type).contains(pos))
                {
                    onPillarRemoved(world, type, pos);
                    return willMap.get(type).remove(pos);
                } else
                {
                    return false;
                }
            } else
            {
                return false;
            }
        } else
        {
            return false;
        }
    }

    //Assume that it has been added already.
    private static void onPillarAdded(World world, EnumDemonWillType type, BlockPos pos)
    {
        System.out.println("Adding...");
        List<BlockPos> closePosList = new ArrayList<BlockPos>();

        int dim = world.provider.getDimension();
        if (pillarMap.containsKey(dim))
        {
            Map<EnumDemonWillType, List<BlockPos>> willMap = pillarMap.get(dim);
            if (willMap.containsKey(type))
            {
                List<BlockPos> otherPosList = willMap.get(type);

                Iterator<BlockPos> posIterator = otherPosList.iterator();
                while (posIterator.hasNext())
                {
                    BlockPos closePos = posIterator.next();
                    if (!closePos.equals(pos) && closePos.distanceSq(pos) <= farthestDistanceSquared)
                    {
                        closePosList.add(closePos);
                    }
                }

            }
        }
        if (nearPillarMap.containsKey(dim))
        {
            Map<EnumDemonWillType, Map<BlockPos, List<BlockPos>>> willMap = nearPillarMap.get(dim);
            if (willMap.containsKey(type))
            {
                Map<BlockPos, List<BlockPos>> posMap = willMap.get(type);

                Iterator<BlockPos> closePosIterator = closePosList.iterator();
                while (closePosIterator.hasNext())
                {
                    BlockPos closePos = closePosIterator.next();
                    List<BlockPos> posList = posMap.get(closePos);
                    if (posList != null && !posList.contains(pos))
                    {
                        posList.add(pos);
                    } else
                    {
                        posList = new ArrayList<BlockPos>();
                        posList.add(pos);
                        posMap.put(closePos, posList);
                    }
                }

                posMap.put(pos, closePosList);
            } else
            {
                Map<BlockPos, List<BlockPos>> posMap = new HashMap<BlockPos, List<BlockPos>>();

                posMap.put(pos, closePosList);
                willMap.put(type, posMap);
            }
        } else
        {
            Map<EnumDemonWillType, Map<BlockPos, List<BlockPos>>> willMap = new HashMap<EnumDemonWillType, Map<BlockPos, List<BlockPos>>>();
            Map<BlockPos, List<BlockPos>> posMap = new HashMap<BlockPos, List<BlockPos>>();

            posMap.put(pos, closePosList);
            willMap.put(type, posMap);
            nearPillarMap.put(dim, willMap);
        }
    }

    private static void onPillarRemoved(World world, EnumDemonWillType type, BlockPos pos)
    {
        System.out.println("Removing...");
        int dim = world.provider.getDimension();
        if (nearPillarMap.containsKey(dim))
        {
            Map<EnumDemonWillType, Map<BlockPos, List<BlockPos>>> willMap = nearPillarMap.get(dim);
            if (willMap.containsKey(type))
            {
                Map<BlockPos, List<BlockPos>> posMap = willMap.get(type);
                List<BlockPos> posList = posMap.get(pos);
                if (posList != null)
                {
                    Iterator<BlockPos> itr = posList.iterator();
                    while (itr.hasNext())
                    {
                        BlockPos checkPos = itr.next();
                        List<BlockPos> checkPosList = posMap.get(checkPos);
                        if (checkPosList != null)
                        {
                            checkPosList.remove(pos);
                        }
                    }

                    posMap.remove(pos);
                }
            }
        }
    }

    //TODO: Change to use the nearPillarMap.
    public static List<BlockPos> getNearbyPillars(World world, EnumDemonWillType type, BlockPos pos)
    {
        int dim = world.provider.getDimension();
        if (nearPillarMap.containsKey(dim))
        {
            Map<EnumDemonWillType, Map<BlockPos, List<BlockPos>>> willMap = nearPillarMap.get(dim);
            if (willMap.containsKey(type))
            {
                Map<BlockPos, List<BlockPos>> posMap = willMap.get(type);
                List<BlockPos> posList = posMap.get(pos);
                if (posList != null)
                {
                    return posList;
                }
            }
        }

        return new ArrayList<BlockPos>();
    }
}