using UnityEngine;

/// <summary>
/// 材质状态保持器
/// 用于在界面切换、场景重载等情况下保持材质的状态
/// </summary>
public class MaterialStateKeeper : MonoBehaviour
{
    private static MaterialStateKeeper instance;
    
    [Header("状态保持设置")]
    public bool keepBodyAlpha = true;
    public bool keepBrainMaterialState = true;
    public bool autoRestoreOnSceneLoad = true;
    
    // 保存的状态数据
    private float savedBodyAlpha = 0.6f;
    private Color savedBrainColor = Color.green;
    
    // 组件引用
    private ProcessModelMatData materialProcessor;
    private BodyAlphaController alphaController;
    
    public static MaterialStateKeeper Instance
    {
        get
        {
            if (instance == null)
            {
                var go = new GameObject("MaterialStateKeeper");
                instance = go.AddComponent<MaterialStateKeeper>();
                DontDestroyOnLoad(go);
            }
            return instance;
        }
    }
    
    void Awake()
    {
        if (instance == null)
        {
            instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else if (instance != this)
        {
            Destroy(gameObject);
            return;
        }
        
        // 查找组件
        FindComponents();
        
        // 如果启用了自动恢复，则恢复状态
        if (autoRestoreOnSceneLoad)
        {
            // 延迟一帧执行，确保所有组件都已初始化
            StartCoroutine(RestoreStateDelayed());
        }
    }
    
    private void FindComponents()
    {
        materialProcessor = FindObjectOfType<ProcessModelMatData>();
        alphaController = FindObjectOfType<BodyAlphaController>();
    }
    
    private System.Collections.IEnumerator RestoreStateDelayed()
    {
        yield return null; // 等待一帧
        
        // 再次查找组件，以防初始查找时组件还未创建
        if (materialProcessor == null)
        {
            materialProcessor = FindObjectOfType<ProcessModelMatData>();
        }
        
        if (alphaController == null)
        {
            alphaController = FindObjectOfType<BodyAlphaController>();
        }
        
        RestoreStates();
    }
    
    /// <summary>
    /// 保存当前材质状态
    /// </summary>
    public void SaveCurrentStates()
    {
        if (keepBodyAlpha && materialProcessor != null)
        {
            savedBodyAlpha = materialProcessor.GetBodyAlpha();
            Debug.Log($"MaterialStateKeeper: 保存Body透明度状态 {savedBodyAlpha:F2}");
        }
        
        if (keepBrainMaterialState)
        {
            var addMaterialScript = FindObjectOfType<AddMaterialToBrainAndOrgans>();
            if (addMaterialScript != null && addMaterialScript.brainMat != null)
            {
                savedBrainColor = addMaterialScript.brainMat.color;
                Debug.Log($"MaterialStateKeeper: 保存大脑材质颜色状态 {savedBrainColor}");
            }
        }
    }
    
    /// <summary>
    /// 恢复保存的材质状态
    /// </summary>
    public void RestoreStates()
    {
        if (keepBodyAlpha && materialProcessor != null)
        {
            materialProcessor.SetBodyAlpha(savedBodyAlpha);
            
            // 如果有UI控制器，同步UI状态
            if (alphaController != null)
            {
                if (alphaController.alphaSlider != null)
                {
                    alphaController.alphaSlider.value = savedBodyAlpha;
                }
            }
            
            Debug.Log($"MaterialStateKeeper: 恢复Body透明度状态 {savedBodyAlpha:F2}");
        }
        
        if (keepBrainMaterialState)
        {
            var addMaterialScript = FindObjectOfType<AddMaterialToBrainAndOrgans>();
            if (addMaterialScript != null && addMaterialScript.brainMat != null)
            {
                addMaterialScript.brainMat.color = savedBrainColor;
                Debug.Log($"MaterialStateKeeper: 恢复大脑材质颜色状态 {savedBrainColor}");
            }
        }
    }
    
    /// <summary>
    /// 在界面切换前调用此方法保存状态
    /// </summary>
    public void OnUISwitch()
    {
        SaveCurrentStates();
    }
    
    /// <summary>
    /// 在界面切换后调用此方法恢复状态
    /// </summary>
    public void OnUISwitchComplete()
    {
        // 延迟恢复，给新界面时间加载
        StartCoroutine(RestoreStateDelayed());
    }
    
    /// <summary>
    /// 重置所有状态到默认值
    /// </summary>
    public void ResetToDefaults()
    {
        savedBodyAlpha = 0.6f;
        savedBrainColor = Color.green;
        RestoreStates();
    }
    
    /// <summary>
    /// 设置Body透明度并保存状态
    /// </summary>
    /// <param name="alpha">透明度值</param>
    public void SetAndSaveBodyAlpha(float alpha)
    {
        if (materialProcessor != null)
        {
            materialProcessor.SetBodyAlpha(alpha);
            savedBodyAlpha = alpha;
        }
    }
    
    void OnApplicationPause(bool pauseStatus)
    {
        if (pauseStatus)
        {
            SaveCurrentStates();
        }
        else
        {
            RestoreStates();
        }
    }
    
    void OnApplicationFocus(bool hasFocus)
    {
        if (!hasFocus)
        {
            SaveCurrentStates();
        }
        else
        {
            RestoreStates();
        }
    }
}