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

public class VenusExosphereEffects : MonoBehaviour
{
    [Header("Витікання атмосфери")]
    public Material leakMaterial;
    public float planetRadius = 32.05f;

    [Range(0f, 1f)]
    public float exosphereLevel = 1f;

    private ParticleSystem leakSystem;
    private bool deadApplied = false;

    void Awake()
    {
        enabled = false;
    }

    public void InitState()
    {
        exosphereLevel = 1f;
        deadApplied = false;

        if (leakSystem == null)
            CreateLeakEffect();

        if (leakSystem != null)
        {
            leakSystem.gameObject.SetActive(true);
            leakSystem.Stop();
            var emission = leakSystem.emission;
            emission.rateOverTime = 0f;
        }
    }

    void CreateLeakEffect()
    {
        GameObject obj = new GameObject("VenusAtmosphericLeak");
        obj.transform.parent = null;
        obj.transform.position = transform.position;

        leakSystem = obj.AddComponent<ParticleSystem>();

        var main = leakSystem.main;
        main.loop = true;
        main.playOnAwake = false;
        main.maxParticles = 50000;
        main.startLifetime = new ParticleSystem.MinMaxCurve(8f, 15f);
        main.startSpeed = new ParticleSystem.MinMaxCurve(10f, 30f);
        main.startSize = new ParticleSystem.MinMaxCurve(1.2f, 1.8f);
        main.gravityModifier = 0f;
        main.startColor = new ParticleSystem.MinMaxGradient(
            new Color(1f, 0.7f, 0.1f, 1f),
            new Color(0.9f, 0.5f, 0.05f, 0.9f)
        );
        main.simulationSpace = ParticleSystemSimulationSpace.World;

        var emission = leakSystem.emission;
        emission.rateOverTime = 0f;

        var shape = leakSystem.shape;
        shape.enabled = true;
        shape.shapeType = ParticleSystemShapeType.Sphere;
        shape.radius = planetRadius;
        shape.radiusThickness = 0f;

        var velocityOverLifetime = leakSystem.velocityOverLifetime;
        velocityOverLifetime.enabled = true;
        velocityOverLifetime.radial = new ParticleSystem.MinMaxCurve(15f);
        velocityOverLifetime.space = ParticleSystemSimulationSpace.Local;

        var colorOverLifetime = leakSystem.colorOverLifetime;
        colorOverLifetime.enabled = true;
        Gradient gradient = new Gradient();
        gradient.SetKeys(
            new GradientColorKey[] {
                new GradientColorKey(new Color(1f, 0.8f, 0.2f), 0f),
                new GradientColorKey(new Color(0.9f, 0.5f, 0.1f), 0.5f),
                new GradientColorKey(new Color(0.6f, 0.2f, 0.0f), 1f)
            },
            new GradientAlphaKey[] {
                new GradientAlphaKey(1f, 0f),
                new GradientAlphaKey(0.6f, 0.5f),
                new GradientAlphaKey(0f, 1f)
            }
        );
        colorOverLifetime.color = new ParticleSystem.MinMaxGradient(gradient);

        var sizeOverLifetime = leakSystem.sizeOverLifetime;
        sizeOverLifetime.enabled = true;
        AnimationCurve sizeCurve = new AnimationCurve();
        sizeCurve.AddKey(0f, 0f);
        sizeCurve.AddKey(0.1f, 1f);
        sizeCurve.AddKey(0.8f, 0.8f);
        sizeCurve.AddKey(1f, 0f);
        sizeOverLifetime.size = new ParticleSystem.MinMaxCurve(1f, sizeCurve);

        var psRenderer = leakSystem.GetComponent<ParticleSystemRenderer>();
        psRenderer.renderMode = ParticleSystemRenderMode.Billboard;
        psRenderer.sortingFudge = 5f;
        if (leakMaterial != null)
            psRenderer.material = leakMaterial;
    }

    void UpdateLeak()
    {
        if (leakSystem == null) return;

        if (exosphereLevel > 0f && deadApplied)
            deadApplied = false;

        var emission = leakSystem.emission;

        if (exosphereLevel <= 0f)
        {
            emission.rateOverTime = 0f;
            leakSystem.Stop();
            ApplyDeadState();
            return;
        }

        leakSystem.gameObject.SetActive(true);

        if (exosphereLevel <= 0.7f)
        {
            float t = Mathf.InverseLerp(0.7f, 0f, exosphereLevel);
            emission.rateOverTime = Mathf.Lerp(100f, 5000f, t);
            if (!leakSystem.isPlaying)
                leakSystem.Play();
        }
        else
        {
            emission.rateOverTime = 0f;
        }
    }

    void ApplyDeadState()
    {
        if (deadApplied) return;
        deadApplied = true;

        var venusDeath = GameManager.Instance.GetCurrentPlanet()
            .planetTransform?.GetComponent<VenusDeath>();
        if (venusDeath != null) venusDeath.ApplyDeadColors();

        var atmo = GameManager.Instance.GetCurrentPlanet().atmosphereSystem;
        if (atmo == null) return;

        var venusAtmo = atmo.GetComponentInChildren<VenusAtmosphereSystem>(true);
        if (venusAtmo != null)
        {
            venusAtmo.SetLayerActive("Layer_Troposphere", false);
            venusAtmo.SetLayerActive("Layer_Mesosphere", false);
            venusAtmo.SetLayerActive("Layer_Thermosphere", false);
            venusAtmo.SetLayerActive("Layer_Exosphere", false);
        }
    }

    void Update()
    {
        if (!Application.isPlaying) return;
        UpdateLeak();
    }

    public void CleanUp()
    {
        if (leakSystem != null)
        {
            var emission = leakSystem.emission;
            emission.rateOverTime = 0f;
            leakSystem.Stop();
        }

        deadApplied = false;
        enabled = false;
    }
}