using UnityEngine;
using DG.Tweening;
using DarkTonic.MasterAudio;

public class Dead : MonoBehaviour
{
    public bool needToFixAngle = true;
    public bool needColliderResize = true;
    public bool isRebootable = true;
    [Header("On River Settings")]
    public bool isOnRiver;
    public float sineLimit;
    public float onRiverFloatSpeed;

    [Header("Textures")]
    public Material evilMat;
    public Material goodMat;
    public Material neutralMat;

    public DeadGender deadGender;
    public DeadType type;
    public GameObject head;
    private Transform hands;
    private GameManager gameManager;
    Vector3 curPosition;
    public Rigidbody deadRigidBody;
    CapsuleCollider capsuleCollider;
    float speed = 0.1f;
    float minDistance = 2f;
    float maxForce = 20f;
    float force = 1f;

    public float timeMod;
    public float speedMod;

    public bool selected;

    public float shotAngle = 45f;

    Vector3 currentPosition;
    bool despawning = false;
    private float randomLookAngleY;

    void OnSpawned()
    {
        InitializeDead();
        lavaHits = 0;
        if (needToFixAngle)
        {
            randomLookAngleY = Random.Range(0f, 360f);
            transform.rotation = Quaternion.Euler(0, randomLookAngleY, 0);
        }
        timeMod = Random.Range(1f, 1000f);
        speedMod = Random.Range(1f, 1f);
    }

    void OnDespawned()
    {
        transform.parent = null;
        despawning = false;
        if (isRebootable)
        {
            RebootType();
        }
    }

    private void Start()
    {
        gameManager = gameManager ?? FindObjectOfType<GameManager>();

        if (!head)
        {
            head = FindObjectOfType<CardboardHead>().gameObject;
        }

        if (!hands)
        {
            hands = head.transform.FindChild("Hands");
        }

        capsuleCollider = capsuleCollider ?? transform.GetComponent<CapsuleCollider>();
        deadRigidBody = deadRigidBody ?? transform.GetComponent<Rigidbody>();
    }

    public Vector3 GetHeadPosition()
    {
        return head.transform.position;
    }


    void Update ()
    {
        if (isOnRiver)
        {
            OnRiverUpdate();
            if (needColliderResize)
            {
                capsuleCollider.radius = 0.6f;
                capsuleCollider.height = 1.6f;
            }
        }
        else
        {
            if (needColliderResize)
            {
                capsuleCollider.radius = 0.3f;
                capsuleCollider.height = 1f;
            }
        }

        if (selected)
        {
            transform.position = Vector3.Lerp(transform.position, hands.position, Time.deltaTime * 4.2f);
        }
    }

    private Transform maleBody;
    private Transform femaleBody;
    private Transform halo;
    private Transform horns;
    public void InitializeDead()
    {
        maleBody = maleBody ?? transform.FindChild("Malechar");
        femaleBody = femaleBody ?? transform.FindChild("FemaleChar");
        halo = halo ?? transform.FindChild("Halo");
        horns = horns ?? transform.FindChild("Horns");
    }

    public void RebootType()
    {
        halo.gameObject.SetActive(true);
        maleBody.gameObject.SetActive(true);
        horns.gameObject.SetActive(true);
        femaleBody.gameObject.SetActive(true);
        transform.localScale = Vector3.one;
    }

    public DeadGender GetGender()
    {
        return deadGender;
    }

    public DeadType GetDeadType()
    {
        return type;
    }

    public void SetDeadType(DeadType type, DeadGender gender)
    {
        var renderer = maleBody.GetComponent<SkinnedMeshRenderer>();
        switch(gender)
        {
            case DeadGender.Male:
                femaleBody.gameObject.SetActive(false);
                maleBody.gameObject.SetActive(true);
                deadGender = DeadGender.Male;
                break;
            case DeadGender.Female:
                maleBody.gameObject.SetActive(false);
                femaleBody.gameObject.SetActive(true);
                renderer = femaleBody.GetComponent<SkinnedMeshRenderer>();
                deadGender = DeadGender.Female;
                break;
        }

        switch(type)
        {
            case DeadType.Good:
                horns.gameObject.SetActive(false);
                renderer.material = goodMat;
                this.type = DeadType.Good;
                break;
            case DeadType.Evil:
                halo.gameObject.SetActive(false);
                renderer.material = evilMat;
                this.type = DeadType.Evil;
                break;
            case DeadType.Neutral:
                halo.gameObject.SetActive(false);
                horns.gameObject.SetActive(false);
                renderer.material = neutralMat;
                this.type = DeadType.Neutral;
                break;
        }
    }

    public bool WasThrown()
    {
        return selected == false && isOnRiver == false;
    }

    public void DragDead ()
    {
        if (gameManager.CanGrabDead())
        {
            gameManager.HighlightTarget(type);
            isOnRiver = false;
            selected = true;
            deadRigidBody.isKinematic = true;
        }
    }

    public float timeToTarget;

    public void ThrowDead ()
    {
        if (selected)
        {
            gameManager.TurnOffHightlight();
            selected = false;
            deadRigidBody.isKinematic = false;
            var target = GetTarget();
            //deadRigidBody.velocity = BallisticVel(target, shotAngle);
            deadRigidBody.AddForce(CalculateBestThrowSpeed(transform.position, target, timeToTarget), ForceMode.VelocityChange);
            deadRigidBody.AddTorque(transform.forward * 25, ForceMode.Impulse);
            PlayScreamingSound(deadGender);
        }
    }

    void PlayScreamingSound (DeadGender gender)
    {
        switch(gender)
        {
            case DeadGender.Male:
                MasterAudio.PlaySound3DFollowTransformAndForget("male_screams", transform);
                break;
            case DeadGender.Female:
                MasterAudio.PlaySound3DFollowTransformAndForget("female_screams", transform);
                break;
        }
    }

    public Vector3 GetTarget()
    {
        RaycastHit hitInfo;
        if (Physics.Raycast(head.transform.position, head.transform.forward, out hitInfo, 100f))
        {
            return hitInfo.point;
        }
        return head.transform.position + (head.transform.forward * 22);
    }

    public bool IsEvil()
    {
        return type == DeadType.Evil;
    }

    public void OnRiverUpdate()
    {
        var recoverRotationSpeed = 1.3f;
        var lookAtSpeed = 4.2f;

        if (needToFixAngle)
        {
            var rotation = lookingAtCamera ?
                Quaternion.Lerp(transform.rotation, Quaternion.LookRotation((head.transform.position - transform.position)), Time.deltaTime * lookAtSpeed) :
                Quaternion.Lerp(transform.rotation, Quaternion.Euler(0, randomLookAngleY, 0), Time.deltaTime * recoverRotationSpeed);

            transform.rotation = rotation;
        }

        var newXPos = transform.position.x + (((gameManager.GetRiverSpeed() * speedMod) * gameManager.GetComboRiverSpeedMultiplier()) * Time.deltaTime);
        transform.position = new Vector3(newXPos , gameManager.GetRiverHeight(), transform.position.z);
    }

    public void Despawn()
    {
        if (despawning) return;
        despawning = true;
        transform.DOScale(0, 0.5f).OnComplete(RealDespawn);
    }

    public void RealDespawn()
    {
        gameManager.GetSpawner().Despawn(transform);
    }

    public int GetCurrentCombo()
    {
        return gameManager.GetCurrentCombo();
    }

    public int ScorePoints(int points, bool firstBounce)
    {
        return gameManager.AddPoints(points, firstBounce);
    }

    private bool lookingAtCamera;
    public void ToggleLookingAtCamera()
    {
        lookingAtCamera = !lookingAtCamera;
    }

    private void OnTriggerEnter(Collider other)
    {
        if (other.name.Equals("DeadDespawner"))
        {
            Despawn();
        }

        if (!selected && !isOnRiver && other.name.Equals("WaterPlane_3200_Tris"))
        {
            if (gameManager != null && gameManager.splashParticle != null) {
                Vector3 splashParticlePos = transform.position;
                splashParticlePos.y -= 0.5f;
                gameManager.splashParticle.transform.position = splashParticlePos;
                gameManager.splashParticle.Play ();
            }
            isOnRiver = true;
            deadRigidBody.isKinematic = true;
        }
    }

    private void OnTriggerExit(Collider other)
    {
        isOnRiver = false;
        deadRigidBody.isKinematic = false;
    }

    public int lavaHitsLimit = 4;
    private int lavaHits = 0;
    private float lavaHitSpeed = 2.25f;

    public void LavaThrow()
    {
        if (lavaHits == lavaHitsLimit)
        {
            deadRigidBody.isKinematic = true;
            transform.DOBlendableMoveBy(Vector3.down * 2, 2f);
            return;
        }
        lavaHits++;
        var direction = Vector3.Normalize(transform.position - head.transform.position);
        direction.y = 0;
        deadRigidBody.velocity = Vector3.zero;
        deadRigidBody.AddForce(CalculateBestThrowSpeed(transform.position, transform.position + (direction * 4), lavaHitSpeed / lavaHits), ForceMode.VelocityChange);
    }

    public void AttachToSpike(Floor spike)
    {
        transform.parent = spike.transform;
        deadRigidBody.isKinematic = true;
    }

    // http://d.gr-assets.com/books/1457364208l/29437996.jpg
    public Vector3 BallisticVel(Vector3 targetPosition, float angle) {
        var dir = targetPosition - transform.position;  // get target direction
        var h = dir.y;  // get height difference
        dir.y = 0;  // retain only the horizontal direction
        var dist = dir.magnitude;  // get horizontal distance
        var a = angle * Mathf.Deg2Rad;  // convert angle to radians
        dir.y = dist* Mathf.Tan(a);  // set dir to the elevation angle
        dist += h / Mathf.Tan(a);  // correct for small height differences
        // calculate the velocity magnitude
        var vel = Mathf.Sqrt(dist * Physics.gravity.magnitude / Mathf.Sin(2 * a));
        return vel * dir.normalized;
    }

    // http://d.gr-assets.com/books/1457364208l/29437996.jpg
    private Vector3 CalculateBestThrowSpeed(Vector3 origin, Vector3 target, float timeToTarget)
    {
        // calculate vectors
        var toTarget = target - origin;
        var toTargetXZ = toTarget;
        toTargetXZ.y = 0;

        // calculate xz and y
        var y = toTarget.y;
        var xz = toTargetXZ.magnitude;

        // calculate starting speeds for xz and y. Physics forumulase deltaX = v0 * t + 1/2 * a * t * t
        // where a is "-gravity" but only on the y plane, and a is 0 in xz plane.
        // so xz = v0xz * t => v0xz = xz / t
        // and y = v0y * t - 1/2 * gravity * t * t => v0y * t = y + 1/2 * gravity * t * t => v0y = y / t + 1/2 * gravity * t
        var t = timeToTarget;
        var v0y = y / t + 0.5f * Physics.gravity.magnitude * t;
        var v0xz = xz / t;

        // create result vector for calculated starting speeds
        var result = toTargetXZ.normalized;        // get direction of xz but with magnitude 1
        result *= v0xz;                                // set magnitude of xz to v0xz (starting speed in xz plane)
        result.y = v0y;                                // set y to v0y (starting speed of y plane)

        return result;
    }

    public void CharonScream ()
    {
        MasterAudio.PlaySound3DFollowTransformAndForget("male_screams", transform, 1, 0.78f);
    }

    public void ThrownBoat ()
    {
        MasterAudio.PlaySound3DFollowTransformAndForget("whoosh", transform);
    }
}

public enum DeadGender
{
    Male,
    Female,
    NonBinary
}

public enum DeadType
{
    Mythological,
    Evil,
    Good,
    Neutral
}

public enum DeadState
{
    Drowning,
    BeingHeld,
    Thrown
}