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

public class GhostScript : MonoBehaviour
{
    private Vector2 teleportPoint;
    private float distanceBetweenPlayerAndTeleportPoint;
    private bool hasBeenReset;
    private bool isNotAttacking;
    public float attackSpeed = 7f;
    private Vector2 attackDirection;
    public int timesTeleported;
    public int timesReset;
    private int teleportLimit;
    private int resetLimit;
    private SpriteRenderer spriteRend;
    private float xPositionDifference;
    private bool facingRight = true;
    public float moveSpeed = 1f;
    private Rigidbody2D rb;
    private Rigidbody2D prb;
    private GameObject player;
    private GameObject ghost;
    private GameObject fleeObject;
    private Vector2 moveDirection;
    private Vector2 fleeDirection;
    public float distanceBetweenPlayerAndGhost;
    private bool hasStartedTeleporting;
    public enum SState
    {
        isChasingPlayer,
        isTeleporting,
        isAttacking,
        isLeaving
    }
    public SState ghostState;

    void Start()
    {
        hasBeenReset = true;
        isNotAttacking = true;
        spriteRend = GetComponent<SpriteRenderer>();
        timesTeleported = 0;
        timesReset = 0;
        hasStartedTeleporting = false;
        ghost = GameObject.Find("Ghost");
        player = GameObject.Find("player_sprite");
        fleeObject = GameObject.Find("death_platform");
        prb = player.GetComponent<Rigidbody2D>();
        ghostState = SState.isChasingPlayer;
        rb = GetComponent<Rigidbody2D>();
    }

    void FixedUpdate()
    {
        xPositionDifference = prb.position.x - rb.position.x;

        if (facingRight == false && xPositionDifference > 0)
        {
            Flip();
        }
        else if (facingRight == true && xPositionDifference < 0)
        {
            Flip();
        }
    }

    void Update()
    {
        teleportPoint = new Vector2(Random.Range(-5.5f, 5.5f), Random.Range(-4.5f, 4.2f));
        distanceBetweenPlayerAndTeleportPoint = Vector3.Distance(teleportPoint, player.transform.position);
        resetLimit = (Random.Range(1, 1));
        teleportLimit = (Random.Range(3, 10));
        distanceBetweenPlayerAndGhost = Vector3.Distance(player.transform.position, ghost.transform.position);

        if (distanceBetweenPlayerAndTeleportPoint <= 5f)
        {
            teleportPoint = new Vector2(Random.Range(-5.5f, 5.5f), Random.Range(-4.5f, 4.2f));
        }

        if (ghostState == SState.isChasingPlayer)
        {
            moveDirection = (player.transform.position - transform.position).normalized * moveSpeed;
            moveDirection = moveDirection.normalized;
            rb.velocity = new Vector2(moveDirection.x * moveSpeed / 5, moveDirection.y * moveSpeed / 5);
        }

        if (ghostState == SState.isChasingPlayer && distanceBetweenPlayerAndGhost <= 2f && hasStartedTeleporting == false)
        {
            hasStartedTeleporting = true;
            ghostState = SState.isTeleporting;
            StartCoroutine(fadeOut());
            StartCoroutine(teleportCoroutine());
            StartCoroutine(colliderController());
        }

        if (ghostState == SState.isTeleporting)
        {
            rb.velocity = new Vector2(0, 0);
        }

        if (ghostState == SState.isAttacking && isNotAttacking == true)
        {
            isNotAttacking = false;
            StartCoroutine(attackCoroutine());
        }

        if (ghostState == SState.isAttacking && hasBeenReset == true)
        {
            if (ghost.transform.position.x <= -5.4f || ghost.transform.position.x >= 5.6f || ghost.transform.position.y <= -4.4f || ghost.transform.position.y >= 4.3f)
            {
                hasBeenReset = false;
                StartCoroutine(resetCoroutine());
            }
        }

        if (ghostState == SState.isLeaving)
        {
            if (ghost.transform.position.x <= -5.4f || ghost.transform.position.x >= 5.6f || ghost.transform.position.y <= -4.4f || ghost.transform.position.y >= 4.3f)
            {
                StartCoroutine(selfDestructCoroutine());
            }
            else
            {

            }
        }
    }

    void Flip()
    {
        facingRight = !facingRight;
        Vector3 Scaler = transform.localScale;
        Scaler.x *= -1;
        transform.localScale = Scaler;
    }

    IEnumerator fadeOut()
    {
        if (timesTeleported <= teleportLimit)
        {
            for (float f = 1f; f >= -0.10f; f -= 0.10f)
            {
                Color c = spriteRend.material.color;
                c.a = f;
                spriteRend.material.color = c;
                yield return new WaitForSeconds(0.05f);
                StartCoroutine(fadeIn());
            }
        }
        else
        {

        }
    }

    IEnumerator fadeIn()
    {
        for (float f = 0.10f; f <= 1; f += 0.10f)
        {
            Color c = spriteRend.material.color;
            c.a = f;
            spriteRend.material.color = c;
            yield return new WaitForSeconds(0.05f);
        }
    }

    IEnumerator teleportCoroutine()
    {
        if (timesTeleported <= teleportLimit)
        {
            timesTeleported += 1;
            yield return new WaitForSeconds(0.5f);
            rb.position = teleportPoint;
            yield return new WaitForSeconds(0.5f);
            StartCoroutine(fadeOut());
            StartCoroutine(teleportCoroutine());
            StartCoroutine(colliderController());
        }
        else
        {
            ghostState = SState.isAttacking;
        }
    }

    IEnumerator colliderController()
    {
        GetComponent<PolygonCollider2D>().enabled = false;
        yield return new WaitForSeconds(0.8f);
        GetComponent<PolygonCollider2D>().enabled = true;
        yield return new WaitForSeconds(0.1f);
        GetComponent<PolygonCollider2D>().enabled = false;
    }

    IEnumerator attackCoroutine()
    {
        GetComponent<PolygonCollider2D>().enabled = true;
        yield return new WaitForSeconds(1.0f);
        GetComponent<PolygonCollider2D>().enabled = true;
        attackDirection = (player.transform.position - transform.position) * attackSpeed;
        attackDirection = attackDirection.normalized;
        rb.velocity = new Vector2(attackDirection.x * attackSpeed, attackDirection.y * attackSpeed);
    }

    IEnumerator resetCoroutine()
    {
        if (timesReset <= resetLimit)
        {
            timesReset += 1;
            timesTeleported = 0;
            isNotAttacking = true;
            ghostState = SState.isTeleporting;
            StartCoroutine(fadeOut());
            StartCoroutine(teleportCoroutine());
            StartCoroutine(colliderController());
            yield return new WaitForSeconds(0.05f);
            hasBeenReset = true;
        }
        else
        {
            ghostState = SState.isLeaving;
        }
    }

    IEnumerator selfDestructCoroutine()
    {
        rb.velocity = new Vector2(0, 0);
        yield return new WaitForSeconds(1.0f);
        fleeDirection = (fleeObject.transform.position - transform.position).normalized * moveSpeed;
        fleeDirection = fleeDirection.normalized;
        rb.velocity = new Vector2(fleeDirection.x * moveSpeed, fleeDirection.y * moveSpeed);
        Destroy(gameObject, 3f);
    }
}