using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Tilemaps;
using UnityEngine.UI;
using System.Linq;
using System;

public class GameManager : MonoBehaviour
{
    public float levelStartDelay = 1f;                      //Time to wait before starting level, in seconds.
    public float turnDelay = 0.1f;                          //Delay between each Player turn.
    public int playerHealth = 6;                      //Starting value for Player food points.
    public static GameManager instance = null;              //Static instance of GameManager which allows it to be accessed by any other script.
    [HideInInspector]
    public bool playersTurn = true;       //Boolean to check if it's players turn, hidden in inspector but public.
    public bool doingSetup = true;
    public GameObject cube;
    public bool paused = false;
    public int level = 1;
    public LayerMask outlinesLayer;

    public Tilemap[] tilemaps;
    public GameObject board;
    public BoardManager boardScript;

    private Transform[] tiles;
    private Text levelText;                                 //Text to display current level number.
    private GameObject levelImage;
    //Store a reference to our BoardManager which will set up the level.
    //Current level number, expressed in game as "Day 1".
    public List<Enemy> enemies;                          //List of all Enemy units, used to issue them move commands.
    private bool enemiesMoving;                             //Boolean to check if enemies are moving.
                                                            //Boolean to check if we're setting up board, prevent Player from moving during setup.
    private IEnumerator ClickCoroutine;


    //Awake is always called before any Start functions
    void Awake()
    {
        //Check if instance already exists
        if (instance == null)

            //if not, set instance to this
            instance = this;

        //If instance already exists and it's not this:
        else if (instance != this)

            //Then destroy this. This enforces our singleton pattern, meaning there can only ever be one instance of a GameManager.
            Destroy(gameObject);

        //Sets this to not be destroyed when reloading scene
        DontDestroyOnLoad(gameObject);

        //Assign enemies to a new List of Enemy objects.
        enemies = new List<Enemy>();

        //Get a component reference to the attached BoardManager script
        boardScript = GetComponent<BoardManager>();

        //

        //Call the InitGame function to initialize the first level
        InitGame();
    }

    //This is called each time a scene is loaded.
    void OnLevelWasLoaded(int index)
    {
        //Add one to our level number.
        level++;
        //Call InitGame to initialize our level.
        InitGame();
    }

    //Initializes the game for each level.
    void InitGame()
    {
        //While doingSetup is true the player can't move, prevent player from moving while title card is up.
        doingSetup = true;

        //Get a reference to our image LevelImage by finding it by name.
        levelImage = GameObject.Find("Level Image");

        //Get a reference to our text LevelText's text component by finding it by name and calling GetComponent.
        levelText = GameObject.Find("Level Text").GetComponent<Text>();

        //Set the text of levelText to the string "Day" and append the current level number.
        levelText.text = "Depth " + level;

        //Set levelImage to active blocking player's view of the game board during setup.
        levelImage.SetActive(true);

        //Call the HideLevelImage function with a delay in seconds of levelStartDelay.
        Invoke("HideLevelImage", levelStartDelay);

        //Clear any Enemy objects in our List to prepare for next level.
        enemies.Clear();



        Player.instance.transform.position = new Vector3(0, 0);
        Player.instance.enabled = true;

        cube = Player.instance.transform.GetChild(0).gameObject;

        if (level == 1)
        {
            boardScript.InstantiateTutorialBoard(0);
            board = GameObject.FindGameObjectWithTag("Board");
            tilemaps = board.GetComponentsInChildren<Tilemap>();
            return;
        }
        else if (level == 2)
        {
            boardScript.InstantiateTutorialBoard(1);
            return;
        }
        else
        {
            //Call the SetupScene function of the BoardManager script, pass it current level number.
            boardScript.SetupScene(level);
        }


    }


    //Hides black image used between levels
    void HideLevelImage()
    {
        //Disable the levelImage gameObject.
        levelImage.SetActive(false);

        //Set doingSetup to false allowing player to move again.
        doingSetup = false;
    }


    Vector3 st = Vector3.zero;
    Vector3 ed = Vector3.zero;

    //Update is called every frame.
    void Update()
    {

        Debug.DrawLine(st, ed);

        //Check that playersTurn or enemiesMoving or doingSetup are not currently true.
        if (playersTurn || enemiesMoving || doingSetup)

            //If any of these are true, return and do not start MoveEnemies.
            return;

        //Start moving enemies.
        StartCoroutine(MoveEnemies());
    }

    //Call this to add the passed in Enemy to the List of Enemy objects.
    public void AddEnemyToList(Enemy script)
    {
        //Add Enemy to List enemies.
        enemies.Add(script);
    }


    //GameOver is called when the player reaches 0 food points
    public void GameOver()
    {
        //Set levelText to display number of levels passed and game over message
        levelText.text = "You succumbed to the Die.";

        //Enable black background image gameObject.
        levelImage.SetActive(true);

        //Disable this GameManager.
        enabled = false;
    }

    //Coroutine to move enemies in sequence.
    IEnumerator MoveEnemies()
    {
        //While enemiesMoving is true player is unable to move.
        enemiesMoving = true;

        //Wait for turnDelay seconds, defaults to .1 (100 ms).
        yield return new WaitForSeconds(turnDelay);

        //If there are no enemies spawned (IE in first level):
        if (enemies.Count == 0)
        {
            //Wait for turnDelay seconds between moves, replaces delay caused by enemies moving when there are none.
            yield return new WaitForSeconds(turnDelay);
        }

        //Loop through List of Enemy objects.
        for (int i = 0; i < enemies.Count; i++)
        {
            //Call the MoveEnemy function of Enemy at index i in the enemies List.
            enemies[i].MoveEnemy();

            //Wait for Enemy's moveTime before moving next Enemy,
            yield return new WaitForSeconds(enemies[i].moveTime);
        }
        //Once Enemies are done moving, set playersTurn to true so player can move.
        playersTurn = true;

        //Enemies are done moving, set enemiesMoving to false.
        enemiesMoving = false;
    }

    public void SelectTarget(List<Vector3Int> actablePositions, Item item)
    {
        StartCoroutine(MoveCurrentHighlighted(actablePositions, item));
    }



    IEnumerator MoveCurrentHighlighted(List<Vector3Int> actablePositions, Item item)
    {
        Tilemap outlinesMap = Array.Find(tilemaps, x => x.name == "Outlines"); // the tilemap on which all outlines are drawn
        Vector2Int playerPos = new Vector2Int((int)Player.instance.transform.position.x, (int)Player.instance.transform.position.y); // the position of the player in Vector2Int because tilemaps methods take only Integer as parameters
        Vector2Int currentHighlighted = playerPos; // only for the beginning, put currentHighlighted at a relative (0,0,0)
        Vector2Int previousHighlighted; // a field to store the position that was highlighted in order to switch the sprite to the normal outline
        Vector2Int direction; // the direction that the player wants to go towards when selecting target
        bool selectingTarget = true;

        while (selectingTarget) // everyframe, while this is true
        {
            // if the player uses arrows keys
            if (Input.GetKeyDown(KeyCode.RightArrow) || Input.GetKeyDown(KeyCode.LeftArrow) || Input.GetKeyDown(KeyCode.UpArrow) || Input.GetKeyDown(KeyCode.DownArrow))
            {

                // typical GetAxis...
                int horizontal = 0;
                int vertical = 0;

                horizontal = (int)Input.GetAxisRaw("Horizontal");
                vertical = (int)Input.GetAxisRaw("Vertical");

                direction = new Vector2Int(horizontal, vertical);

                previousHighlighted = currentHighlighted; // store the position of the currentHighlighted before it changes

                RaycastHit2D hit = Physics2D.Raycast(currentHighlighted+outlinesMap.cellSize.x* (Vector2)direction, direction, 10, outlinesLayer); // Cast a ray from currentHighlighted toward the direction on the outlinesLayer

                st = currentHighlighted + outlinesMap.cellSize.x * (Vector2)direction;

                ed = st + (Vector3)(Vector2)direction * 10f;

                //Debug.Log(hit.collider.name);

                // If the ray hit something, then there is an outline in that direction
                if (hit.collider != null)
                {
                    Debug.Log("here");
                    Debug.Log(hit.point);
                    Vector3Int pos = outlinesMap.WorldToCell(hit.point + outlinesMap.cellSize.x / 2f * (Vector2)direction);
                    currentHighlighted = new Vector2Int(pos.x, pos.y);
                    // Until currentHighlight is not equivalent to the position of an outlineTile on the outlinesMap... (Since the ray has hit something on the outlines layer, there should necessarily be an outlineTile in that direction)
                    //while (outlinesMap.GetTile(new Vector3Int(currentHighlighted.x, currentHighlighted.y, 0)) != board.GetComponent<GridInformation>().outlineTile)
                    //    currentHighlighted += direction;
                }
                //else if (hit.collider == null) // The ray originating from currentHighlighted has not hit anything, thus there is no outlineTile in that direction
                //{
                //    Debug.Log("Recasting from player");

                //    //// Cast a ray toward the direction on the Outlines layer, but this time the origin is the player's position
                //    //RaycastHit2D hitFromPlayer = Physics2D.Raycast(playerPos, direction, 10, outlinesLayer);

                //    //// If the ray hit something, then there is an outline in that direction
                //    //if (hitFromPlayer.collider != null)
                //    //    // Until currentHighlight is not equivalent to the position of an outlineTile on the outlinesMap... (Since the ray has hit something on the outlines layer, there should necessarily be an outlineTile in that direction)
                //    //    while (outlinesMap.GetTile(new Vector3Int(currentHighlighted.x, currentHighlighted.y, 0)) != board.GetComponent<GridInformation>().outlineTile)
                //    //        currentHighlighted += direction;
                //    //else // both rays have not returned anything
                //    //{
                //    //    Debug.Log("Both raycasts did not hit anything. There is no available target in that direction");
                //    //}


                //    hit = Physics2D.Raycast(playerPos + direction, direction, 10, outlinesLayer); // Cast a ray from currentHighlighted toward the direction on the outlinesLayer
                //    if (hit.collider != null)
                //    {
                //        Vector3Int pos = outlinesMap.WorldToCell(hit.point);
                //        currentHighlighted = new Vector2Int(pos.x, pos.y);
                //    }
                //    else
                //    {
                //        Debug.Log("Both raycasts did not hit anything. There is no available target in that direction");
                //    }
                //}

                Debug.Log(currentHighlighted);

                UpdateHighlighted(outlinesMap, previousHighlighted, currentHighlighted);
            }
            else if (Input.GetKeyDown(KeyCode.Space)) // If user presses spacebar, use the action, turn all outlines off and quit the coroutine
            {
                item.Use(new Vector3Int(currentHighlighted.x, currentHighlighted.y, 0));
                selectingTarget = false;
                StopCoroutine(MoveCurrentHighlighted(actablePositions, item));
            }

            yield return null;
        }
    }

    public void UpdateHighlighted(Tilemap outlinesMap, Vector2Int previousHighlighted, Vector2Int currentHighlighted)
    {
        // if the outlinesMap has a tile at the currentHighlighted...
        if (outlinesMap.HasTile(new Vector3Int(currentHighlighted.x, currentHighlighted.y, 0)))
        {
            // if the outlinesMap has a tile at the previousHighlighted... (this is to make sure that, at the beginning when currentHighlighted is set to the playerPos, the playerPos does not become outlined)
            if (outlinesMap.HasTile(new Vector3Int(previousHighlighted.x, previousHighlighted.y, 0)))
                // set the previously highlighted outlineTile back to the normal outlineTile
                outlinesMap.SetTile(new Vector3Int(previousHighlighted.x, previousHighlighted.y, 0), board.GetComponent<GridInformation>().outlineTile);

            // Switch the normal outlineTile to the selectedOutlineTile
            outlinesMap.SetTile(new Vector3Int(currentHighlighted.x, currentHighlighted.y, 0), board.GetComponent<GridInformation>().selectedOutlineTile);
        }
    }
}