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

public class DragonMovement : MonoBehaviour
{
    const bool ROTATE_WITH_FLAP = false;

    [SerializeField] KeyCode FlapKey;
    Rigidbody2D _rigidbody;
    float _flapTime = 0f;
    [SerializeField] float FlapForce = 300f;
    [SerializeField] float FlapLength = .25f;
    Animator _animator;
    bool _inCloud;
    [SerializeField] GameObject _fireballPrefab;
    [SerializeField] GameObject _fireballSpawnPoint;
    [SerializeField] GameObject _coneSpawnPoint;
    [SerializeField] GameObject _flash;
    [SerializeField] string _dragonName;
    [SerializeField] Color _color;
    [SerializeField] List<SpriteRenderer> _ammoGui = new List<SpriteRenderer>();
    [SerializeField] List<SpriteRenderer> _ammoGui2 = new List<SpriteRenderer>();
    [SerializeField] GameObject _ammoNormal;
    [SerializeField] GameObject _ammoGlide;
    const float DIVE_TIME = 0.4f;
    float _buttonHoldTime = 0f;
    ArrayList _ghosts = new ArrayList();

    float _stunTime = 0f;
    float _debugCurSpeed;

    bool _victory = false;

    int _ammo = 0;
    float _speedBoostTime = 0f;
    float _timeToUpdateGhosts = 0f;
    bool _isInDive = false;

    public enum AttackType
    {
        FIREBALL,
        CONE
    }

    [SerializeField] AttackType _attackType = AttackType.FIREBALL;

    const string CONE_NAME = "cone";

    public int Ammo { get => _ammo;
        set {
            _ammo = value;
            for (int i = 0; i < _ammoGui.Count; ++i)
            {
                if (i < _ammo)
                {
                    _ammoGui[i].enabled = true;
                    _ammoGui2[i].enabled = true;
                }
                else
                {
                    _ammoGui[i].enabled = false;
                    _ammoGui2[i].enabled = false;
                }
               
            }
        }
    }

    private void OnTriggerEnter2D(Collider2D collision)
    {

        /*
        GameObject cone = transform.Find(CONE_NAME)?.gameObject;
        if (cone)
        {
            GameObject.Destroy(cone);
        }
        */

        CheckCloudCollision(collision);

        if (collision.CompareTag("Bird"))
        {
            Bird bird = collision.GetComponent<Bird>();
            bird.Eat();
            Ammo = 5;
            _speedBoostTime = 1f;
            _attackType = bird.AttackType;

            if (_attackType == AttackType.FIREBALL)
                ColorizeAmmo(Color.red);
            else
                ColorizeAmmo(Color.green);

        }

        if (collision.CompareTag("FinishLine"))
        {
            Game game = FindObjectOfType<Game>();
            game.Victory(_dragonName, _color);
        }

        if (collision.CompareTag("Lightning"))
        {
            Stun(.4f);
        }

        if (collision.CompareTag("Fireball"))
        {
            Fireball fireball = collision.GetComponent<Fireball>();
            if (fireball != null && fireball.transform.parent != null && fireball.transform.parent.gameObject == this.gameObject)
                return;

            if (fireball.AttackType == AttackType.CONE)
            {
                Stun(.4f);
            }
            else
            {
                Stun(.6f);
            }
        }

        if (collision.CompareTag("Pterodactyl"))
        {
            Stun(.8f);
        }
    }

    void ColorizeAmmo(Color color)
    {
        for (int i = 0; i < _ammoGui.Count; ++i)
        {
            _ammoGui[i].color = color;
            _ammoGui2[i].color = color;
        }
    }

    private void OnTriggerStay2D(Collider2D collision)
    {
        CheckCloudCollision(collision);
    }

    private void CheckCloudCollision(Collider2D collision)
    {
        if (collision.CompareTag("Cloud"))
        {
            Cloud cloud = collision.GetComponent<Cloud>();
            cloud.TriggerLighting(transform.position.x);
        }
    }

    void Stun(float length)
    {
        _isInDive = false;
        _stunTime = length;
        _animator.Play("fall");
        ShowNormalAmmo();
    }

    private void OnTriggerExit2D(Collider2D collision)
    {
        _inCloud = false;
    }
    void Start()
    {
        GameObject ghostContainer = GameObject.Find("Ghosts");
        for (int i = 0; i < 5; ++i)
        {
            GameObject ghost = transform.Find("Ghost" + (i + 1).ToString()).gameObject;
            ghost.transform.parent = ghostContainer.transform;
            _ghosts.Add(ghost);
        }

        Ammo = 0;
        _rigidbody = this.GetComponent<Rigidbody2D>();
        _animator = this.GetComponent<Animator>();

        //Ammo = 5;
        //_attackType = AttackType.CONE;
    }

    private void Update()
    {
        _speedBoostTime -= Time.deltaTime;
        _timeToUpdateGhosts -= Time.deltaTime;

        if (_timeToUpdateGhosts < 0)
        {
            UpdateGhosts();
        }

        if (Input.GetKeyDown(FlapKey) && _stunTime <0f)
        {
            Flap();
            Shoot();
        }

        if (_victory)
        {
            float scale = 8f * Time.deltaTime;
            transform.localScale = transform.localScale + new Vector3(scale, scale, 0f);
        }
    }

    void Flap()
    {
        _flapTime = FlapLength;
        _animator.Play("fly");
        transform.eulerAngles = new Vector3(-45f, transform.eulerAngles.y, transform.eulerAngles.z);
        ShowNormalAmmo();
    }

    void ShowNormalAmmo()
    {
        _ammoNormal.SetActive(true);
        _ammoGlide.SetActive(false);
    }

    void NormalFlight()
    {
        _animator.Play("glide");
        ShowNormalAmmo();
    }

    void Shoot()
    {
        if (Ammo <= 0)
            return;

        Ammo--;

        if (_attackType == AttackType.FIREBALL)
        {
            GameObject.Instantiate(_fireballPrefab, _fireballSpawnPoint.transform.position, Quaternion.identity);
        }
        else if (_attackType == AttackType.CONE)
        {
            GameObject fireball = GameObject.Instantiate(_fireballPrefab, _coneSpawnPoint.transform.position, Quaternion.identity);
            fireball.name = CONE_NAME;
            fireball.GetComponent<Fireball>().AttackType = AttackType.CONE;
            fireball.transform.parent = this.transform;
            Rigidbody2D rigidBody = fireball.AddComponent<Rigidbody2D>();
            rigidBody.isKinematic = true;
        }
    }

    void FixedUpdate()
    {
        if (_flapTime > 0f && _stunTime < 0f)
        {
            _rigidbody.AddForce(new Vector2(0f, FlapForce));
        }
        if (_stunTime > 0f)
        {
            _rigidbody.AddForce(new Vector2(FlapForce * -.05f, FlapForce * -.05f));
            transform.Rotate(Vector3.forward, Time.deltaTime * 1000f);
            if (_flapTime < 0f)
            {
                _flapTime = 0f;
            }
        }
        else if (_flapTime > 0 && ROTATE_WITH_FLAP)
        {
            transform.eulerAngles = new Vector3(0f, 0f, 30f);
        }
        else
        {
            transform.rotation = Quaternion.identity;
        }
        _flapTime -= Time.deltaTime;
        _stunTime -= Time.deltaTime;

        if (Input.GetKey(FlapKey))
        {
            _buttonHoldTime += Time.deltaTime;
        }
        else
        {
            _buttonHoldTime = 0f;
        }

        const float SPEED = .4f;
        float horizontalSpeed = SPEED;


        float verticalSpeed = 0f;

        if (_buttonHoldTime >= DIVE_TIME)
        {
            if (_isInDive == false)
            {
                _isInDive = true;
                _ammoNormal.SetActive(false);
                _ammoGlide.SetActive(true);
                _animator.Play("speedup");
                _rigidbody.velocity = new Vector2(_rigidbody.velocity.x, 0f);
                _rigidbody.AddForce(new Vector2(FlapForce * .1f, FlapForce * -5.5f));
            }
            horizontalSpeed += (_buttonHoldTime) * 3f;
        }
        else
        {
            if (_isInDive)
            {
                NormalFlight();
                _isInDive = false;
            }
        }

  

 
        if (_stunTime > 0f)
        {
            horizontalSpeed = -5f;
        }

        const float MAX_SPEED = SPEED * 2.2f;
        if (horizontalSpeed > MAX_SPEED)
        {
            horizontalSpeed = MAX_SPEED;
        }

        if (_speedBoostTime > 0f)
        {
            horizontalSpeed *= 2.3333f;
        }
        _debugCurSpeed = horizontalSpeed;
        float x = transform.position.x + horizontalSpeed;
        x = Mathf.Max(x, 32);
        transform.position = new Vector3(x, transform.position.y+ verticalSpeed, transform.position.z);

    }

    public void Flash()
    {
        _flash.SetActive(true);
        Invoke("Unflash", .2f);
    }

    public void Unflash()
    {
        _flash.SetActive(false);
    }

    void UpdateGhosts()
    {
        if (_isInDive == false)
        {
            foreach (GameObject ghost in _ghosts)
            {
                ghost.transform.position = new Vector3(-10000, -10000, -10000);
            }
        }
        else
        {
            for (int i = _ghosts.Count - 1; i >= 0; --i)
            {
                GameObject thisGhost = (GameObject)_ghosts[i];
                GameObject prevGhost;
                if (i == 0)
                {
                    prevGhost = this.gameObject;
                }
                else
                    prevGhost = (GameObject)_ghosts[i - 1];

                thisGhost.GetComponent<SpriteRenderer>().sprite = prevGhost.GetComponent<SpriteRenderer>().sprite;
                //thisGhost.scale = prevGhost.scale;

                //make the horizontal offset increase with the amount of time in the glide, capping out at -12, and starting out at -5
                thisGhost.transform.position = new Vector3(prevGhost.transform.position.x - 12f, prevGhost.transform.position.y, prevGhost.transform.position.z + .1f);
                //if (i == 0 && _hidden)
                //{
                    //thisGhost.transform.position = new Vector3(-10000, -10000, 0.1f);
                //}
            }
        }

        _timeToUpdateGhosts = .025f;
    }
}