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

public class DismembermentHandler : MonoBehaviour
{

    // General Variables
    private HealthManager healthHandler;
    private Animator animator;
    public AudioSource audio_source;
    public GameObject root;
    body_parts index;

    public AudioClip[] global_hit_sounds;

    [System.Serializable]
    public class dismember_part
    {
        public GameObject effect;
        public Transform spawn;
        public bool get_spawn_rotation;
        public bool follow_spawn;
        public AudioClip[] dismemberment_sounds;
    };

    [System.Serializable]
    public class dismember_effect
    {
        public dismember_part[] parts;
        public float chance;
    };

    [System.Serializable]
    public class dismember_effects
    {
        public dismember_effect[] effects;
        public GameObject[] dependency_part_array;
    }

    [System.Serializable]
    public class body_parts
    {

        public string part_name;
        public bool is_dettached = false;
        public GameObject[] attached_part_array;
        public Collider[] part_collider_array;
        public float damage_mulitplier;
        public float damage_to_dismemberment;
        public dismember_effects[] dismember_effects_array;
        public RuntimeAnimatorController animation;
        public string[] dependencies;

    }

    public body_parts[] body_parts_array;

    private void Start()
    {

        healthHandler = GetComponent<HealthManager>();
        animator = GetComponent<Animator>();

    }

    public Transform getChild(Transform _source, string _name)
    {
        if (_source.name == _name)
        {
            return _source;
        }
        foreach (Transform _i in _source.transform)
        {
            Transform _child = getChild(_i, _name);
            if (_child)
                return _child;
        }
        return null;
    }
    public void inherit( GameObject _target,GameObject _source )
    {
        Transform _part = getChild(_source.transform,_target.name);
        if (_part)
        {
            _target.transform.localPosition = _part.localPosition;
            _target.transform.localRotation = _part.localRotation;
            _target.transform.localScale = _part.localScale;
        }

        foreach (Transform _i in _target.transform)
        {
            inherit(_i.gameObject, _source);
        }
    }

    public void dismember(string body_part, float damage, bool dependency)
    {

        foreach (var i in body_parts_array) if (i.part_name == body_part) index = i;

        if (!dependency)
        {

            healthHandler.applyDamage(damage, index != null ? index.damage_mulitplier : 1F);
            audio_source.PlayOneShot(global_hit_sounds[Random.Range(0, global_hit_sounds.Length)]);

        }

        if (index != null)
        {

            index.damage_to_dismemberment -= damage * index.damage_mulitplier;

            if (index.is_dettached) return;
            if (index.damage_to_dismemberment > 0 && !dependency) return;

            index.is_dettached = true;

            Dictionary<string, bool> state_part_array = new Dictionary<string, bool>();

            foreach (var j in index.attached_part_array)
            {
                state_part_array[j.name] = j.active;
                j.SetActive(false);
            }

            foreach (var j in index.part_collider_array)
            {
                j.enabled = false;
            }

            if (index.animation != null && !healthHandler.is_dead) animator.runtimeAnimatorController = index.animation;

            var largest_index = -1;
            var largest_size = 0;

            var i = 0;
            for (i = 0; i < index.dismember_effects_array.Length; i++)
            {
                var element = index.dismember_effects_array[i];

                var j = 0;
                for (j = 0; j < element.dependency_part_array.Length; j++)
                {
                    var name = element.dependency_part_array[j].name;
                    if (state_part_array[name] == false)
                    {
                        break;
                    }
                }

                if (j == element.dependency_part_array.Length)
                {
                    if (element.dependency_part_array.Length > largest_size)
                    {
                        largest_index = i;
                        largest_size = j;
                    }
                }
            }

            //Dictionary<string, bool> state_part_array = new Dictionary<string, bool>();
            //ArrayList candidates = new ArrayList();

            if (largest_index > -1)
            {
                var effects = index.dismember_effects_array[largest_index].effects;

                float chance_sum = 0, chance_floor = 0;
                foreach (var effect in effects)
                {
                    chance_sum += effect.chance;
                }

                if (0 == chance_sum)
                    chance_sum = 1;

                var r = Random.RandomRange(0.0f, 1.0f);
                foreach (var effect in effects)
                {
                    chance_floor += effect.chance / chance_sum;
                    if (chance_floor >= r)
                    {
                        foreach (var part in effect.parts)
                        {
                            GameObject temp_object = Instantiate(part.effect, part.spawn.position, part.get_spawn_rotation ? part.spawn.rotation : part.effect.transform.rotation);
                            if (part.follow_spawn)
                            {
                                temp_object.transform.SetParent(part.spawn, true);
                            }
                            if (temp_object)
                            {
                                inherit(temp_object, root);
                            }
                            if ( part.dismemberment_sounds.Length > 0)
                            {
                                audio_source.PlayOneShot(part.dismemberment_sounds[Random.Range(0, part.dismemberment_sounds.Length)]);
                            }
                        }
                        break;
                    }
                }

            }

            if (!dependency)
            {

                healthHandler.applyDamage(damage, index.damage_mulitplier);

            }

            foreach (var s in index.dependencies) dismember(s, 0F, true);

        }

    }

}