FSM

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using Pathfinding;
using AI.States;

public class StateMachine{
    public List<AIState> Tasks;
    public CitizenAI cScript;

    public StateMachine(CitizenAI owner){
        this.Tasks = new List<AIState>(15);
        cScript = owner;
    }

    public void DoCurrent(){
        if(Tasks.Count > 0){
            Tasks[0].StateUpdate();
        }
        else{
            AssessNeeds ();
        }
    }

    public void AddAction(AIState _task){
        if(Tasks.Count == 0){
            Tasks.Add(_task);
            Tasks[0].SetUp();
        }
        else{
            Tasks.Add(_task);
        }
    }

    public void AddActionPriority(AIState _task){
        Tasks.Insert(0, _task);
    }

    public void DeQueue(){
        if(Tasks.Count > 0){
            Tasks.RemoveAt(0);
            if(Tasks.Count > 0){
                Tasks[0].SetUp();
            }
            else{
                AssessNeeds();
            }
        }
        else{
            AssessNeeds();
        }
    }

    public void ClearTasks(){
        if(Tasks.Count > 0){
            Tasks[0].Exit();
        }
        Tasks.Clear();
    }


    public void AssessNeeds(){
        if(cScript.ShouldLookForHome()){
            LookForSuitableHome();
        }
        else if(cScript.ShouldWork()){
            RegisterForWorkPlace();
        }
        else if(cScript.CanWorkOnField()){
            RegisterForFieldWork();
        }
        else if(cScript.ShouldBuild()){
            RegisterForConstructionSite();
        }
        else if(cScript.CanClearField()){
            RegisterForClearingField();
        }
        else if(cScript.roadNeedsClearing()){
            RegisterForClearingRoad();
        }
        else if(cScript.areaNeedsClearing()){
            RegisterForHarvestingArea();
        }
        else{
            MoveToRandomPoint();
        }
    }

    #region State Bundles

    public void LookForSuitableHome(){
        AddAction(new LookForHome(cScript));
    }

    /// <summary>
    /// Sends the agent to cut a tree.
    /// </summary>
    /// <param name="treePos">Tree position.</param>
    /// <param name="autoDeliver">If set to <c>true</c> brings the logs back to the nearest storage</param>
    public void CutTreeAtPosition(Vector3 treePos, bool autoDeliver){
        WalkToLocation(treePos);
        AddAction(new PlayAnim("Cut_Tree", cScript));
        AddAction(new CutTreeAtPosition(treePos, cScript));
        AddAction(new PlayAnimAndWait("BendDown", cScript));
        AddAction(new TakeItem(AllRessources.WOOD, 20, cScript));
        AddAction(new WaitTimer(2f, cScript));
        AddAction(new PlayAnimAndWait("Get_up", cScript));

        if(autoDeliver){
            int[] arr = new int[] {AllRessources.WOOD};
            DropItemsAtNearestStorage(arr);
        }
    }

    public void PlantTreeAtPosition(Vector3 treePos, TreePlanter tp){
        WalkToLocation(treePos);
        AddAction(new PlayAnimAndWait("BendDown", cScript));
        AddAction(new WaitTimer(2f, cScript));
        AddAction(new PlantTree(treePos, tp, cScript));
        AddAction(new PlayAnimAndWait("Get_up", cScript));
    }

    /// <summary>
    /// Sends the agent to pick up a rock
    /// </summary>
    /// <param name="rockPos">Rock position.</param>
    /// <param name="autoDeliver">If set to <c>true</c> brings the stone back to the nearest storage</param>
    public void PickUpRockAtPosition(Vector3 rockPos, bool autoDeliver){
        WalkToLocation(rockPos);
        AddAction(new PlayAnim("Cut_Tree", cScript));
        AddAction(new CutTreeAtPosition(rockPos, cScript));
        AddAction(new PlayAnimAndWait("BendDown", cScript));
        AddAction(new TakeItem(AllRessources.STONE, 8, cScript));
        AddAction(new WaitTimer(2f, cScript));
        AddAction(new PlayAnimAndWait("Get_up", cScript));

        if(autoDeliver){
            int[] arr = new int[] {AllRessources.STONE};
            DropItemsAtNearestStorage(arr);
        }
    }

    public void PickUpItemsFromWorkAndBringThemToStorage(){
        int[] itemToPickUp = cScript.workScript.GetTakeResources();
        AddAction(new SetCurrentString(cScript, "Going to get items from work."));
        WalkToLocation(cScript.workScript.workWayPoint.position);
        AddAction(new PlayAnimAndWait("BendDown", cScript));
        AddAction(new TakeItemsFromInventoryLocation(itemToPickUp, cScript.workScript, cScript));
        AddAction(new PlayAnimAndWait("Get_up", cScript));
        AddAction(new SetCurrentString(cScript, "Bringing items to storage."));
        AddAction(new PerformAction(cScript, BringItemsFromWorkToNearestStorage));
    }

    public void PickUpItemsAtNearestStorage(int[] itemsToPickUp){
        Storeage store = cScript.getNearestStoreage(cScript._myTransform.position).parent.GetComponent<Storeage>();
        AddAction(new PlayAnim("Walk_001", cScript));
        AddAction(new MoveToLocation(store.storeTransform.position, cScript));
        AddAction(new PlayAnimAndWait("BendDown", cScript));
        AddAction(new TakeItemsFromInventoryLocation(itemsToPickUp, store, cScript));
        AddAction(new WaitTimer(2f, cScript));
        AddAction(new PlayAnimAndWait("Get_up", cScript));
    }

    public void DropItemsAtNearestStorage(int[] itemsToDrop){
        Storeage store = cScript.getNearestStoreage(cScript._myTransform.position).parent.GetComponent<Storeage>();
        AddAction(new PlayAnim("Walk_001", cScript));
        AddAction(new MoveToLocation(store.storeTransform.position, cScript));
        AddAction(new PlayAnimAndWait("BendDown", cScript));
        AddAction(new DropItemAtInventoryLocation(itemsToDrop, store, cScript));
        AddAction(new WaitTimer(2f, cScript));
        AddAction(new PlayAnimAndWait("Get_up", cScript));
    }

    public void DropItemsAtConstructionSite(){
        Vector3 constructionLocation = cScript.buildScript.transform.position;
        WalkToLocation(constructionLocation);
        int[] itemsToDrop = new int[] {AllRessources.STONE, AllRessources.WOOD, AllRessources.TOOLS};
        AddAction(new PlayAnimAndWait("BendDown", cScript));
        AddAction(new DropItemAtInventoryLocation(itemsToDrop, cScript.buildScript, cScript));
        AddAction(new WaitTimer(2f, cScript));
        AddAction(new PlayAnimAndWait("Get_up", cScript));
    }

    public void DropItemsAtWorkPlace(){
        Vector3 workLocation = cScript.workScript.workWayPoint.position;
        WalkToLocation(workLocation);
        int[] resourcesToDrop = cScript.workScript.ressourcesRequired;
        AddAction(new PlayAnimAndWait("BendDown", cScript));
        AddAction(new DropItemAtInventoryLocation(resourcesToDrop, cScript.workScript, cScript));
        AddAction(new WaitTimer(2f, cScript));
        AddAction(new PlayAnimAndWait("Get_up", cScript));
    }

    public void BringItemsFromWorkToNearestStorage(){
        int[] resourcesToDrop = cScript.workScript.GetDropResources();
        DropItemsAtNearestStorage(resourcesToDrop);
    }

    public void WalkToLocation(Vector3 worldPos){
        AddAction(new PlayAnim("Walk_001", cScript));
        AddAction(new MoveToLocation(worldPos, cScript));
    }

    public void RegisterForWorkPlace(){
        WorkScript ws = cScript.workScript;
        if(cScript.WorkNeedsItems()){
            int[] itemNeeded = cScript.workScript.GetMissingItemsForOperaions();
            PickUpItemsAtNearestStorage(itemNeeded);
            AddAction(new SetCurrentString(cScript, "Bringing items to work place."));
            AddAction(new PerformAction(cScript, DropItemsAtWorkPlace));
        }
        else if(cScript.isRunner & cScript.workScript.storageFull){
            PickUpItemsFromWorkAndBringThemToStorage();
        }
        else{
            cScript.workScript.WorkTasks.SetupNextTasks(this);
        }
    }

    /// <summary>
    /// Perform any work related with construction location.
    /// </summary>
    public void RegisterForConstructionSite(){
        if(cScript.buildScript == null){
            Building bs = SaveManager.Instance.constructionNeeded[0];
            if(bs.volounteerForWork(cScript.gameObject)){
                cScript.buildScript = bs;
            }
            else{
                return;
            }
        }
        if(cScript.buildScript.treesToCut.Count > 0){
            Vector3 tree = cScript.buildScript.treesToCut[0];
            cScript.buildScript.treesToCut.RemoveAt(0);
            CutTreeAtPosition(tree, true);
            return;
        }
        if(cScript.buildScript.rocks.Count > 0){
            Vector3 rock = cScript.buildScript.rocks[0].transform.position;
            cScript.buildScript.rocks.RemoveAt(0);
            PickUpRockAtPosition(rock, true);
            return;
        }

        if(!cScript.buildScript.checkRessourcesCommitted()){
            int[] resourcesNeeded = cScript.buildScript.getMissingResources(cScript);
            PickUpItemsAtNearestStorage(resourcesNeeded);
            AddAction(new PerformAction(cScript, DropItemsAtConstructionSite));
        }
        else{
            if(cScript.buildScript.allRessourcesGathered && cScript.buildScript.builder == null){
                cScript.buildScript.commitForWork(cScript.gameObject);
                AddAction(new PlayAnimAndWait("BendDown", cScript));
                AddAction(new PlayAnim("Build", cScript));
                AddAction(new WaitTimer(cScript.buildScript.timeToBuild, cScript));
                AddAction(new PlayAnimAndWait("Get_up", cScript));
            }
            else if(!cScript.buildScript.allRessourcesGathered){
                cScript.buildScript = null;
                ClearTasks ();
                DeQueue ();
            }
        }
    }

    public void RegisterForClearingField(){
        FieldScript fs;
        for(int i = 0 ; i < SaveManager.Instance.FieldsNeedingWork.Count ; i++){
            fs = SaveManager.Instance.FieldsNeedingWork[i];
            if(fs.treesToCut.Count > 0){
                Vector3 tree = fs.treesToCut[0];
                fs.treesToCut.RemoveAt(0);
                CutTreeAtPosition(tree, true);
                return;
            }
            else if(fs.rocks.Count > 0){
                Vector3 rock = fs.rocks[0].transform.position;
                fs.rocks.RemoveAt(0);
                PickUpRockAtPosition(rock, true);
                return;
            }
        }
    }

    public void RegisterForFieldWork(){
        if(cScript.fieldScript == null){
            FieldScript fs = SaveManager.Instance.FieldsNeedingWork[0];
            if(fs.applyForWork(cScript.gameObject)){
                cScript.fieldScript = fs;
            }
            else{
                return;
            }
        }

        cScript.isWorking = cScript.fieldScript.commitForWork();
        if(cScript.isWorking){
            if(cScript.fieldScript.state == FieldScript.State.Grown){
                HarvestFieldCrops();
            }
            else{
                TendToFieldCrops();
            }
        }

    }

    public void TendToFieldCrops(){
        Transform[] cropList = cScript.fieldScript.getWorkableCrops(cScript.gameObject);
        WalkToLocation(cropList[0].position);
        AddAction(new PlayAnimAndWait("BendDown", cScript));
        AddAction(new TendToCrop(cropList, 0, cScript));
        AddAction(new PlayAnimAndWait("Get_up", cScript));
    }

    public void HarvestFieldCrops(){
        CropScript[] cropList = cScript.fieldScript.GetHarvestableCrops(cScript.gameObject);
        WalkToLocation(cropList[0].transform.position);
        AddAction(new PlayAnimAndWait("BendDown", cScript));
        AddAction(new HarvestCrops(cropList, 0, cScript));
        AddAction(new PlayAnimAndWait("Get_up", cScript));

    }

    public void RegisterForClearingRoad(){
        RoadScript rs = UpdateNearbyRoads.Instance.RoadsThatNeedClearing[0];
        if(rs.treesToCut.Count > 0){
            Vector3 tree = rs.treesToCut[0];
            rs.treesToCut.RemoveAt(0);
            rs.CheckIfClearingIsDone();
            CutTreeAtPosition(tree, true);
            return;
        }
        if(rs.rocks.Count > 0){
            Vector3 rock = rs.rocks[0].transform.position;
            rs.rocks.RemoveAt(0);
            PickUpRockAtPosition(rock, true);
            rs.CheckIfClearingIsDone();
            return;
        }
    }

    public void RegisterForHarvestingArea(){
        HarvestArea rs = SaveManager.Instance.harvestingAreas[0];
        if(rs.treesToCut.Count > 0){
            Vector3 tree = rs.getNextTree();
            CutTreeAtPosition(tree, true);
            return;
        }
        if(rs.rocks.Count > 0){
            Vector3 rock = rs.getNextRock().transform.position;
            PickUpRockAtPosition(rock, true);
            return;
        }
    }

    public void MoveToRandomPoint(){
        Vector3 rand = getRandomPosition(cScript._myTransform);
        if(rand != Vector3.zero){
            AddAction(new PlayAnim("Walk_001", cScript));
            AddAction(new MoveToLocation(rand, cScript));
            AddAction(new PlayAnimAndWait("BendDown", cScript));
            AddAction(new WaitTimer(5f, cScript));
            AddAction(new PlayAnimAndWait("Get_up", cScript));
        }
    }

    #endregion
    public void Test(){
        Debug.Log("This has been called");
    }

    public void DisableMesh(){
        cScript.citizenMesh.enabled = false;
    }

    public void EnableMesh(){
        cScript.citizenMesh.enabled = true;
    }

    public void CommitForWork(){
        cScript.isWorking = cScript.workScript.commitForWork();
    }

    public void LeaveWork(){
        cScript.workScript.leaveWork();
        cScript.workScript.WorkTasks.OnExit();
        cScript.isWorking = false;
    }

    public Vector3 getRandomPosition(Transform origin){
        Vector3 pos = new Vector3(origin.position.x + Random.Range (-15, 15),
                                  origin.position.y + 50.0f, origin.position.z + Random.Range (-15, 15));
        //Ray ray;
        RaycastHit hit;
        if(Physics.Raycast (pos, Vector3.down, out hit, 100)){
            Node node = AstarPath.active.GetNearest (hit.point).node;
            if(node.walkable){
                return  new Vector3(node.position.x, node.position.y, node.position.z) * Int3.PrecisionFactor;
            }
        }
        return Vector3.zero;
    }

}