using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Rendering.Universal;
using UnityEngine.Rendering;
using HorizonBasedAmbientOcclusion.Universal;
using System.Collections.Generic;
using petabytes.LTCLight;
using Unity.VisualScripting;
using TMPro;
using JetBrains.Annotations;
using MS_Outline;

public class SelectLight : MonoBehaviour
{
    public Slider _SunPositionSlider;
    public Slider _RoomShadowSlider;
    public Slider _SunIntensitySlider;
    public Slider _ShadowLightsSlider;
    public Slider _GlowLightsSlider;
    public Slider _PointsLightSlider;
    public Slider _CeilingBritenessSlider;
    public Slider _EnvironementSlider;
    public Slider _ReflectionSlider;
    public Slider _SaturationSlider;
    public Slider _ContrastSlider;

    public GameObject SpotLightsContainer;
    public GameObject SpotCeilingBriteness;
    public GameObject InteriorPanel;
    public GameObject ExteriorPanel;

    public void StarInteriorPanel()
    {
        DOIT.CloseALLPNL();
        InteriorPanel.SetActive(true);
        InteriorPanel.transform.localPosition=new(388,0,0);        
        GameObject Setting=Get.o2("InteriorLights","Setting");
        Set.AlphaAllChildwithValue(Setting,_G.HD,0.5f);

    }
    public void StarExteriorPanel()
    {
        DOIT.CloseALLPNL();
        ExteriorPanel.SetActive(true);
        ExteriorPanel.transform.localPosition=new(388,0,0);  
    } 
    public static void Set_All_Lights_to_Scene() {

        //print("_G.HD====="+_G.HD);

        //SUN
        Set_Sun_Position();
        Set_Sun_Light_Intensity();

        Get.o2("LIGHTS", "ONOFF").SetActive(true);
        GameObject SpotLightsContainer=Get.o2("LIGHTS/ONOFF", "SpotWallContainer");
        GameObject SpotCeilingBriteness=Get.o2("LIGHTS/ONOFF", "SpotCeiling");

        //Setting All 
        SetEnvironent();
        SetOcclusion();
        SetSceneLights(SpotLightsContainer);
        SetRoomShadow(SpotLightsContainer);
        SetCeilingBriteness(SpotCeilingBriteness);
        SetGlowBloom();
        SetReflection();
        SetSaturation();
        SetContrast();
        SetSliders();

    }

    public static void SetSliders()
    {
        Get.o2("Canvas", "Panel_SCENE").SetActive(true);
        Get.o2("Panel_SCENE", "PNL").SetActive(true);
        Get.o2("Panel_SCENE/PNL", "SUNpnl").SetActive(true);
        Get.o2("Panel_SCENE/PNL", "InteriorLights").SetActive(true);
        GameObject SettingsContainer=Get.o2("Panel_SCENE/PNL/InteriorLights", "Setting");
        GameObject EnvironementSlider=Get.o2("Panel_SCENE/PNL/InteriorLights", "SliderEnvironment");
        GameObject SunPanel=Get.o2("Panel_SCENE/PNL/SUNpnl", "Ambiance");

        //Sun
        SunPanel.transform.Find("SliderSunPosition").transform.GetComponent<Slider>().value=_G.LightSetting["SunPosition"] ;
        SunPanel.transform.Find("SliderSunIntensity").transform.GetComponent<Slider>().value=_G.LightSetting["SunIntensity"] ;
        Get.o2("Panel_SCENE/PNL", "SUNpnl").SetActive(false);

        //Environement
        EnvironementSlider.GetComponent<Slider>().value=_G.LightSetting["Environment"] ;

        //Setting HD
        SettingsContainer.transform.Find("SliderOcclusion").transform.GetComponent<Slider>().value=_G.LightSetting["Occlusion"] ;
        SettingsContainer.transform.Find("SliderLights").transform.GetComponent<Slider>().value=_G.LightSetting["SceneLights"] ;
        SettingsContainer.transform.Find("SliderShadow").transform.GetComponent<Slider>().value=_G.LightSetting["ShadowRoom"] ;
        SettingsContainer.transform.Find("SliderCeiling").transform.GetComponent<Slider>().value=_G.LightSetting["CeilingIntensity"] ;
        SettingsContainer.transform.Find("SliderBloom").transform.GetComponent<Slider>().value=_G.LightSetting["GlowBloom"] ;
        SettingsContainer.transform.Find("SliderReflexion").transform.GetComponent<Slider>().value=_G.LightSetting["Reflection"] ;
        SettingsContainer.transform.Find("SlideSaturation").transform.GetComponent<Slider>().value=_G.LightSetting["Saturation"] ;
        SettingsContainer.transform.Find("Contrast").transform.GetComponent<Slider>().value=_G.LightSetting["Contrast"] ;

        
        Get.o2("Panel_SCENE/PNL", "InteriorLights").SetActive(false);
    }
 
    //--------------------------------------------------------------------------------------------------------
    //-----------------SETTING------------------------------------------------------------------------
    //--------------------------------------------------------------------------------------------------------

    //Sun Position
    public void Sun_Position()
    {
        _G.LightSetting["SunPosition"]=_SunPositionSlider.value;
        Set_Sun_Position();
    }
    public static void Set_Sun_Position(){
        GameObject  Sun = ReflectionProbesUpdater.DirectionalLight;
        Sun.transform.eulerAngles = new(30,_G.LightSetting["SunPosition"],0);
    }
    
    //Sun Control
    public void Sun_Light_Intensity(){
        _G.LightSetting["SunIntensity"]=_SunIntensitySlider.value;
        Set_Sun_Light_Intensity();
    }
    public static void Set_Sun_Light_Intensity(){
        bool isSunOn=Get.o2("LIGHTS","ONOFF").activeInHierarchy;
        Get.o2("LIGHTS","ONOFF").SetActive(true);
        GameObject Sun=Get.o2("LIGHTS/ONOFF","Sun");
        if(Sun!=null)Sun.GetComponent<Light>().intensity=_G.LightSetting["SunIntensity"];
        Get.o2("LIGHTS","ONOFF").SetActive(isSunOn);
    }

    //Environent
    public void Environent(){
        float Intensity = _EnvironementSlider.value;
        if(!_G.HD)Intensity*=1.1111f;
        _G.LightSetting["Environment"]=Intensity;
        SetEnvironent();
    }
    public static void SetEnvironent()
    {
        //RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Flat;
        float sliderValue=_G.LightSetting["Environment"];
        if(_G.HD)sliderValue*=0.8f;
        RenderSettings.ambientLight = new Color(sliderValue / 255f, sliderValue / 255f, sliderValue / 255f);
        float intensityMultiplier=sliderValue/120;
        Color currentColor = RenderSettings.ambientLight;
        RenderSettings.ambientLight = currentColor * intensityMultiplier;
    }

    //Occlusion
    public void Oclussion()
    {
        _G.LightSetting["Occlusion"] = _RoomShadowSlider.value;
        SetOcclusion();
    }
    public static void SetOcclusion()
    {
        float value= _G.LightSetting["Occlusion"];
        Volume volume = Get.o1("Global Volume").GetComponent<Volume>();
        volume.profile.TryGet(out HorizonBasedAmbientOcclusion.Universal.HBAO hbao);
        hbao.SetAoRadius( value); 
        _G.LightSetting["ShadowRoomIntensity"]=value;
    }

    //Scene Lights
    public void SceneLights()
    {
        _G.LightSetting["SceneLights"] = _PointsLightSlider.value;
        SetSceneLights(SpotLightsContainer);
    }
    public static void SetSceneLights(GameObject SpotLightsContainer){
        foreach(Transform Spot in SpotLightsContainer.transform){
            Spot.GetComponent<Light>().intensity = _G.LightSetting["SceneLights"];
        }
    }

    //Room Shadow
    public void RoomShadow(){
        _G.LightSetting["ShadowRoom"]=_ShadowLightsSlider.value;            
        SetRoomShadow(SpotLightsContainer);
    }
    public static void SetRoomShadow(GameObject SpotLightsContainer){
        foreach(Transform Spot in SpotLightsContainer.transform){
            Spot.GetComponent<Light>().shadowStrength= _G.LightSetting["ShadowRoom"];
        }
    }

    //Ceiling Light
    public void CeilingBriteness(){
        _G.LightSetting["CeilingIntensity"]=_CeilingBritenessSlider.value;
        SetCeilingBriteness(SpotCeilingBriteness);
    }
    public static void SetCeilingBriteness(GameObject SpotCeilingBriteness){
        SpotCeilingBriteness.GetComponent<Light>().intensity=_G.LightSetting["CeilingIntensity"] ;
    }

    //BLOOM
    public void GlowBloom()
    {
        _G.LightSetting["GlowBloom"]=_GlowLightsSlider.value; 
        SetGlowBloom();
    }
    public static void SetGlowBloom()
    {
        Volume volume = Get.o1("Global Volume").GetComponent<Volume>();
        volume.profile.TryGet(out Bloom bloom);
        bloom.intensity.value=_G.LightSetting["GlowBloom"]; 
        GameObject[] Glow = GameObject.FindGameObjectsWithTag("Glow");
        foreach(GameObject GlowG in Glow)
        {
           GlowG.GetComponent<GlowOutlineTarget>().GlowIntensity=_G.LightSetting["GlowBloom"]*0.25f;
        }

    }

    //REFLECTION
    public void Reflection()
    {
        _G.LightSetting["Reflection"]=_ReflectionSlider.value;
        SetReflection();
    }
    public static void SetReflection()
    {
        Get.o2("LIGHTS","Reflection Probe").GetComponent<ReflectionProbe>().intensity=_G.LightSetting["Reflection"];
    }

    //SATURATION
    public void Saturation()
    {
        _G.LightSetting["Saturation"]=_SaturationSlider.value; 
        SetSaturation();
    }
    public static void SetSaturation()
    {
        Volume volume = Get.o1("Global Volume").GetComponent<Volume>();
        volume.profile.TryGet(out ColorAdjustments adjustments);
        adjustments.saturation.value = _G.LightSetting["Saturation"];
    }

    //CONTRAST
    public void Contrast()
    {
        _G.LightSetting["Contrast"]=_ContrastSlider.value; 
        SetContrast();
    }
    public static void SetContrast()
    {
        //print("Contrat======"+_G.LightSetting["Contrast"]);
        Volume volume = Get.o1("Global Volume").GetComponent<Volume>();
        volume.profile.TryGet(out ColorAdjustments adjustments);
        adjustments.contrast.value = _G.LightSetting["Contrast"];
    }


    //--------------------------------------------------------------------------------------------------------
    //-----------------RESET LIGHTS------------------------------------------------------------------------
    //--------------------------------------------------------------------------------------------------------

    // public static void AddSpotLight(GameObject Base,float H,string C40){
    //     //print("C40=====" + C40);
    //     string[] c40 = C40.Split("_");
    //     float Intensity = 15;
    //     if (c40.Length > 1) { Intensity = float.Parse(c40[1]); };
    //     GameObject lightGameObject = new ("SpotLight");
    //     lightGameObject.AddComponent<Light>();
    //     lightGameObject.GetComponent<Light>().type=0;
    //     lightGameObject.transform.position = new Vector3(0, -H*0.5f+0, 0);
    //     lightGameObject.transform.eulerAngles = new Vector3(90, 0, 0);
    //     lightGameObject.transform.SetParent(Base.transform);
    //     lightGameObject.GetComponent<Light>().intensity=Intensity;
    //     lightGameObject.GetComponent<Light>().range=50;
    //     lightGameObject.GetComponent<Light>().innerSpotAngle=100;
    //     lightGameObject.GetComponent<Light>().spotAngle=179;
    //     bool isLightOn=false;
    //     if(c40[0]=="On")isLightOn=true;
    //     lightGameObject.GetComponent<Light>().enabled=isLightOn;
    //     lightGameObject.tag="Lights_Wall_Cabinet";
    //     lightGameObject.SetActive(false);
    // }
    public static bool OpenOnScene()
    {
        foreach(Transform O in SceneModeManager.Scene)
        {
            if (O.name.Length > 4)
            {
                string objectType = O.name[..4];
                switch (objectType)
                {
                    case "open":return true;
                    //case "door":return true;
                    case "pati":return true;
                    case "wind":return true;
                }
            }
        }
        return false;
    }
    public void NeonToggle(bool isNeonOn)
    {
        Get.o2(SceneModeManager.Selected.name,"Neon").SetActive(isNeonOn);
    }


}