using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UIElements;
using Mirror;

public class SnakeController : NetworkBehaviour
{
    [SyncVar]
    public string userId;
    [SyncVar(hook = nameof(OnScoreChange))]
    public int Score = 0;
    public Vector2 startOffset = new Vector3(-10, -10);
    public float movingInterval = 0.2f;
    [SyncVar]
    public Vector2 curDirection = Vector3.right;
    public List<SnakePiece> snakePieces = new List<SnakePiece>();
    public List<BendData> bends = new List<BendData>();
    [SyncVar]
    private List<BendData> serverBends = new List<BendData>();
    public GameObject snakePiecePrefab;
    public int startingLength = 3;

    public Vector2 fieldSize = new Vector2(160, 90);
    float moveTimer;
    [SyncVar]
    private float serverMoveTimer;

    public float topEdge => transform.position.y + fieldSize.y / 2f;
    public float botEdge => transform.position.y - fieldSize.y / 2f;
    public float leftEdge => transform.position.x - fieldSize.x / 2f;
    public float rightEdge => transform.position.x + fieldSize.x / 2f;

    // Add new fields for client prediction
    private List<Vector2> predictedPositions = new List<Vector2>();
    private List<Vector2> predictedDirections = new List<Vector2>();
    private float lastServerUpdateTime;
    private const float MAX_PREDICTION_TIME = 0.5f; // Maximum time to keep predictions
    private const float PREDICTION_TOLERANCE = 0.1f; // Tolerance for position matching
    private const float SYNC_THRESHOLD = 1f; // Distance threshold for considering out of sync

    void Start()
    {
        ButtonSet.OnUp += OnUp;
        ButtonSet.OnDown += OnDown;
        ButtonSet.OnLeft += OnLeft;
        ButtonSet.OnRight += OnRight;

#if UNITY_EDITOR
        GameData.user_id = "user" + Random.Range(0, 100);
#endif

        if (!isServer && isLocalPlayer)
        {
            CmdSetUserId(GameData.user_id);
        }

        if (isLocalPlayer)
        {
            lastServerUpdateTime = Time.time;
            playerType = GameData.isMaster ? PlayerType.Master : PlayerType.Client;

        }
    }

    [Command]
    void CmdSetUserId(string userId)
    {
        if (GameData.betData == null)
        {
            startOffset.y += Random.Range(0, 10);
            this.userId = userId;

        }
        else
        {
            if (userId == GameData.betData.owner_id)
            {
                startOffset.y += 10;
            }
            this.userId = userId;
            playerType = userId == GameData.betData.owner_id ? PlayerType.Master : PlayerType.Client;
        }

    }

    private void OnDestroy()
    {
        ButtonSet.OnUp -= OnUp;
        ButtonSet.OnDown -= OnDown;
        ButtonSet.OnLeft -= OnLeft;
        ButtonSet.OnRight -= OnRight;
    }
    [SyncVar]
    public bool isKickstarted = false;
    void OnSnakePiecesChanged(List<NetworkIdentity> oldPieces, List<NetworkIdentity> newPieces)
    {
        if (!isClient) return;
        Debug.Log("Server added a new piece with id: " + newPieces[newPieces.Count - 1].netId);
        
        // Clear existing pieces
        foreach (var piece in snakePieces)
        {
            if (piece != null)
            {
                Destroy(piece.gameObject);
            }
        }
        snakePieces.Clear();

        // Add new pieces
        foreach (var netId in newPieces)
        {
            if (netId != null)
            {
                var piece = netId.GetComponent<SnakePiece>();
                if (piece != null)
                {
                    snakePieces.Add(piece);
                }
            }
        }
    }

    public void StartGame()
    {
        if (!isServer) return;

        snakePieces = new List<SnakePiece>();
        
        for (int i = 0; i < startingLength; i++)
        {
            Vector3 pos = ((Vector2)transform.position - startOffset) - (Vector2.right * i);
            GameObject newPiece = Instantiate(snakePiecePrefab, pos, Quaternion.identity);
            NetworkServer.Spawn(newPiece);
            SnakePiece piece = newPiece.GetComponent<SnakePiece>();
            piece.userId = userId;
            snakePieces.Add(piece);
            RpcAddSnakePiece(piece.netIdentity);
        }
        isKickstarted = true;
        isDead = false;
    }

    [ClientRpc]
    void RpcAddSnakePiece(NetworkIdentity netId)
    {
        var piece = netId.GetComponent<SnakePiece>();
        if (piece != null)
        {
            snakePieces.Add(piece);
        }
    }

    public bool controlling = false;
    void Update()
    {
        if (isLocalPlayer)
        {
            ProcessInput();
        }
        if (NetGameManager.instance.gameOver) { return; }
        if (!isKickstarted) { return; }

        if (isServer)
        {
            CheckHead();
            if (isDead) { return; }
            Move();
        }
        else if (isLocalPlayer)
        {
            // Client-side prediction for local player
            if (moveTimer > 0)
            {
                moveTimer -= Time.deltaTime;
            }
            else
            {
                moveTimer = movingInterval;
                PredictMove();
            }
        }
    }

    void ProcessInput()
    {
        if (Input.GetKeyDown(KeyCode.RightArrow))
        {
            OnRight();
        }
        else if (Input.GetKeyDown(KeyCode.LeftArrow))
        {
            OnLeft();
        }
        else if (Input.GetKeyDown(KeyCode.UpArrow))
        {
            OnUp();
        }
        else if (Input.GetKeyDown(KeyCode.DownArrow))
        {
            OnDown();
        }
    }

    void OnRight()
    {
        ChangeDir(Vector2.right);
    }

    void OnLeft()
    {
        ChangeDir(-Vector2.right);
    }

    void OnUp()
    {
        ChangeDir(Vector2.up);
    }

    void OnDown()
    {
        ChangeDir(-Vector2.up);
    }

    public void AddScore(int amount = 1)
    {
        Score += amount;
        if (isServer)
        {
            RpcOnScore();
        }
        else
        {
            OnScore();
        }
    }

    [ClientRpc]
    void RpcOnScore()
    {
        OnScore();
    }

    void OnScoreChange(int oldScore, int newScore)
    {
        NetGameManager.instance.UpdateScore(isLocalPlayer, newScore);
    }

    void OnScore()
    {
        SFXManager.instance.PlayCrunch();
    }

    List<Vector2> moveInputQueue = new List<Vector2>();
    void ChangeDir(Vector2 newDir)
    {
        if (isServer)
        {
            changeDir(newDir);
        }
        else
        {
            CmdChangeDir(newDir);
        }
        SFXManager.instance.PlayTurn();
    }

    void changeDir(Vector2 newDir)
    {
        if (curDirection == -newDir)
        {
            return;
        }
        moveInputQueue.Add(newDir);
    }

    [Command]
    void CmdChangeDir(Vector2 newDir)
    {
        changeDir(newDir);
    }

    bool queueNewPiece = false;
    void PredictMove()
    {
        if (moveInputQueue.Count > 0)
        {
            Vector2 dir = Vector2.zero;
            if (curDirection.x != 0)
            {
                dir = new Vector2(-curDirection.x, moveInputQueue[0].y);
            }
            else
            {
                dir = new Vector2(moveInputQueue[0].x, -curDirection.y);
            }
            curDirection = moveInputQueue[0];
            moveInputQueue.RemoveAt(0);

            // Add bend to both local and server lists
            BendData newBend = new BendData()
            {
                position = snakePieces[0].transform.position,
                direction = dir
            };
            bends.Add(newBend);
            CmdAddBend(newBend);
        }

        // Store current state for prediction
        Vector2 curPosition = snakePieces[0].transform.position;
        Vector2 lastPosition = snakePieces[snakePieces.Count - 1].transform.position;

        // Update snake pieces
        for (int i = snakePieces.Count - 1; i > 0; i--)
        {
            Vector3 dir = (snakePieces[i - 1].transform.position - snakePieces[i].transform.position).normalized;
            snakePieces[i].direction = dir;
            snakePieces[i].isHead = false;
            snakePieces[i].transform.position = snakePieces[i - 1].transform.position;

            BendData bendToRemove = null;
            foreach (BendData bend in bends)
            {
                if (bend.position == snakePieces[i].transform.position)
                {
                    snakePieces[i].direction = bend.direction;
                    if (i == snakePieces.Count - 1)
                    {
                        bendToRemove = bend;
                    }
                    break;
                }
            }

            if (bendToRemove != null)
            {
                bends.Remove(bendToRemove);
                CmdRemoveBend(bendToRemove);
            }
        }

        // Move head
        snakePieces[0].transform.position = (Vector3)curPosition + (Vector3)curDirection;
        snakePieces[0].direction = curDirection;
        snakePieces[0].isHead = true;

        // Handle wrapping
        if (snakePieces[0].transform.position.x > rightEdge)
        {
            snakePieces[0].transform.position = new Vector2(leftEdge, snakePieces[0].transform.position.y);
        }
        else if (snakePieces[0].transform.position.x < leftEdge)
        {
            snakePieces[0].transform.position = new Vector2(rightEdge, snakePieces[0].transform.position.y);
        }

        if (snakePieces[0].transform.position.y > topEdge)
        {
            snakePieces[0].transform.position = new Vector2(snakePieces[0].transform.position.x, botEdge);
        }
        else if (snakePieces[0].transform.position.y < botEdge)
        {
            snakePieces[0].transform.position = new Vector2(snakePieces[0].transform.position.x, topEdge);
        }

        // Store prediction
        predictedPositions.Add(snakePieces[0].transform.position);
        predictedDirections.Add(curDirection);

        // Request server sync periodically
        if (Time.time - lastServerUpdateTime > 0.1f) // Request sync every 100ms
        {
            CmdRequestSync();
        }
    }

    void Move()
    {
        if (moveTimer > 0)
        {
            moveTimer -= Time.deltaTime;
            return;
        }

        moveTimer = movingInterval;
        if (moveInputQueue.Count > 0)
        {
            Vector2 dir = Vector2.zero;
            if (curDirection.x != 0)
            {
                dir = new Vector2(-curDirection.x, moveInputQueue[0].y);
            }
            else
            {
                dir = new Vector2(moveInputQueue[0].x, -curDirection.y);
            }
            curDirection = moveInputQueue[0];
            moveInputQueue.RemoveAt(0);

            // Add bend to both local and server lists
            BendData newBend = new BendData()
            {
                position = snakePieces[0].transform.position,
                direction = dir
            };
            bends.Add(newBend);
            CmdAddBend(newBend);
        }

        Vector2 curPosition = snakePieces[0].transform.position;
        Vector2 lastPosition = snakePieces[snakePieces.Count - 1].transform.position;

        // Update snake pieces
        for (int i = snakePieces.Count - 1; i > 0; i--)
        {
            Vector3 dir = (snakePieces[i - 1].transform.position - snakePieces[i].transform.position).normalized;
            snakePieces[i].direction = dir;
            snakePieces[i].isHead = false;
            snakePieces[i].transform.position = snakePieces[i - 1].transform.position;

            BendData bendToRemove = null;
            foreach (BendData bend in bends)
            {
                if (bend.position == snakePieces[i].transform.position)
                {
                    snakePieces[i].direction = bend.direction;
                    if (i == snakePieces.Count - 1)
                    {
                        bendToRemove = bend;
                    }
                    break;
                }
            }

            if (bendToRemove != null)
            {
                bends.Remove(bendToRemove);
                CmdRemoveBend(bendToRemove);
            }
        }

        if (queueNewPiece)
        {
            GameObject newPiece = Instantiate(snakePiecePrefab, lastPosition, Quaternion.identity);
            NetworkServer.Spawn(newPiece);
            SnakePiece piece = newPiece.GetComponent<SnakePiece>();
            piece.userId = userId;
            snakePieces.Add(piece);
            RpcAddSnakePiece(piece.netIdentity);
            SFXManager.instance.PlayCrunch();
            AddScore();

            queueNewPiece = false;
        }

        // Move head
        snakePieces[0].transform.position = (Vector3)curPosition + (Vector3)curDirection;
        snakePieces[0].direction = curDirection;
        snakePieces[0].isHead = true;

        // Handle wrapping
        if (snakePieces[0].transform.position.x > rightEdge)
        {
            snakePieces[0].transform.position = new Vector2(leftEdge, snakePieces[0].transform.position.y);
        }
        else if (snakePieces[0].transform.position.x < leftEdge)
        {
            snakePieces[0].transform.position = new Vector2(rightEdge, snakePieces[0].transform.position.y);
        }

        if (snakePieces[0].transform.position.y > topEdge)
        {
            snakePieces[0].transform.position = new Vector2(snakePieces[0].transform.position.x, botEdge);
        }
        else if (snakePieces[0].transform.position.y < botEdge)
        {
            snakePieces[0].transform.position = new Vector2(snakePieces[0].transform.position.x, topEdge);
        }

        // After server movement, send state to clients
        if (isServer)
        {
            Vector2[] positions = new Vector2[snakePieces.Count];
            Vector2[] directions = new Vector2[snakePieces.Count];

            for (int i = 0; i < snakePieces.Count; i++)
            {
                positions[i] = snakePieces[i].transform.position;
                directions[i] = snakePieces[i].direction;
            }

            RpcReconcileState(positions, directions, serverMoveTimer);
        }
    }

    [Command]
    void CmdRequestSync()
    {
        Vector2[] positions = new Vector2[snakePieces.Count];
        Vector2[] directions = new Vector2[snakePieces.Count];

        for (int i = 0; i < snakePieces.Count; i++)
        {
            positions[i] = snakePieces[i].transform.position;
            directions[i] = snakePieces[i].direction;
        }

        RpcReconcileState(positions, directions, serverMoveTimer);
    }

    [ClientRpc]
    void RpcReconcileState(Vector2[] serverPositions, Vector2[] serverDirections, float serverTimer)
    {
        if (!isLocalPlayer && !isServer) 
        {
            // For non-local players, directly update positions from server
            for (int i = 0; i < snakePieces.Count; i++)
            {
                if (i < serverPositions.Length)
                {
                    snakePieces[i].transform.position = serverPositions[i];
                    snakePieces[i].direction = serverDirections[i];
                    snakePieces[i].isHead = (i == 0);
                }
            }
            return;
        }

        if (!isLocalPlayer) return;

        // Sync move timer with server
        moveTimer = serverTimer;

        // Find the oldest prediction that matches the server state
        int matchIndex = -1;
        for (int i = 0; i < predictedPositions.Count; i++)
        {
            if (Vector2.Distance(predictedPositions[i], serverPositions[0]) < PREDICTION_TOLERANCE)
            {
                matchIndex = i;
                break;
            }
        }

        if (matchIndex >= 0)
        {
            // Remove all predictions up to the matching one
            predictedPositions.RemoveRange(0, matchIndex + 1);
            predictedDirections.RemoveRange(0, matchIndex + 1);
        }
        else
        {
            // Check if we're significantly out of sync
            bool needsSync = false;
            float maxDist = 0;
            for (int i = 0; i < snakePieces.Count; i++)
            {
                if (i < serverPositions.Length)
                {
                    float distance = Vector2.Distance(snakePieces[i].transform.position, serverPositions[i]);
                    if (distance > SYNC_THRESHOLD)
                    {
                        maxDist = Mathf.Max(maxDist, distance);
                        needsSync = true;
                    }
                }
            }

            if (needsSync)
            {
                Debug.Log("Syncing local player, max dist: " + maxDist);
                // Only update positions if significantly out of sync
                for (int i = 0; i < snakePieces.Count; i++)
                {
                    if (i < serverPositions.Length)
                    {
                        snakePieces[i].transform.position = serverPositions[i];
                        snakePieces[i].direction = serverDirections[i];
                        snakePieces[i].isHead = (i == 0);
                    }
                }
                // Clear predictions after sync
                predictedPositions.Clear();
                predictedDirections.Clear();
            }
        }

        lastServerUpdateTime = Time.time;
    }

    bool isDead = false;
    public PlayerType playerType;
    void CheckHead()
    {
        Collider2D[] obstacles = Physics2D.OverlapCircleAll(snakePieces[0].transform.position, 0.25f);
        foreach (Collider2D obstacle in obstacles)
        {
            if (obstacle.GetComponent<SnakePiece>() != null)
            {
                if (obstacle.transform == snakePieces[0].transform)
                {

                }
                else
                {
                    Debug.Log($"Crashed into {obstacle.name}", gameObject);
                    isDead = true;
                    NetGameManager.instance.GameOver(playerType == PlayerType.Master ? PlayerType.Client : PlayerType.Master);
                    SFXManager.instance.PlayDeath();
                }
            }

            if (obstacle.GetComponent<Fruit>() != null)
            {
                queueNewPiece = true;

                NetGameManager.instance.DestroyFruit(obstacle.transform.position);
            }

        }
    }

    private void OnDrawGizmos()
    {
        Gizmos.DrawWireCube(transform.position, new Vector3(fieldSize.x, fieldSize.y));
        if (snakePieces.Count > 0)
        {
            Gizmos.DrawWireSphere(snakePieces[0].transform.position, 0.25f);
        }
    }

    [Command]
    void CmdAddBend(BendData bend)
    {
        serverBends.Add(bend);
        RpcAddBend(bend);
    }

    [Command]
    void CmdRemoveBend(BendData bend)
    {
        serverBends.Remove(bend);
        RpcRemoveBend(bend);
    }

    [ClientRpc]
    void RpcAddBend(BendData bend)
    {
        if (!isLocalPlayer)
        {
            bends.Add(bend);
        }
    }

    [ClientRpc]
    void RpcRemoveBend(BendData bend)
    {
        if (!isLocalPlayer)
        {
            bends.Remove(bend);
        }
    }
}

[System.Serializable]
public class BendData
{
    public Vector3 position;
    public Vector2 direction;
}