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

[System.Serializable]
public struct TileData
{
    public PlayerType playerType;
    public Transform playerFinishingTileParent;
}

public class TilesManager : MonoBehaviour, IBootLoader, IDataLoader, IBase
{
    [SerializeField] private Tile[] generalTiles;
    [SerializeField] private TileData[] tileDatas;

    private GameplayManager gameplayManager;

    private Dictionary<PlayerType, List<Tile>> finishingTileDataPairs = new Dictionary<PlayerType, List<Tile>>();

    public void Initialize()
    {
        InterfaceManager.Instance.RegisterInterface<TilesManager>(this);
    }

    public void InitializeData()
    {
        gameplayManager = InterfaceManager.Instance.GetInterfaceInstance<GameplayManager>();
    }

    public void InitTilesData()
    {
        finishingTileDataPairs = new Dictionary<PlayerType, List<Tile>>();
        foreach (var tileData in tileDatas)
        {
            if (gameplayManager.PlayerTypesCollection.Contains(tileData.playerType))
            {
                finishingTileDataPairs.Add(tileData.playerType, new List<Tile>());     
                foreach (Transform child in tileData.playerFinishingTileParent)
                    finishingTileDataPairs[tileData.playerType].Add(child.GetComponent<Tile>());
            }
        }
    }

    public int GetFinishingTileDataLength(PlayerType playerType) => finishingTileDataPairs[playerType].Count;

    public int GetGeneralTilesLength() => generalTiles.Length;

    public Tile RetrieveTileBasedOnIndex(int index)
    {
        Debug.Log($"RetrieveTileBasedOnIndex: Index: {index}");

        Tile tile = index == generalTiles.Length ? generalTiles[0] : generalTiles[index];

        return tile;
    }

    public Tile RetrieveFinishingTileBasedOnIndex(PlayerType playerType, int index)
    {
        return finishingTileDataPairs[playerType][index];
    }

    public int GetNextGeneralTileIndex(int currentTileIndex)
    {
        return currentTileIndex == GetGeneralTilesLength() - 1 ? 0 : currentTileIndex + 1;
    }

    public int GetNextFinishingTileIndex(int currentTileIndex, PlayerType currentPlayerTypeTurn)
    {
        return currentTileIndex > GetFinishingTileDataLength(currentPlayerTypeTurn) - 1 ? 0 : currentTileIndex + 1;
    }

    public void ResetData()
    {
        finishingTileDataPairs.Clear();
    }

    // causes null ref cast exception while player is moving.
    /*
    public void ResetTileData(PlayerType playerType, int currentTileIndex, PlayerState playerState)
    {
        if (playerState == PlayerState.InFinishingPath || playerState == PlayerState.HasFinished)
        {
            Tile tile = RetrieveFinishingTileBasedOnIndex(playerType, currentTileIndex);
            tile.ResetTileData();
        }
        else if (playerState == PlayerState.Moving)
        {
            Tile tile = RetrieveTileBasedOnIndex(currentTileIndex);
            tile.ResetTileData();
        }
        else if (playerState == PlayerState.InSafeZone)
        {
            SafeTile tile = (SafeTile)RetrieveTileBasedOnIndex(currentTileIndex);
            tile.ResetTileData();
        }
    }
    */

    public void ResetTileDatas()
    {
        foreach (var tile in generalTiles)
            tile.ResetTileData();

        foreach (var pair in finishingTileDataPairs)
        {
            foreach (var tile in finishingTileDataPairs[pair.Key])
            {
                tile.ResetTileData();
            }
        }
    }

    public Vector3 GetAndInitPositionInsideSafeZone(PlayerPawn playerPawn, Tile targetTile, PlayerType currentPlayerTypeTurn)
    {
        Vector3 targetPosition;
        SafeTile targetSafeTile = (SafeTile)targetTile;
        Debug.Log($"targetSafeTile.PlayerTypesCount: {targetSafeTile.PlayerTypesCount}");
        if (targetSafeTile.PlayerTypesCount == 1)
        {
            Debug.Log($"targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn): {targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn)}");
            if (!targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn)) // means it is a new player type, the second one
            {
                PlayerType initialPlayerType = targetSafeTile.GetFirstPlayerType();

                // rearrange already existing player from center position to it's saved transform
                Debug.Log($"### GetAndInitPositionInsideSafeZone initialPlayerType: {initialPlayerType}");
                var playerPawns = targetSafeTile.GetPlayerPawns(initialPlayerType);
                Debug.Log($"### GetAndInitPositionInsideSafeZone playerPawns: {playerPawns.Count}");

                foreach (var pawn in playerPawns)
                {
                    var placementPoint = targetSafeTile.GetPlacementPoint(initialPlayerType);
                    Debug.Log($"### GetAndInitPositionInsideSafeZone placementPoint: {placementPoint.position}");
                    pawn.MoveToCustomTilePosition(placementPoint.position);
                }

                Debug.Log($"### GetAndInitPositionInsideSafeZone playerPawn: {playerPawn.name}, {playerPawn.PlayerType}");
                Debug.Log($"### GetAndInitPositionInsideSafeZone currentPlayerTypeTurn: {currentPlayerTypeTurn}");

                targetSafeTile.InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
                targetPosition = targetSafeTile.GetPlacementPoint(currentPlayerTypeTurn).position;

                Debug.Log($"### GetAndInitPositionInsideSafeZone targetPosition: {targetPosition}");
            }
            else
            {
                targetSafeTile.InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
                targetPosition = targetTile.CenterPlacementPosition;
            }
        }
        else
        {
            // TODO :: Check the data if it's consistent
            Debug.Log($"targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn): {targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn)}");
            if (!targetSafeTile.ContainsPlayerType(currentPlayerTypeTurn))
            {
                Debug.Log($"targetSafeTile.PlayerTypesCount: {targetSafeTile.PlayerTypesCount}");
                if (targetSafeTile.PlayerTypesCount < 1) // he is the only player that is being added to the safe zone
                {
                    targetSafeTile.InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
                    targetPosition = targetTile.CenterPlacementPosition;
                }
                else
                {
                    targetSafeTile.InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
                    targetPosition = targetSafeTile.GetPlacementPoint(currentPlayerTypeTurn).position;
                }
            }
            else
            {
                targetSafeTile.InitPlayerPawn(playerPawn, currentPlayerTypeTurn);
                targetPosition = targetSafeTile.GetPlacementPoint(currentPlayerTypeTurn).position;
            }
        }

        return targetPosition;
    }
}