package electrosphere.entity.state.equip;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import electrosphere.collision.dispatch.CollisionObject;
import electrosphere.dynamics.RigidBody;
import electrosphere.entity.Entity;
import electrosphere.entity.EntityDataStrings;
import electrosphere.entity.EntityUtils;
import electrosphere.entity.types.attach.AttachUtils;
import electrosphere.entity.types.creature.CreatureUtils;
import electrosphere.entity.types.item.ItemUtils;
import electrosphere.game.client.targeting.crosshair.Crosshair;
import electrosphere.game.collision.collidable.Collidable;
import electrosphere.game.data.creature.type.equip.EquipPoint;
import electrosphere.game.data.item.type.EquipWhitelist;
import electrosphere.main.Globals;
import electrosphere.renderer.actor.Actor;
import electrosphere.renderer.actor.ActorMeshMask;

/**
 *
 * @author amaterasu
 */
public class EquipState {
    
    Entity parent;

    List<EquipPoint> equipPoints = new LinkedList<EquipPoint>();
    Map<String,Entity> equipMap = new HashMap<String,Entity>();
    
    public EquipState(Entity parent, List<EquipPoint> equipPoints){
        this.parent = parent;
        for(EquipPoint point : equipPoints){
            this.equipPoints.add(point);
        }
    }

    public List<String> equippedPoints(){
        return new LinkedList<String>(equipMap.keySet());
    }
    
    public void attemptEquip(Entity toEquip, EquipPoint point){
        boolean hasEquipped = equipMap.containsKey(point.getEquipPointId());
        boolean targetIsItem = ItemUtils.isItem(toEquip);
        boolean targetIsAttached = AttachUtils.isAttached(toEquip);
        boolean targetHasWhitelist = ItemUtils.hasEquipList(toEquip);
        String equipItemClass = ItemUtils.getEquipClass(toEquip);//somehow resolve from toEquip
        List<String> pointEquipClassList = point.getEquipClassWhitelist();
        boolean itemIsInPointWhitelist = pointEquipClassList.contains(equipItemClass);
        if(!hasEquipped && targetIsItem && !targetIsAttached && itemIsInPointWhitelist){
            if(targetHasWhitelist){
                //by attaching are we going to be replacing meshes?
                String parentCreatureId = CreatureUtils.getType(parent);
                List<EquipWhitelist> whitelist = ItemUtils.getEquipWhitelist(toEquip);
                for(EquipWhitelist whitelistItem : whitelist){
                    if(whitelistItem.getCreatureId().equals(parentCreatureId)){
                        //put in map
                        equipMap.put(point.getEquipPointId(),toEquip);
                        String modelName = whitelistItem.getModel();
                        Globals.assetManager.addModelPathToQueue(modelName);
                        Actor parentActor = EntityUtils.getActor(parent);
                        //queue meshes from display model to parent actor
                        ActorMeshMask meshMask = parentActor.getMeshMask();
                        for(String toBlock : whitelistItem.getMeshMaskList()){
                            meshMask.blockMesh(modelName, toBlock);
                        }
                        for(String toDraw : whitelistItem.getMeshList()){
                            meshMask.queueMesh(modelName, toDraw);
                        }
                        //attach to parent bone
                        AttachUtils.attachEntityToEntityAtBone(parent, toEquip, point.getBone());
                        //make uncollidable
                        if(toEquip.containsKey(EntityDataStrings.PHYSICS_COLLISION_BODY) && toEquip.containsKey(EntityDataStrings.PHYSICS_COLLIDABLE)){
                            CollisionObject rigidBody = (CollisionObject)toEquip.getData(EntityDataStrings.PHYSICS_COLLISION_BODY);
                            Globals.collisionEngine.deregisterPhysicsObject(rigidBody);
                        }
                        //hide toEquip actor
                        EntityUtils.setDraw(toEquip, false);
                        //make untargetable
                        Globals.entityManager.setTargetable(toEquip, false);
                        break;
                    }
                }
            } else {
                //since we're not replacing meshes we must be attaching to a bone
                equipMap.put(point.getEquipPointId(),toEquip);
                AttachUtils.attachEntityToEntityAtBone(parent, toEquip, point.getBone());
                if(toEquip.containsKey(EntityDataStrings.PHYSICS_COLLISION_BODY) && toEquip.containsKey(EntityDataStrings.PHYSICS_COLLIDABLE)){
                    CollisionObject rigidBody = (CollisionObject)toEquip.getData(EntityDataStrings.PHYSICS_COLLISION_BODY);
                    Globals.collisionEngine.deregisterPhysicsObject(rigidBody);
                }
                Globals.entityManager.setTargetable(toEquip, false);
            }
        }

        // if(!hasEquipPrimary() && ItemUtils.isItem(toEquip) && !AttachUtils.isAttached(toEquip)){
        //     if(ItemUtils.hasEquipList(toEquip)){
        //         String parentCreatureId = CreatureUtils.getType(parent);
        //         List<EquipWhitelist> whitelist = ItemUtils.getEquipWhitelist(toEquip);
        //         for(EquipWhitelist whitelistItem : whitelist){
        //             if(whitelistItem.getCreatureId().equals(parentCreatureId)){
        //                 equipPrimary = toEquip;
        //                 String modelName = whitelistItem.getModel();
        //                 Globals.assetManager.addModelPathToQueue(modelName);
        //                 Actor parentActor = EntityUtils.getActor(parent);
        //                 //queue meshes from display model to parent actor
        //                 ActorMeshMask meshMask = parentActor.getMeshMask();
        //                 for(String toBlock : whitelistItem.getMeshMaskList()){
        //                     meshMask.blockMesh(modelName, toBlock);
        //                 }
        //                 for(String toDraw : whitelistItem.getMeshList()){
        //                     meshMask.queueMesh(modelName, toDraw);
        //                 }
        //                 //attach to parent bone
        //                 AttachUtils.attachEntityToEntityAtBone(parent, toEquip, equipPrimaryBoneName);
        //                 //make uncollidable
        //                 if(toEquip.getDataKeys().contains(EntityDataStrings.PHYSICS_COLLISION_BODY) && toEquip.getDataKeys().contains(EntityDataStrings.PHYSICS_COLLIDABLE)){
        //                     CollisionObject rigidBody = (CollisionObject)toEquip.getData(EntityDataStrings.PHYSICS_COLLISION_BODY);
        //                     Globals.collisionEngine.deregisterPhysicsObject(rigidBody);
        //                 }
        //                 //hide toEquip actor
        //                 EntityUtils.setDraw(toEquip, false);
        //                 //make untargetable
        //                 Globals.entityManager.setTargetable(equipPrimary, false);
        //                 break;
        //             }
        //         }
        //     } else {
        //         equipPrimary = toEquip;
        //         AttachUtils.attachEntityToEntityAtBone(parent, toEquip, equipPrimaryBoneName);
        //         if(toEquip.getDataKeys().contains(EntityDataStrings.PHYSICS_COLLISION_BODY) && toEquip.getDataKeys().contains(EntityDataStrings.PHYSICS_COLLIDABLE)){
        //             CollisionObject rigidBody = (CollisionObject)toEquip.getData(EntityDataStrings.PHYSICS_COLLISION_BODY);
        //             Globals.collisionEngine.deregisterPhysicsObject(rigidBody);
        //         }
        //         Globals.entityManager.setTargetable(equipPrimary, false);
        //     }
        // }
    }

    public EquipPoint getEquipPoint(String name){
        for(EquipPoint point : equipPoints){
            if(point.getEquipPointId().equals(name)){
                return point;
            }
        }
        return null;
    }

    public Entity getEquippedItemAtPoint(String point){
        return equipMap.get(point);
    }
    
    // public void drop(Entity entity){
        // if(hasEquipPrimary()){
        //     AttachUtils.detatchEntityFromEntityAtBone(parent,equipPrimary);
        //     if(equipPrimary.getDataKeys().contains(EntityDataStrings.PHYSICS_COLLISION_BODY) && equipPrimary.getDataKeys().contains(EntityDataStrings.PHYSICS_COLLIDABLE)){
        //         CollisionObject rigidBody = (CollisionObject)equipPrimary.getData(EntityDataStrings.PHYSICS_COLLISION_BODY);
        //         Globals.collisionEngine.registerPhysicsObject(rigidBody);
        //     }
        //     Globals.entityManager.setTargetable(equipPrimary, true);
        //     equipPrimary = null;
        // }
    // }

    public void unequipPoint(String pointId){
        Entity equipped = equipMap.remove(pointId);
        if(equipped != null){
            boolean targetHasWhitelist = ItemUtils.hasEquipList(equipped);
            if(targetHasWhitelist){
                //have to do fancy mesh removal nonsense
                //basically the reverse of below
                // List<EquipWhitelist> whitelist = ItemUtils.getEquipWhitelist(equipped);
                // for(EquipWhitelist whitelistItem : whitelist){
                //     if(whitelistItem.getCreatureId().equals(parentCreatureId)){
                //         //put in map
                //         equipMap.put(point.getEquipPointId(),toEquip);
                //         String modelName = whitelistItem.getModel();
                //         Globals.assetManager.addModelPathToQueue(modelName);
                //         Actor parentActor = EntityUtils.getActor(parent);
                //         //queue meshes from display model to parent actor
                //         ActorMeshMask meshMask = parentActor.getMeshMask();
                //         for(String toBlock : whitelistItem.getMeshMaskList()){
                //             meshMask.blockMesh(modelName, toBlock);
                //         }
                //         for(String toDraw : whitelistItem.getMeshList()){
                //             meshMask.queueMesh(modelName, toDraw);
                //         }
                //         //attach to parent bone
                //         AttachUtils.attachEntityToEntityAtBone(parent, toEquip, point.getBone());
                //         //make uncollidable
                //         if(toEquip.getDataKeys().contains(EntityDataStrings.PHYSICS_COLLISION_BODY) && toEquip.getDataKeys().contains(EntityDataStrings.PHYSICS_COLLIDABLE)){
                //             CollisionObject rigidBody = (CollisionObject)toEquip.getData(EntityDataStrings.PHYSICS_COLLISION_BODY);
                //             Globals.collisionEngine.deregisterPhysicsObject(rigidBody);
                //         }
                //         //hide toEquip actor
                //         EntityUtils.setDraw(toEquip, false);
                //         //make untargetable
                //         Globals.entityManager.setTargetable(toEquip, false);
                //         break;
                //     }
                // }
            } else {
                AttachUtils.detatchEntityFromEntityAtBone(parent, equipped);
                EntityUtils.cleanUpDrawableEntity(equipped);
            }
        }
    }
    
    
}