ColorBomb

using System;
using System.Collections;
using UnityEngine;
using Unity.Netcode;
using Unity.Netcode.Components;
using UnityEngine.SceneManagement;

public class PlayerController : NetworkBehaviour
{
    
    [SerializeField] private float _moveSpeed = 5f;
    [SerializeField] private int teamNumber = 0;//0 : Yellow , 1 : Purple , 2 : Green , 3 : Blue

    private bool isSpawn = false;
    public  int distance = 2;

    //SpeedBoost
    private float normalSpeed;
    private float _itemDuration;
    
    //Protection
    private bool Protection ; 
    private float _protectDuration;
    
    //ExplosionRangeOne
    private bool ExplosionRangeOne;
    private float _explosionRangeOneDuration;
    
    //ExplosionRangeOne
    private bool ExplosionRangeTwo;
    
    //Prefab
    [SerializeField] private GameObject[] bombPrefab;

    [SerializeField] private Sound Dead , Collect , Placebomb ;

    //Grid
    private Grid grid;
    private GameObject _grid;

    private Rigidbody2D rb;

    private int maxBombs = 3;                   //Change Max Bomb HERE <--
    private float refillTime = 3f;             //Change Refill Bomb delay HERE <--

    private int currentBombs;
    private bool isRefilling;
    private bool dieing;

    private GameManager _gameManager;

    [SerializeField] private Animator animator;

    private void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        normalSpeed = _moveSpeed;
        currentBombs = maxBombs;
        isRefilling = false;
        ExplosionRangeOne = false;
        afterplay = false;
        dieing = false;
    }
 
    private void Update()
    {
        if(IsOwner) 
        {
            animator.SetInteger("teamNumber" , teamNumber);
            spawnpoint();
            if( GameObject.FindGameObjectWithTag("Grid") == null ) return;
             _grid = GameObject.FindGameObjectWithTag("Grid");
             grid = _grid.GetComponent<Grid>();
            Movement();
            GameManager.instance.BombCountText.text = /*"current Bomb : " + */"" +currentBombs;
        }
        
    }

    private void PlaceBomb()
    {
        if( currentBombs > 0)
        {
            SoundManager.instance.Play(Collect);
            Vector3Int cellPosition = grid.WorldToCell(transform.position);
            Vector3 cellCenter = grid.GetCellCenterWorld(cellPosition);
            SpawnBombServerRpc(cellCenter);
            currentBombs--;
            isRefilling = true;
            StartCoroutine(RefillBombs());
            if (ExplosionRangeOne)
            {
                SpawnBombOptionOneServerRpc(cellCenter);
            }
            SoundManager.instance.Play(Placebomb);
            animator.SetTrigger("Hold");

        }
    }

    IEnumerator RefillBombs()
    {
        yield return new WaitForSeconds(refillTime);
        currentBombs++;
        isRefilling = false;
    }

    [ClientRpc]
    void SpawnBombClientRpc( Vector3 cellCenter )
    {
        GameObject temp = bombPrefab[teamNumber];
        temp.GetComponentInChildren<Bomb>()._distance = distance ;
        Instantiate(temp , cellCenter , Quaternion.identity);
    }
    [ClientRpc]
    void SpawnBombOptionOneClientRpc( Vector3 cellCenter )
    {
        GameObject temp = bombPrefab[teamNumber];
        temp.GetComponentInChildren<Bomb>()._distance = distance + 1;
        Instantiate(temp , cellCenter , Quaternion.identity);
    }
    [ClientRpc]
    void SpawnBombOptionTwoClientRpc( Vector3 cellCenter )
    {
        GameObject temp = bombPrefab[teamNumber];
        temp.GetComponentInChildren<Bomb>()._distance = distance;
        Instantiate(temp , cellCenter , Quaternion.identity);
    }

    [ServerRpc]
    void SpawnBombServerRpc( Vector3 cellCenter )
    {
        SpawnBombClientRpc(cellCenter);
    }
    [ServerRpc]
    void SpawnBombOptionOneServerRpc( Vector3 cellCenter )
    {
        SpawnBombOptionOneClientRpc(cellCenter);
    }
    [ServerRpc]
    void SpawnBombOptionTwoServerRpc( Vector3 cellCenter )
    {
        SpawnBombOptionTwoClientRpc(cellCenter);
    }


    private void Movement()
    {
        if( !GameManager.instance.isGameOver )
        {
            if( GameManager.instance.isStart )
            {
                if( dieing == false )
                {
                    float x = Input.GetAxis("Horizontal");
                    float y = Input.GetAxis("Vertical");
                    flip();
                    Vector2 movement = new Vector2(x , y);
                    rb.velocity = movement * _moveSpeed;
                    animator.SetFloat("velocity" , rb.velocity.magnitude);
                    if( Input.GetKeyDown(KeyCode.Space) )
                    {
                        PlaceBomb();
                    }
                }
            }
            else rb.velocity = Vector2.zero;
        }
    }


    private void flip()
    {
        if(Input.GetKeyDown(KeyCode.A) ) 
        {
            transform.localScale = new Vector3(1 , transform.localScale.y , transform.localScale.z);
        }
        if( Input.GetKeyDown(KeyCode.D) )
        {
            transform.localScale = new Vector3(-1 , transform.localScale.y , transform.localScale.z);
        }
    }

    public void ItemAbility(float speed , float duration  )
    {
        _moveSpeed = speed;
        _itemDuration = duration;
        StartCoroutine("SpeedDuration");
        SoundManager.instance.Play(Collect);
    }

   

    public void ItemProtection(bool protection, float duration )
    {
        Protection = protection;  
        _itemDuration = duration;
        StartCoroutine("ProtectionDuration");
        SoundManager.instance.Play(Collect);
    }

    public void ItemAddBomb(int addBomb ,int addmaxBomb)
    {
        currentBombs = addBomb;
        maxBombs = addmaxBomb;
        
        SoundManager.instance.Play(Collect);
        
    }

    public void ExplosionRangeOptionOne(bool explosion, float duration)
    {
        ExplosionRangeOne = explosion;
        _itemDuration = duration;
        StartCoroutine("ExplosionTwoDuration");
        SoundManager.instance.Play(Collect);
    }
    
    public void ExplosionRangeOptionTwo(bool explosion, float duration)
    {
        ExplosionRangeTwo = explosion;
        _itemDuration = duration;
        StartCoroutine("ExplosionOneDuration");
        SoundManager.instance.Play(Collect);
    }

    private IEnumerator SpeedDuration()
    {
        yield return new WaitForSeconds(_itemDuration);
        _moveSpeed = normalSpeed;
    }

    private IEnumerator ProtectionDuration()
    {
        yield return new WaitForSeconds(_itemDuration);
        Protection = false;
    }
    private IEnumerator ExplosionOneDuration()
    {
        yield return new WaitForSeconds(_itemDuration);
        ExplosionRangeOne = false;
    }
    private IEnumerator ExplosionTwoDuration()
    {
        yield return new WaitForSeconds(_itemDuration);
        ExplosionRangeTwo = false;
    }
    

    [ClientRpc]
    void TeamSelectClientRpc(int _teamNumber )
    {
        teamNumber = _teamNumber;
    }
    [ServerRpc]
    void TeamSelectServerRpc( int _teamNumber )
    {
        TeamSelectClientRpc(_teamNumber);
    }

    private bool afterplay;
    private void spawnpoint()
    {
        if( SceneManager.GetActiveScene().name == "InGame" )
        {
            if( isSpawn == false )
            {
                if( afterplay == false )
                {
                    transform.position = Spawnpoint.instance.spawnpoint[teamNumber].position;
                }
                if( afterplay == true) 
                {
                    int randomInt = UnityEngine.Random.Range(0 , Spawnpoint.instance.spawnpoint.Length);
                    transform.position = Spawnpoint.instance.spawnpoint[randomInt].position; 
                } 
                rb.velocity = Vector2.zero;
                afterplay = true;
            isSpawn = true;
            }
        }
    }

    public void selectTeam(int teamnuumber)
    {
        TeamSelectServerRpc(teamnuumber);
    }

    public void playerDie()
    {
        if (Protection == false)
        {
            SoundManager.instance.Play(Dead);
            dieing = true;
            StartCoroutine(waitRespawn());
            animator.SetBool("die" , true);
        }
        else
        {
            isSpawn = true;
        }
    }

    private IEnumerator waitRespawn()
    {
        yield return new WaitForSeconds(3);
        isSpawn = false;
        dieing = false;
        _moveSpeed = normalSpeed;
        ExplosionRangeOne = false;
        maxBombs = 3;
        currentBombs = maxBombs;
        animator.SetBool("die" , false);
    }
}