CapersProject/Assets/02.Scripts/Ui/Title/TitleOptions.cs

using System;
using System.Collections;
using System.Linq;
using BlueWater;
using BlueWater.Audios;
using BlueWater.Uis;
using BlueWater.Utility;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.InputSystem;
using UnityEngine.UI;

public enum ScreenMode
{
    FullScreen = 0,
    BorderlessFullScreen = 1,
    Windowed = 2
}

public class TitleOptions : PopupUi
{
    [SerializeField]
    private GameObject _panel;

    [SerializeField]
    private Slider _masterVolume;

    [SerializeField]
    private Slider _bgmVolume;

    [SerializeField]
    private Slider _sfxVolume;

    [SerializeField]
    private TMP_Dropdown _screenModeDropdown;
    
    [SerializeField]
    private TMP_Dropdown _resolutionDropdown;

    [SerializeField]
    private TMP_Dropdown _languageDropdown;

    private AudioManager _audioManager;

    private InputAction _interactionEAction;
    private InputAction _closeOptionsAction;
    
    public Action CloseOptions;

    private void Start()
    {
        _interactionEAction = PlayerInputKeyManager.Instance.GetAction(InputActionMaps.TycoonUi, TycoonUiActions.InteractionE);
        _closeOptionsAction = PlayerInputKeyManager.Instance.GetAction(InputActionMaps.TycoonUi, TycoonUiActions.Cancel);
        
        _audioManager = AudioManager.Instance;
        
        InitializeScreenModeDropdown();
        InitializeResolutionDropdown();

        var masterVolume = ES3.Load(SaveData.MasterVolume, 1f);
        SetMasterVolume(masterVolume);

        var bgmVolume = ES3.Load(SaveData.BgmVolume, 1f);
        SetBgmVolume(bgmVolume);

        var sfxVolume = ES3.Load(SaveData.SfxVolume, 1f);
        SetSfxVolume(sfxVolume);

        StartCoroutine(nameof(InitializeLanguage));
    }

    private void OnDestroy()
    {
        if (_interactionEAction != null)
        {
            _interactionEAction.performed -= OnInteractionE;
        }

        if (_closeOptionsAction != null)
        {
            _closeOptionsAction.performed -= OnCloseOptions;
        }

        if (_resolutionDropdown != null)
        {
            _resolutionDropdown.onValueChanged.RemoveListener(SetResolution);
        }

        if (_screenModeDropdown != null)
        {
            _screenModeDropdown.onValueChanged.RemoveListener(SetScreenMode);
        }
    }

    public override void Open()
    {
        PopupUiController.RegisterPopup(this);
        _panel.SetActive(true);
        IsOpened = true;
    }

    public override void Close()
    {
        _panel.SetActive(false);
        PopupUiController.UnregisterPopup(this);
        IsOpened = false;
    }
    
    public override void EnableInput()
    {
        _interactionEAction.performed += OnInteractionE;
        _closeOptionsAction.performed += OnCloseOptions;
    }

    public override void DisableInput()
    {
        _interactionEAction.performed -= OnInteractionE;
        _closeOptionsAction.performed -= OnCloseOptions;
    }
    
    private void InitializeScreenModeDropdown()
    {
        _screenModeDropdown.ClearOptions();
        var options = Enum.GetNames(typeof(ScreenMode));
        var localizedOptions = options
            .Select(Utils.GetLocalizedString)
            .ToList();
        _screenModeDropdown.AddOptions(localizedOptions);
        
        var savedScreenMode = ES3.Load(SaveData.ScreenMode, (int)ScreenMode.FullScreen);
        _screenModeDropdown.value = savedScreenMode;
        
        _screenModeDropdown.onValueChanged.AddListener(SetScreenMode);
    }
    
    private void InitializeResolutionDropdown()
    {
        _resolutionDropdown.ClearOptions();
        var resolutions = Screen.resolutions;
        var resolutionOptions = resolutions
            .Select(element => $"{element.width}x{element.height}")
            .Distinct()
            .ToList();

        // 현재 해상도 가져오기
        string currentResolutionString = $"{Screen.width}x{Screen.height}";

        // 현재 해상도가 리스트에 없으면 추가
        if (!resolutionOptions.Contains(currentResolutionString))
        {
            resolutionOptions.Add(currentResolutionString);
        }

        _resolutionDropdown.AddOptions(resolutionOptions);

        // 저장된 해상도 설정
        var savedResolution = ES3.Load(SaveData.Resolution, defaultValue: currentResolutionString);
        var savedIndex = resolutionOptions.IndexOf(savedResolution);

        if (savedIndex == -1)
        {
            // 저장된 값이 드롭다운에 없으면 추가
            resolutionOptions.Add(savedResolution);
            savedIndex = resolutionOptions.Count - 1;
        }

        _resolutionDropdown.value = savedIndex;
        _resolutionDropdown.onValueChanged.AddListener(SetResolution);
    }

    public void SetMasterVolume(float value)
    {
        _audioManager.SetMasterVolume(value);
        _masterVolume.value = value;
        ES3.Save(SaveData.MasterVolume, value);
    }

    public void SetBgmVolume(float value)
    {
        _audioManager.SetBgmVolume(value);
        _bgmVolume.value = value;
        ES3.Save(SaveData.BgmVolume, value);
    }

    public void SetSfxVolume(float value)
    {
        _audioManager.SetSfxVolume(value);
        _sfxVolume.value = value;
        ES3.Save(SaveData.SfxVolume, value);
    }

    private IEnumerator InitializeLanguage()
    {
        yield return new WaitUntil(() => LocalizationManager.Instance.IsInitialized);
        
        _languageDropdown.ClearOptions();
        
        var localeOptions = Enum.GetValues(typeof(LocaleType))
            .Cast<LocaleType>()
            .Select(locale => LocalizationManager.Instance.GetLocaleDisplayName(locale))
            .ToList();
        
        _languageDropdown.AddOptions(localeOptions);

        var languageIndex = LocalizationManager.Instance.GetCurrentLocaleIndex();
        _languageDropdown.value = languageIndex;
    }

    public void ChangeLanguage(int localeType)
    {
        _languageDropdown.value = localeType;
        LocalizationManager.Instance.ChangeLocale((LocaleType)localeType);
    }
    
    public void OnInteractionE(InputAction.CallbackContext context)
    {
        var current = EventSystem.current.currentSelectedGameObject;
        if (!current) return;

        var currenButton = current.GetComponent<Button>();
        currenButton.onClick.Invoke();
    }

    public void OnCloseOptions(InputAction.CallbackContext context)
    {
        CloseOptions?.Invoke();
    }

    public void SetScreenMode(int screenModeIndex)
    {
        switch ((ScreenMode)screenModeIndex)
        {
            case ScreenMode.FullScreen:
                Screen.fullScreenMode = FullScreenMode.FullScreenWindow;
                break;
            case ScreenMode.BorderlessFullScreen:
                if (Application.platform == RuntimePlatform.WindowsPlayer)
                {
                    Screen.fullScreenMode = FullScreenMode.ExclusiveFullScreen;
                }
                else if (Application.platform == RuntimePlatform.OSXPlayer)
                {
                    Screen.fullScreenMode = FullScreenMode.MaximizedWindow;
                }
                break;
            case ScreenMode.Windowed:
                Screen.fullScreenMode = FullScreenMode.Windowed;
                break;
            default:
                throw new ArgumentOutOfRangeException(nameof(screenModeIndex), screenModeIndex, null);
        }
        
        ES3.Save(SaveData.ScreenMode, screenModeIndex);
        EventManager.InvokeChangedDisplay();
    }
    
    public void SetResolution(int resolutionIndex)
    {
        var resolutionString = _resolutionDropdown.options[resolutionIndex].text;
        SetResolution(resolutionString);
    }
    
    private void SetResolution(string resolutionString)
    {
        var parts = resolutionString.Split(new[] { 'x', '@', ' ' }, StringSplitOptions.RemoveEmptyEntries);

        if (parts.Length >= 2 &&
            int.TryParse(parts[0], out var width) &&
            int.TryParse(parts[1], out var height))
        {
            string saveResolution = $"{width}x{height}";
            Screen.SetResolution(width, height, Screen.fullScreenMode);
            ES3.Save(SaveData.Resolution, saveResolution);
            EventManager.InvokeChangedDisplay();
        }
    }
}