using UnityEngine;
using UnityEngine.UI;
using TMPro;

public class TextQualityOptimizer : MonoBehaviour
{
    [Header("文字质量优化设置")]
    [SerializeField] private bool enableHighDPI = true; // 启用高DPI支持
    [SerializeField] private float resolutionScale = 2.0f; // 分辨率缩放
    [SerializeField] private bool usePixelPerfect = true; // 像素完美模式
    [SerializeField] private FilterMode preferredFilterMode = FilterMode.Bilinear; // 首选过滤模式
    [SerializeField] private bool enableMSAA = true; // 启用多重采样抗锯齿
    
    [Header("字体优化")]
    [SerializeField] private bool useBitmapFont = false; // 使用位图字体
    [SerializeField] private int fontTextureSize = 1024; // 字体纹理大小
    [SerializeField] private bool enableFontSmoothing = true; // 启用字体平滑
    
    [Header("Canvas优化")]
    [SerializeField] private bool useRenderTexture = false; // 使用渲染纹理
    [SerializeField] private int renderTextureWidth = 2048; // 渲染纹理宽度
    [SerializeField] private int renderTextureHeight = 1024; // 渲染纹理高度
    [SerializeField] private bool enableCanvasOptimization = true; // 启用Canvas优化
    
    private Camera mainCamera;
    private Canvas[] sceneCanvases;
    
    void Start()
    {
        mainCamera = Camera.main;
        if (mainCamera == null)
        {
            mainCamera = FindObjectOfType<Camera>();
        }
        
        // 应用质量设置
        ApplyQualitySettings();
        
        // 优化场景中的Canvas
        OptimizeSceneCanvases();
    }
    
    [ContextMenu("应用质量优化")]
    public void ApplyQualitySettings()
    {
        // 设置高DPI支持
        if (enableHighDPI)
        {
            Screen.SetResolution(Screen.currentResolution.width, Screen.currentResolution.height, true);
        }
        
        // 设置抗锯齿
        if (enableMSAA)
        {
            QualitySettings.antiAliasing = 4; // 4x MSAA
        }
        
        // 设置纹理质量
        QualitySettings.masterTextureLimit = 0; // 最高质量
        QualitySettings.anisotropicFiltering = AnisotropicFiltering.ForceEnable;
        
        Debug.Log("已应用文字质量优化设置");
    }
    
    [ContextMenu("优化场景Canvas")]
    public void OptimizeSceneCanvases()
    {
        sceneCanvases = FindObjectsOfType<Canvas>();
        
        foreach (Canvas canvas in sceneCanvases)
        {
            OptimizeCanvas(canvas);
        }
        
        Debug.Log($"已优化 {sceneCanvases.Length} 个Canvas");
    }
    
    private void OptimizeCanvas(Canvas canvas)
    {
        if (!enableCanvasOptimization) return;
        
        // 优化CanvasScaler
        CanvasScaler scaler = canvas.GetComponent<CanvasScaler>();
        if (scaler != null)
        {
            scaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
            scaler.referenceResolution = new Vector2(1920, 1080);
            scaler.screenMatchMode = CanvasScaler.ScreenMatchMode.MatchWidthOrHeight;
            scaler.matchWidthOrHeight = 0.5f;
        }
        
        // 优化Canvas设置
        canvas.additionalShaderChannels |= AdditionalCanvasShaderChannels.Normal;
        canvas.additionalShaderChannels |= AdditionalCanvasShaderChannels.Tangent;
        
        // 优化所有Text组件
        Text[] texts = canvas.GetComponentsInChildren<Text>();
        foreach (Text text in texts)
        {
            OptimizeText(text);
        }
        
        // 优化所有TextMeshPro组件
        TextMeshProUGUI[] tmpTexts = canvas.GetComponentsInChildren<TextMeshProUGUI>();
        foreach (TextMeshProUGUI tmp in tmpTexts)
        {
            OptimizeTextMeshPro(tmp);
        }
    }
    
    private void OptimizeText(Text text)
    {
        if (text == null) return;
        
        // 设置高质量文字属性
        text.horizontalOverflow = HorizontalWrapMode.Overflow;
        text.verticalOverflow = VerticalWrapMode.Overflow;
        text.resizeTextForBestFit = false;
        text.supportRichText = false;
        text.fontStyle = FontStyle.Normal;
        
        // 应用分辨率缩放
        if (resolutionScale > 1.0f)
        {
            text.fontSize = (int)(text.fontSize * resolutionScale);
            text.transform.localScale = Vector3.one / resolutionScale;
        }
        
        // 优化材质
        if (text.material != null)
        {
            text.material.SetFloat("_SrcBlend", (float)UnityEngine.Rendering.BlendMode.SrcAlpha);
            text.material.SetFloat("_DstBlend", (float)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
            text.material.SetFloat("_ZWrite", 0);
            text.material.DisableKeyword("_ALPHATEST_ON");
            text.material.EnableKeyword("_ALPHABLEND_ON");
            text.material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
            text.material.renderQueue = 3000;
        }
    }
    
    private void OptimizeTextMeshPro(TextMeshProUGUI tmp)
    {
        if (tmp == null) return;
        
        // 设置高质量TextMeshPro属性
        tmp.enableAutoSizing = false;
        tmp.fontStyle = FontStyles.Normal;
        tmp.enableWordWrapping = false;
        tmp.richText = false;
        tmp.raycastTarget = false; // 如果不需要交互
        
        // 应用分辨率缩放
        if (resolutionScale > 1.0f)
        {
            tmp.fontSize = tmp.fontSize * resolutionScale;
            tmp.transform.localScale = Vector3.one / resolutionScale;
        }
        
        // 优化材质
        if (tmp.material != null)
        {
            tmp.material.SetFloat("_UnderlayDilate", 0.0f);
            tmp.material.SetFloat("_UnderlaySoftness", 0.0f);
            tmp.material.SetFloat("_WeightNormal", 0.5f);
            tmp.material.SetFloat("_WeightBold", 0.75f);
            tmp.material.SetFloat("_OutlineWidth", 0.0f);
            tmp.material.SetFloat("_FaceDilate", 0.0f);
            tmp.material.SetFloat("_FaceSoftness", 0.0f);
        }
    }
    
    [ContextMenu("创建高质量字体材质")]
    public void CreateHighQualityFontMaterial()
    {
        // 创建高质量字体材质
        Material highQualityMaterial = new Material(Shader.Find("UI/Default"));
        
        // 设置高质量属性
        highQualityMaterial.SetFloat("_SrcBlend", (float)UnityEngine.Rendering.BlendMode.SrcAlpha);
        highQualityMaterial.SetFloat("_DstBlend", (float)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
        highQualityMaterial.SetFloat("_ZWrite", 0);
        highQualityMaterial.DisableKeyword("_ALPHATEST_ON");
        highQualityMaterial.EnableKeyword("_ALPHABLEND_ON");
        highQualityMaterial.DisableKeyword("_ALPHAPREMULTIPLY_ON");
        highQualityMaterial.renderQueue = 3000;
        
        // 设置纹理过滤
        if (highQualityMaterial.mainTexture != null)
        {
            highQualityMaterial.mainTexture.filterMode = preferredFilterMode;
        }
        
        Debug.Log("已创建高质量字体材质");
    }
    
    [ContextMenu("优化字体设置")]
    public void OptimizeFontSettings()
    {
        // 查找所有字体资源
        Font[] fonts = Resources.FindObjectsOfTypeAll<Font>();
        
        foreach (Font font in fonts)
        {
            if (font != null)
            {
                // 注意：字体属性需要在Unity编辑器的字体导入设置中手动调整
                if (fontTextureSize > 0)
                {
                    Debug.Log($"建议将字体 {font.name} 的纹理大小设置为 {fontTextureSize}");
                }
            }
        }
        
        Debug.Log($"已检查 {fonts.Length} 个字体设置");
    }
    
    [ContextMenu("检查文字质量")]
    public void CheckTextQuality()
    {
        Debug.Log("=== 文字质量检查报告 ===");
        Debug.Log($"屏幕分辨率: {Screen.currentResolution.width}x{Screen.currentResolution.height}");
        Debug.Log($"DPI: {Screen.dpi}");
        Debug.Log($"抗锯齿级别: {QualitySettings.antiAliasing}");
        Debug.Log($"纹理质量: {QualitySettings.masterTextureLimit}");
        Debug.Log($"各向异性过滤: {QualitySettings.anisotropicFiltering}");
        
        // 检查场景中的文字组件
        Text[] texts = FindObjectsOfType<Text>();
        TextMeshProUGUI[] tmpTexts = FindObjectsOfType<TextMeshProUGUI>();
        
        Debug.Log($"场景中Text组件数量: {texts.Length}");
        Debug.Log($"场景中TextMeshPro组件数量: {tmpTexts.Length}");
        
        // 检查Canvas设置
        Canvas[] canvases = FindObjectsOfType<Canvas>();
        Debug.Log($"场景中Canvas数量: {canvases.Length}");
        
        foreach (Canvas canvas in canvases)
        {
            Debug.Log($"Canvas '{canvas.name}' 渲染模式: {canvas.renderMode}");
            CanvasScaler scaler = canvas.GetComponent<CanvasScaler>();
            if (scaler != null)
            {
                Debug.Log($"Canvas '{canvas.name}' 缩放模式: {scaler.uiScaleMode}");
            }
        }
    }
    
    [ContextMenu("应用像素完美模式")]
    public void ApplyPixelPerfectMode()
    {
        if (!usePixelPerfect) return;
        
        // 设置像素完美渲染
        if (mainCamera != null)
        {
            mainCamera.orthographic = true;
            mainCamera.orthographicSize = Screen.height / 2f / 100f; // 假设100像素 = 1单位
        }
        
        // 设置Canvas为像素完美
        Canvas[] canvases = FindObjectsOfType<Canvas>();
        foreach (Canvas canvas in canvases)
        {
            CanvasScaler scaler = canvas.GetComponent<CanvasScaler>();
            if (scaler != null)
            {
                scaler.uiScaleMode = CanvasScaler.ScaleMode.ConstantPixelSize;
                scaler.scaleFactor = 1.0f;
            }
        }
        
        Debug.Log("已应用像素完美模式");
    }
    
    // 在Inspector中实时预览
    private void OnValidate()
    {
        if (Application.isPlaying)
        {
            // 实时应用某些设置
            if (enableMSAA)
            {
                QualitySettings.antiAliasing = 4;
            }
        }
    }
}