package electrosphere.entity.state.attack;


import electrosphere.server.datacell.utils.ServerBehaviorTreeUtils;
import electrosphere.net.parser.net.message.SynchronizationMessage;
import electrosphere.server.datacell.utils.DataCellSearchUtils;

import electrosphere.engine.Globals;
import electrosphere.entity.Entity;
import electrosphere.entity.EntityDataStrings;
import electrosphere.entity.EntityUtils;
import electrosphere.entity.btree.BehaviorTree;
import electrosphere.entity.btree.StateTransitionUtil;
import electrosphere.entity.btree.StateTransitionUtil.StateTransitionUtilItem;
import electrosphere.entity.state.attack.ClientAttackTree.AttackTreeDriftState;
import electrosphere.entity.state.attack.ClientAttackTree.AttackTreeState;
import electrosphere.entity.state.collidable.Impulse;
import electrosphere.entity.state.equip.ServerEquipState;
import electrosphere.entity.state.hitbox.HitboxCollectionState;
import electrosphere.entity.state.movement.groundmove.ServerGroundMovementTree;
import electrosphere.entity.state.rotator.ServerRotatorTree;
import electrosphere.entity.types.attach.AttachUtils;
import electrosphere.entity.types.collision.CollisionObjUtils;
import electrosphere.entity.types.creature.CreatureUtils;
import electrosphere.entity.types.item.ItemUtils;
import electrosphere.entity.types.projectile.ProjectileUtils;
import electrosphere.game.data.common.TreeDataState;
import electrosphere.game.data.creature.type.attack.AttackMove;
import electrosphere.game.data.creature.type.equip.EquipPoint;
import electrosphere.logger.LoggerInterface;
import electrosphere.net.parser.net.message.EntityMessage;
import electrosphere.net.synchronization.annotation.SyncedField;
import electrosphere.net.synchronization.annotation.SynchronizedBehaviorTree;
import electrosphere.net.synchronization.enums.BehaviorTreeIdEnums;
import electrosphere.net.synchronization.enums.FieldIdEnums;
import electrosphere.renderer.actor.Actor;
import electrosphere.server.datacell.Realm;
import electrosphere.util.math.MathUtils;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

import org.joml.Quaterniond;
import org.joml.Vector3d;
import org.joml.Vector3f;

@SynchronizedBehaviorTree(name = "serverAttackTree", isServer = true, correspondingTree="clientAttackTree")
/**
 * Server basic attack tree
 */
public class ServerAttackTree implements BehaviorTree {
    
    @SyncedField
    //the state of the attack tree
    AttackTreeState state;

    @SyncedField
    //the state of drifting caused by the attack animation
    AttackTreeDriftState driftState;
    
    Entity parent;
    
    CopyOnWriteArrayList<EntityMessage> networkMessageQueue = new CopyOnWriteArrayList<EntityMessage>();
    
    long lastUpdateTime = 0;
    
    float frameCurrent;
    
    String animationName = "SwingWeapon";
    
    int maxFrame = 60;

    List<AttackMove> currentMoveset = null;
    @SyncedField
    String currentMoveId = null; //the id of the current move -- used to synchronize the move to client
    AttackMove currentMove = null; //the actual current move object
    Entity currentWeapon = null;
    boolean currentMoveHasWindup;
    boolean currentMoveCanHold;
    boolean stillHold = true;
    boolean firesProjectile = false;
    String projectileToFire = null;
    String attackingPoint = null;

    //The state transition util
    StateTransitionUtil stateTransitionUtil;
    
    private ServerAttackTree(Entity e, Object ... params){
        state = AttackTreeState.IDLE;
        driftState = AttackTreeDriftState.NO_DRIFT;
        parent = e;
        this.stateTransitionUtil = StateTransitionUtil.create(parent, true, new StateTransitionUtilItem[]{
            StateTransitionUtilItem.create(
                AttackTreeState.WINDUP,
                () -> {
                    TreeDataState state = currentMove.getWindupState();
                    if(state == null){
                        return null;
                    } else {
                        return state.getAnimation();
                    }
                },
                () -> {
                    TreeDataState state = currentMove.getWindupState();
                    if(state == null){
                        return null;
                    } else {
                        return state.getAudioData();
                    }
                },
                () -> {
                    if(currentMoveCanHold && stillHold){
                        setState(AttackTreeState.HOLD);
                    } else {
                        setState(AttackTreeState.ATTACK);
                    }
                    this.stateTransitionUtil.interrupt(AttackTreeState.WINDUP);
                }
            ),
            StateTransitionUtilItem.create(
                AttackTreeState.HOLD,
                () -> {
                    TreeDataState state = currentMove.getHoldState();
                    if(state == null){
                        return null;
                    } else {
                        return state.getAnimation();
                    }
                },
                () -> {
                    TreeDataState state = currentMove.getHoldState();
                    if(state == null){
                        return null;
                    } else {
                        return state.getAudioData();
                    }
                },
                null
            ),
            StateTransitionUtilItem.create(
                AttackTreeState.ATTACK,
                () -> {
                    TreeDataState state = currentMove.getAttackState();
                    if(state == null){
                        return null;
                    } else {
                        return state.getAnimation();
                    }
                },
                null,
                () -> {
                    this.setState(AttackTreeState.COOLDOWN);
                    this.stateTransitionUtil.interrupt(AttackTreeState.ATTACK);
                }
            ),
            StateTransitionUtilItem.create(
                AttackTreeState.COOLDOWN,
                () -> {
                    TreeDataState state = currentMove.getCooldownState();
                    if(state == null){
                        return null;
                    } else {
                        return state.getAnimation();
                    }
                },
                null,
                null
            ),
        });
    }
    
    /**
     * <p> Automatically generated </p>
     * <p>
     * Gets state.
     * </p>
     */
    public AttackTreeState getState(){
        return state;
    }
    
    public void start(){
        currentMoveCanHold = false;
        currentMoveHasWindup = false;
        stillHold = true;
        firesProjectile = false;
        projectileToFire = null;
        currentWeapon = null;
        attackingPoint = null;
        //figure out attack type we should be doing
        String attackType = getAttackType();
        //if we can attack, setup doing so
        if(canAttack(attackType)){
            setAttackMoveTypeActive(attackType);
            currentMoveset = getMoveset(attackType);
            if(currentMoveset != null){
                if(currentMove == null){
                    currentMove = currentMoveset.get(0);
                } else {
                    currentMove = getNextMove(currentMoveset,currentMove.getNextMoveId());
                }
                if(currentMove != null){
                    firesProjectile = currentMove.getFiresProjectile();
                    if(firesProjectile){
                        projectileToFire = ItemUtils.getWeaponDataRaw(currentWeapon).getProjectileModel();
                    }

                    //set initial stuff (this alerts the client as well)
                    setCurrentMoveId(currentMove.getAttackMoveId());

                    //start tree
                    if(currentMove.getWindupState() != null){
                        setState(AttackTreeState.WINDUP);
                    } else if(currentMove.getAttackState() != null){
                        setState(AttackTreeState.ATTACK);
                    } else {
                        LoggerInterface.loggerEngine.ERROR(new IllegalStateException("Trying to start attacking tree, but current move does not have windup or attack states defined!"));
                    }
                    //intuit can hold from presence of windup anim
                    currentMoveCanHold = currentMove.getHoldState() != null;
                    //stop movement tree
                    if(parent.containsKey(EntityDataStrings.SERVER_MOVEMENT_BT)){
                        BehaviorTree movementTree = CreatureUtils.serverGetEntityMovementTree(parent);
                        if(movementTree instanceof ServerGroundMovementTree){
                            ((ServerGroundMovementTree)movementTree).interrupt();
                        }
                    }
                    Vector3d movementVector = CreatureUtils.getFacingVector(parent);
                    EntityUtils.getRotation(parent).rotationTo(MathUtils.getOriginVector(), new Vector3d(movementVector.x,movementVector.y,movementVector.z));
                    frameCurrent = 0;
                } else {
                    setState(AttackTreeState.IDLE);
                }
            }
        }
    }

    public void release(){
        stillHold = false;
    }
    
    /**
     * Interrupts the tree
     */
    public void interrupt(){
        setState(AttackTreeState.IDLE);
        //activate hitboxes
        List<Entity> attachedEntities = AttachUtils.getChildrenList(parent);
        for(Entity currentAttached : attachedEntities){
            if(HitboxCollectionState.hasHitboxState(currentAttached)){
                HitboxCollectionState currentState = HitboxCollectionState.getHitboxState(currentAttached);
                currentState.setActive(false);
            }
        }
    }
    
    @Override
    public void simulate(float deltaTime){
        frameCurrent = frameCurrent + (float)Globals.timekeeper.getDeltaFrames();
        float velocity = CreatureUtils.getVelocity(parent);
        Vector3d position = EntityUtils.getPosition(parent);
        Vector3d movementVector = CreatureUtils.getFacingVector(parent);
        
        //parse attached network messages
        for(EntityMessage message : networkMessageQueue){
            networkMessageQueue.remove(message);
            switch(message.getMessageSubtype()){
                case ATTACKUPDATE:
                    EntityUtils.getPosition(parent).set(message.getpositionX(),message.getpositionY(),message.getpositionZ());
                    break;
                case STARTATTACK: {
                    start();
                } break;
                default:
                //silently ignore
                break;
            }
        }

        //handle the drifting if we're supposed to currently
        switch(driftState){
            case DRIFT:
            if(currentMove != null){
                //calculate the vector of movement
                CollisionObjUtils.getCollidable(parent).addImpulse(new Impulse(new Vector3d(movementVector), new Vector3d(0,0,0), new Vector3d(0,0,0), currentMove.getDriftGoal() * Globals.timekeeper.getSimFrameTime(), "movement"));
                if(frameCurrent > currentMove.getDriftFrameEnd()){
                    setDriftState(AttackTreeDriftState.NO_DRIFT);
                }
            }
            break;
            case NO_DRIFT:
            if(currentMove != null){
                if(frameCurrent > currentMove.getDriftFrameStart() && frameCurrent < currentMove.getDriftFrameEnd()){
                    setDriftState(AttackTreeDriftState.DRIFT);
                }
            }
            break;
        }

        // if(state != AttackTreeState.IDLE){
        //     System.out.println(frameCurrent);
        // }
        
        //state machine
        switch(state){
            case WINDUP: {
                if(parent.containsKey(EntityDataStrings.SERVER_ROTATOR_TREE)){
                    ServerRotatorTree.getServerRotatorTree(parent).setActive(true);
                }
                this.stateTransitionUtil.simulate(AttackTreeState.WINDUP);
                Globals.server.broadcastMessage(
                    EntityMessage.constructattackUpdateMessage(
                        parent.getId(),
                        System.currentTimeMillis(),
                        (float)position.x,
                        (float)position.y,
                        (float)position.z,
                        movementVector.x,
                        movementVector.y,
                        movementVector.z,
                        velocity,
                        0
                    )
                );
            } break;
            case HOLD: {
                this.stateTransitionUtil.simulate(AttackTreeState.HOLD);
                if(!stillHold){
                    setState(AttackTreeState.ATTACK);
                    this.stateTransitionUtil.interrupt(AttackTreeState.HOLD);
                }
            } break;
            case ATTACK: {
                this.stateTransitionUtil.simulate(AttackTreeState.ATTACK);
                //activate hitboxes
                List<Entity> attachedEntities = AttachUtils.getChildrenList(parent);
                for(Entity currentAttached : attachedEntities){
                    if(HitboxCollectionState.hasHitboxState(currentAttached)){
                        HitboxCollectionState currentState = HitboxCollectionState.getHitboxState(currentAttached);
                        currentState.setActive(true);
                    }
                }
                if(firesProjectile && projectileToFire != null){
                    //spawn projectile
                    //TODO: solve spawnPosition, initialVector
                    Vector3d spawnPosition = new Vector3d(0,0,0);
                    Quaterniond arrowRotation = new Quaterniond();
                    String targetBone = null;
                    ServerEquipState equipState = ServerEquipState.getEquipState(parent);
                    EquipPoint weaponPoint = null;
                    if((weaponPoint = equipState.getEquipPoint(attackingPoint)) != null){
                        targetBone = weaponPoint.getBone();
                    }
                    if(targetBone != null){
                        Actor parentActor = EntityUtils.getActor(parent);
                        //transform bone space
                        spawnPosition = new Vector3d(parentActor.getBonePosition(targetBone));
                        spawnPosition = spawnPosition.mul(((Vector3f)EntityUtils.getScale(parent)));
                        Quaterniond rotation = EntityUtils.getRotation(parent);
                        spawnPosition = spawnPosition.rotate(new Quaterniond(rotation.x,rotation.y,rotation.z,rotation.w));
                        //transform worldspace
                        spawnPosition.add(new Vector3d(EntityUtils.getPosition(parent)));
                        //set
                        // EntityUtils.getPosition(currentEntity).set(position);
                        //set rotation
    //                    Quaternionf rotation = parentActor.getBoneRotation(targetBone);
    //                    EntityUtils.getRotation(currentEntity).set(rotation).normalize();
                        // Vector3d facingAngle = CreatureUtils.getFacingVector(parent);
                        arrowRotation = parentActor.getBoneRotation(targetBone);
                        // EntityUtils.getRotation(currentEntity).rotationTo(MathUtils.ORIGIN_VECTORF, new Vector3f((float)facingAngle.x,(float)facingAngle.y,(float)facingAngle.z)).mul(parentActor.getBoneRotation(targetBone)).normalize();
                    }
                    Vector3f initialVector = new Vector3f((float)movementVector.x,(float)movementVector.y,(float)movementVector.z).normalize();
                    Realm parentRealm = Globals.realmManager.getEntityRealm(parent);
                    ProjectileUtils.serverSpawnBasicProjectile(parentRealm, projectileToFire, spawnPosition, arrowRotation, 750, initialVector, 0.03f);
                    projectileToFire = null;
                }
                Globals.server.broadcastMessage(
                        EntityMessage.constructattackUpdateMessage(
                                parent.getId(),
                                System.currentTimeMillis(),
                                (float)position.x,
                                (float)position.y,
                                (float)position.z,
                                movementVector.x,
                                movementVector.y,
                                movementVector.z,
                                velocity,
                                1
                        )
                );
            } break;
            case COOLDOWN: {
                this.stateTransitionUtil.simulate(AttackTreeState.COOLDOWN);
                //deactive hitboxes
                List<Entity> attachedEntities = AttachUtils.getChildrenList(parent);
                for(Entity currentAttached : attachedEntities){
                    if(HitboxCollectionState.hasHitboxState(currentAttached)){
                        HitboxCollectionState currentState = HitboxCollectionState.getHitboxState(currentAttached);
                        currentState.setActive(false);
                    }
                }
                if(frameCurrent > currentMove.getWindupFrames() + currentMove.getAttackFrames() + currentMove.getCooldownFrames()){
                    setState(AttackTreeState.IDLE);
                    this.stateTransitionUtil.interrupt(AttackTreeState.COOLDOWN);
                    frameCurrent = 0;
                    if(parent.containsKey(EntityDataStrings.SERVER_ROTATOR_TREE)){
                        ServerRotatorTree.getServerRotatorTree(parent).setActive(false);
                    }
                }
                Globals.server.broadcastMessage(
                        EntityMessage.constructattackUpdateMessage(
                                parent.getId(),
                                System.currentTimeMillis(),
                                (float)position.x,
                                (float)position.y,
                                (float)position.z,
                                movementVector.x,
                                movementVector.y,
                                movementVector.z,
                                velocity,
                                2
                        )
                );
            } break;
            case IDLE: {
                currentMove = null;
                currentMoveset = null;
            } break;
        }
    }

    public void addNetworkMessage(EntityMessage networkMessage) {
        networkMessageQueue.add(networkMessage);
    }

    String getAttackType(){
        String rVal = null;
        if(ServerEquipState.hasEquipState(parent)){
            ServerEquipState equipState = ServerEquipState.getEquipState(parent);
            for(String point : equipState.equippedPoints()){
                Entity item = equipState.getEquippedItemAtPoint(point);
                if(ItemUtils.isWeapon(item)){
                    attackingPoint = point;
                    currentWeapon = item;
                    switch(ItemUtils.getWeaponClass(item)){
                        case "sword1h":
                        rVal = EntityDataStrings.ATTACK_MOVE_TYPE_MELEE_SWING_ONE_HAND;
                        break;
                        case "sword2h":
                        rVal = EntityDataStrings.ATTACK_MOVE_TYPE_MELEE_SWING_TWO_HAND;
                        break;
                        case "bow2h":
                        rVal = EntityDataStrings.ATTACK_MOVE_TYPE_BOW_TWO_HAND;
                        break;
                    }
                }
            }
        }
        return rVal;
    }
    
    /**
     * Checks whether the entity can attack or not
     * @param attackType The type of attack to perform
     * @return true if it can attack, false otherwise
     */
    boolean canAttack(String attackType){
        boolean rVal = true;
        if(attackType == null){
            return false;
        } else if(state != AttackTreeState.IDLE){
            //checks if we have a next move and if we're in the specified range of frames when we're allowed to chain into it
            if(
                currentMove.getNextMoveId() != null && 
                !currentMove.getNextMoveId().equals("") &&
                frameCurrent >= currentMove.getMoveChainWindowStart() && frameCurrent <= currentMove.getMoveChainWindowEnd()
            ){
                rVal = true;
            }
        } else {
            if(ServerEquipState.hasEquipState(parent)){
                // ServerEquipState equipState = ServerEquipState.getEquipState(parent);
                // if(equipState.hasEquipPrimary()){
                //     switch(attackType){
                //         case EntityDataStrings.ATTACK_MOVE_TYPE_MELEE_SWING_ONE_HAND:
                //             break;
                //         default:
                //             rVal = false;
                //             break;
                //     }
                // } else {
                //     switch(attackType){
                //         case EntityDataStrings.ATTACK_MOVE_TYPE_MELEE_SWING_ONE_HAND:
                //             rVal = false;
                //             break;
                //         default:
                //             rVal = false;
                //             break;
                //     }
                // }
            }
        }
        return rVal;
    }

    AttackMove getNextMove(List<AttackMove> moveset, String nextMoveId){
        AttackMove rVal = null;
        for(AttackMove move : moveset){
            if(move.getAttackMoveId().equals(nextMoveId)){
                rVal = move;
                break;
            }
        }
        return rVal;
    }

    /**
     * Sets the current attack type of the entity
     * @param attackType the current attack type
     */
    public void setAttackMoveTypeActive(String attackType){
        parent.putData(EntityDataStrings.ATTACK_MOVE_TYPE_ACTIVE, attackType);
    }

    /**
     * Checks whether the attack tree is active or not
     * @return true if active, false otherwise
     */
    public boolean isAttacking(){
        return this.state != AttackTreeState.IDLE;
    }

    /**
     * Gets the current moveset
     * @param attackType the attack type
     * @return The moveset if it exists
     */
    public List<AttackMove> getMoveset(String attackType){
        return (List<AttackMove>)parent.getData(attackType);
    }
    
    /**
     * <p> Automatically generated </p>
     * <p>
     * Sets state and handles the synchronization logic for it.
     * </p>
     * @param state The value to set state to.
     */
    public void setState(AttackTreeState state){
        this.state = state;
        int value = ClientAttackTree.getAttackTreeStateEnumAsShort(state);
        DataCellSearchUtils.getEntityDataCell(parent).broadcastNetworkMessage(SynchronizationMessage.constructUpdateClientStateMessage(parent.getId(), BehaviorTreeIdEnums.BTREE_SERVERATTACKTREE_ID, FieldIdEnums.TREE_SERVERATTACKTREE_SYNCEDFIELD_STATE_ID, value));
    }
    /**
     * <p> Automatically generated </p>
     * <p>
     * Gets driftState.
     * </p>
     */
    public AttackTreeDriftState getDriftState(){
        return driftState;
    }
    /**
     * <p> Automatically generated </p>
     * <p>
     * Sets driftState and handles the synchronization logic for it.
     * </p>
     * @param driftState The value to set driftState to.
     */
    public void setDriftState(AttackTreeDriftState driftState){
        this.driftState = driftState;
        int value = ClientAttackTree.getAttackTreeDriftStateEnumAsShort(driftState);
        DataCellSearchUtils.getEntityDataCell(parent).broadcastNetworkMessage(SynchronizationMessage.constructUpdateClientStateMessage(parent.getId(), BehaviorTreeIdEnums.BTREE_SERVERATTACKTREE_ID, FieldIdEnums.TREE_SERVERATTACKTREE_SYNCEDFIELD_DRIFTSTATE_ID, value));
    }
    /**
     * <p> (initially) Automatically generated </p>
     * <p>
     * Attaches this tree to the entity.
     * </p>
     * @param entity The entity to attach to
     * @param tree The behavior tree to attach
     * @param params Optional parameters that will be provided to the constructor
     */
    public static ServerAttackTree attachTree(Entity parent, Object ... params){
        ServerAttackTree rVal = new ServerAttackTree(parent,params);
        //!!WARNING!! from here below should not be touched
        //This was generated automatically to properly alert various systems that the btree exists and should be tracked
        ServerBehaviorTreeUtils.attachBTreeToEntity(parent, rVal);
        parent.putData(EntityDataStrings.TREE_SERVERATTACKTREE, rVal);
        Globals.entityValueTrackingService.attachTreeToEntity(parent, BehaviorTreeIdEnums.BTREE_SERVERATTACKTREE_ID);
        return rVal;
    }
    /**
     * <p> Automatically generated </p>
     * <p>
     * Detatches this tree from the entity.
     * </p>
     * @param entity The entity to detach to
     * @param tree The behavior tree to detach
     */
    public static void detachTree(Entity entity, BehaviorTree tree){
        Globals.entityValueTrackingService.detatchTreeFromEntity(entity, BehaviorTreeIdEnums.BTREE_SERVERATTACKTREE_ID);
    }
    /**
     * <p>
     * Gets the ServerAttackTree of the entity
     * </p>
     * @param entity the entity
     * @return The ServerAttackTree
     */
    public static ServerAttackTree getServerAttackTree(Entity entity){
        return (ServerAttackTree)entity.getData(EntityDataStrings.TREE_SERVERATTACKTREE);
    }
    /**
     * <p> Automatically generated </p>
     * <p>
     * Gets currentMoveId.
     * </p>
     */
    public String getCurrentMoveId(){
        return currentMoveId;
    }
    /**
     * <p> Automatically generated </p>
     * <p>
     * Sets currentMoveId and handles the synchronization logic for it.
     * </p>
     * @param currentMoveId The value to set currentMoveId to.
     */
    public void setCurrentMoveId(String currentMoveId){
        this.currentMoveId = currentMoveId;
        DataCellSearchUtils.getEntityDataCell(parent).broadcastNetworkMessage(SynchronizationMessage.constructUpdateClientStringStateMessage(parent.getId(), BehaviorTreeIdEnums.BTREE_SERVERATTACKTREE_ID, FieldIdEnums.TREE_SERVERATTACKTREE_SYNCEDFIELD_CURRENTMOVEID_ID, currentMoveId));
    }
}