using System.Collections;
using System.Collections.Generic;
using UnityEngine;


public class PlayerController : MonoBehaviour
{
    public GameObject waypointPrefab;
    public GameObject IslaContainer;
    public GameObject Player;
    public GameObject RaycastManager;
    public Vector3 HeldHitPoint;


    public List<GameObject> waypoints;
    private List<GameObject> waypointsToRemove;


    private float walkSpeed = 1.7f;
    private float runSpeed = 3.0f;

    public int[] Directions = { 0, 45, 90, 135, 180, 225, 270, 315, 359 };

    public int FinalDirectionPass;

    public int DirectionArrayPosition = 0;


    public Vector3 previousPlayerPosition;
    public bool IslaFacingMovingDirection;
    public int ArrayCount;
    public bool boolTurnElapsed;
    public bool StartTurnRoutine;

    public int KeepCountforQueue = 0;



    //public float direction;




    public Animator Playeranim;



    AudioSource audioData;



    void Start()
    {
        previousPlayerPosition = transform.position;
        Player.transform.position = DungeonGridManager.CalcGridSnappedPosition(this.transform.position);
        waypoints = new List<GameObject>();
        waypointsToRemove = new List<GameObject>();
        this.SnapPlayerToGrid();
        StartCoroutine(ReorientIslasDirectionWhileTurnPasses());


        IslaContainer.transform.rotation = Quaternion.AngleAxis(Directions[DirectionArrayPosition], new Vector3(0, 1, 0));



        //In for debug purposes, also a reminder that I'll be expanding this later as
        //I want it to check the type of tile based on the tile name next
        audioData = GetComponent<AudioSource>();
        audioData.Play(0);

        Playeranim = IslaContainer.GetComponentInChildren<Animator>();
        Playeranim.SetBool("Walking", false);




    }



    void SnapPlayerToGrid()
    {

        this.transform.position = DungeonGridManager.CalcGridSnappedPosition(this.transform.position);
    }


    void FixedUpdate()
    {



            IslaContainer.transform.rotation = Quaternion.AngleAxis(Directions[DirectionArrayPosition], new Vector3(0, 1, 0));








        if (this.waypoints.Count > 0 && boolTurnElapsed is true)
        {



            TurnIsla();

            Vector3 velocity = walkSpeed * Time.deltaTime * (waypoints[0].transform.position - this.transform.position).normalized;

            this.transform.position += velocity;


            // Thought this might cause slight jitter in movement near
            // waypoints, not seeing any such issue yet tho

            if (velocity.magnitude >= (waypoints[0].transform.position - this.transform.position).magnitude)
            {

                Debug.Log(DirectionArrayPosition);
                audioData.Play(0);




                waypointsToRemove.Add(waypoints[0]);
                TurnIsla();
                previousPlayerPosition = transform.position;

            }
        }

    }
    void LateUpdate()
    {



        if (waypoints.Count == 0)
        {
            Playeranim.SetBool("Walking", false);


        }

        _UpdateWaypoints();

    }



    //Method handles the management of triggering the ReorientIslasDirectionWhileTurnPasses() method. TurnIsla() goes compares last position saved based on 1). start of script
    // or 2). the death of the previous waypoints[0]. The method is called whenever there is movement, and I'm most likely repeating myself at times.
    // A way to improve this method, or outright removing it, would be having the dungeonSceneManager's gridcell have DirectionArrayPosition identites that will be read
    // by the TurnIsla and allow for ReorientIslasDirectionWhileTurnPasses() to reorient the player in motion. Establishes FinalDirection Pass in order to check
    // against the current DirectionArrayPosition which is then modified to match in ReorientIslasDirectionWhileTurnPasses()
    int TurnIsla()
    {
        if (waypoints.Count == 0)
        {
            this.SnapPlayerToGrid();
            return FinalDirectionPass;


        }



        //public int[] Directions = { 0, 45, 90, 135, 180, 225, 270, 315, 359 };
        //                            0   1   2   3    4    5    6    7


        //Up

        if (waypoints[0].transform.position.x < previousPlayerPosition.x)
        {
            if (waypoints[0].transform.position.z == previousPlayerPosition.z)
            {

                FinalDirectionPass = 0;
                StartCoroutine("ReorientIslasDirectionWhileTurnPasses");
                return FinalDirectionPass;
            }

            else if (waypoints[0].transform.position.z < previousPlayerPosition.z)
            {

                FinalDirectionPass = 7;
                StartCoroutine("ReorientIslasDirectionWhileTurnPasses");
                return FinalDirectionPass;
            }
            else if (waypoints[0].transform.position.z > previousPlayerPosition.z)
            {

                FinalDirectionPass = 1;
                StartCoroutine("ReorientIslasDirectionWhileTurnPasses");
                return FinalDirectionPass;
            }
            else if (FinalDirectionPass != DirectionArrayPosition)
            {
                StartCoroutine("ReorientIslasDirectionWhileTurnPasses");
                return FinalDirectionPass;
            }
        }

        //Down
        if (waypoints[0].transform.position.x > previousPlayerPosition.x)
        {
            if (waypoints[0].transform.position.z > previousPlayerPosition.z)
            {

                FinalDirectionPass = 3;
                StartCoroutine("ReorientIslasDirectionWhileTurnPasses");
                return FinalDirectionPass;
            }
            else if (waypoints[0].transform.position.z < previousPlayerPosition.z)
            {

                FinalDirectionPass = 5;
                StartCoroutine("ReorientIslasDirectionWhileTurnPasses");
                return FinalDirectionPass;
            }

            else if (waypoints[0].transform.position.z == previousPlayerPosition.z)
            {

                FinalDirectionPass = 4;
                StartCoroutine("ReorientIslasDirectionWhileTurnPasses");
                return FinalDirectionPass;
            }

            else if (FinalDirectionPass != DirectionArrayPosition)
            {

                StartCoroutine("ReorientIslasDirectionWhileTurnPasses");
                return FinalDirectionPass;
            }
            return FinalDirectionPass;
        }

        //left
        if (waypoints[0].transform.position.z > previousPlayerPosition.z)
        {
            if (FinalDirectionPass != DirectionArrayPosition)
            {

                StartCoroutine("ReorientIslasDirectionWhileTurnPasses");

            }
            FinalDirectionPass = 2;
            StartCoroutine("ReorientIslasDirectionWhileTurnPasses");
            return FinalDirectionPass;
        }

        //right
        if (waypoints[0].transform.position.z < previousPlayerPosition.z)
        {
            if (FinalDirectionPass != DirectionArrayPosition)
            {

                StartCoroutine("ReorientIslasDirectionWhileTurnPasses");
                return FinalDirectionPass;
            }

            FinalDirectionPass = 6;
            StartCoroutine("ReorientIslasDirectionWhileTurnPasses");
            return FinalDirectionPass;
        }
        return FinalDirectionPass;
    }


    //ReorientIslasDirectionWhileTurnPasses() handles the actual turn of the character. I want to design it to stop the movement, then turn her as it "passes a turn" and then
    // continue on through the movement in FixedUpdate(). ReorientIslasDirectionWhileTurnPasses() checks the FinalDirectionPass and DirectionArrayPosition. Originally I had it
    // try and increment the turn based on arbitrary moments of .5 seconds that represented an abstraction of a "turn" which would later be subbed in with evoking the
    // future turnManager class which will have a Turn() method.

    IEnumerator ReorientIslasDirectionWhileTurnPasses()
    {




        if ((FinalDirectionPass == DirectionArrayPosition))
        {
            boolTurnElapsed = true;
        }


        if (FinalDirectionPass > DirectionArrayPosition)
        {

            if (FinalDirectionPass > DirectionArrayPosition)
            {
                boolTurnElapsed = false;

                yield return DirectionArrayPosition = FinalDirectionPass;

                if ((FinalDirectionPass == DirectionArrayPosition))
                {
                    yield return FinalDirectionPass == DirectionArrayPosition;
                    boolTurnElapsed = true;


                }


            }
        }
        if (FinalDirectionPass < DirectionArrayPosition)
        {

            boolTurnElapsed = false;

            yield return DirectionArrayPosition = FinalDirectionPass;


            if ((FinalDirectionPass == DirectionArrayPosition))
            {
                yield return FinalDirectionPass == DirectionArrayPosition;
                boolTurnElapsed = true;
            }


        }

        if ((FinalDirectionPass == DirectionArrayPosition))
        {
            boolTurnElapsed = true;
            yield return FinalDirectionPass == DirectionArrayPosition;

        }

    }







    private void _UpdateWaypoints()
    {

        if (waypointsToRemove.Count > 0)
        {
            foreach (var pathIndicator in waypointsToRemove)
            {
                waypoints.Remove(pathIndicator);

                Destroy(pathIndicator);

            }

            waypointsToRemove.Clear();
        }

        if (Input.GetMouseButtonDown(0))
        {

            RaycastHit hit;




            Playeranim.SetBool("Walking", true);

            if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hit, 100))
            {
                Debug.DrawLine(Camera.main.transform.position, hit.point, Color.red, 5f);


                HeldHitPoint = hit.point;


                Debug.Log(HeldHitPoint);

                foreach (var oldCell in waypoints)
                {

                    Destroy(oldCell);

                }
                waypoints.Clear();

                var snappedPosition = DungeonGridManager.CalcGridSnappedPosition(HeldHitPoint);
                Debug.Log(snappedPosition); << Speaks back fine, gives me the correct output
                var dungeonSceneManager = this.GetDungeonSceneManager();

                var pathCells = dungeonSceneManager.GetPath(this.transform.position, snappedPosition);
                foreach (var pathCell in pathCells) << no pathcells get generated when the camera is 0, 90, 180, 270 or 360.
                {
                    GameObject waypoint = Instantiate(waypointPrefab, pathCell.Position, Quaternion.identity);

                    waypoint.transform.SetParent(this.transform.parent);
                    waypoints.Add(waypoint);
                    TurnIsla();
                }
            }
        }

    }



    private DungeonSceneManager GetDungeonSceneManager()
        {
            return GameObject.FindGameObjectWithTag("DungeonSceneManager").GetComponent<DungeonSceneManager>();
        }
    }