package com.ruoyi.common.utils;

import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.utils.spring.SpringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Locale;

/**
 * ���Ի���������
 * ���ڴ�����������صĹ��߷���
 *
 * @author ruoyi
 */
public class LocaleUtils
{
    private static final Logger log = LoggerFactory.getLogger(LocaleUtils.class);

    /** 默认语言（台湾繁体） */
    private static final Locale DEFAULT_LOCALE = new Locale("zh", "TW");

    /** Redis���û��������õ�keyǰ׺ */
    private static final String USER_LANGUAGE_KEY_PREFIX = "user:language:";

    /**
     * ���������ַ���ΪLocale����
     * ֧�ֶ��ָ�ʽ��
     * - �»��߸�ʽ��zh_CN, en_US
     * - ���ַ���ʽ��zh-CN, en-US
     * - �����Դ��룺zh, en, vi
     *
     * @param language �����ַ���
     * @return Locale�������languageΪ���򷵻�Ĭ��Locale��Խ���
     */
    public static Locale parseLocale(String language)
    {
        return DEFAULT_LOCALE;
//        if (StringUtils.isEmpty(language))
//        {
//            return DEFAULT_LOCALE;
//        }
//
//        // �����»��߸�ʽ���� zh_CN��
//        if (language.contains("_"))
//        {
//            String[] parts = language.split("_", 2);
//            if (parts.length == 2)
//            {
//                return new Locale(parts[0], parts[1]);
//            }
//            else
//            {
//                return new Locale(parts[0]);
//            }
//        }
//
//        // �������ַ���ʽ���� zh-CN��
//        if (language.contains("-"))
//        {
//            return Locale.forLanguageTag(language);
//        }
//
//        // �����Դ��루�� zh, en, vi��
//        return new Locale(language);
    }

    /**
     * ��ȡ�û������Ի���
     * ���ȴ�Redis�л�ȡ�û����������ã�����������򷵻�Ĭ�����Ի�����Խ���
     *
     * @param userId �û�ID
     * @return Locale����
     */
    public static Locale getUserLocale(Long userId)
    {
        if (userId == null)
        {
            return DEFAULT_LOCALE;
        }

        try
        {
            // ��Redis��ȡ�û���������
            RedisCache redisCache = SpringUtils.getBean(RedisCache.class);
            if (redisCache != null)
            {
                String key = userId.toString();
                String language = redisCache.getCacheObject(key);
                if (StringUtils.isNotEmpty(language))
                {
                    return parseLocale(language);
                }
            }
        }
        catch (Exception e)
        {
            log.debug("��ȡ�û���������ʧ�ܣ�ʹ��Ĭ�����ԣ��û�ID: {}", userId, e);
        }

        // Ĭ�Ϸ���Խ����
        return DEFAULT_LOCALE;
    }

    /**
     * �����û������Ի�����Redis
     *
     * @param userId �û�ID
     * @param language �����ַ���
     */
    public static void setUserLocale(String userId, String language)
    {
        if (userId == null || StringUtils.isEmpty(language) || StringUtils.isEmpty(userId))
        {
            return;
        }

        try
        {
            RedisCache redisCache = SpringUtils.getBean(RedisCache.class);
            if (redisCache != null)
            {
                String key = userId;
                redisCache.setCacheObject(key, language);
            }
        }
        catch (Exception e)
        {
            log.error("�����û�����ʧ�ܣ��û�ID: {}, ����: {}", userId, language, e);
        }
    }

    /**
     * ��ȡĬ�����Ի���
     *
     * @return Ĭ��Locale����Խ���
     */
    public static Locale getDefaultLocale()
    {
        return DEFAULT_LOCALE;
    }


    /**
     * 将语言字符串转换为语言编码
     * - zh-CN -> 2 (简体中文)
     * - en-US -> 1 (英文)
     * - 其他   -> 3 (繁体中文，默认)
     *
     * @param language 语言字符串（如 zh-CN, en-US, zh-TW）
     * @return 语言编码
     */
    public static String toLangCode(String language)
    {
        if ("zh-CN".equals(language))
        {
            return "2";
        }
        if ("en-US".equals(language))
        {
            return "1";
        }
        return "3";
    }
    /**
     * 获取用户语言编码
     * 从Redis中获取用户的语言设置，并返回对应的语言编码
     * 语言编码映射：
     * - zh-CN -> 2 (简体中文)
     * - zh-TW -> 3 (繁体中文)
     * - en-US -> 1 (英文)
     * - 其他或默认 -> 0 (越南语)
     *
     * @param userId 用户ID字符串
     * @return 语言编码：0-越南语(默认), 1-英文, 2-简体中文, 3-繁体中文
     */
    public static String getUserLanguageCode(String userId)
    {
        String result = "0"; // 默认语言（越南语）
        if (StringUtils.isEmpty(userId))
        {
            return result;
        }

        RedisCache redisCache = SpringUtils.getBean(RedisCache.class);
        try
        {

            String lang = redisCache.getCacheObject(userId);
            log.debug("从redis获取的语言：{}, 用户ID: {}", lang, userId);
            if ("zh-CN".equals(lang))
            {
                result = "2";
            }
            else if ("zh-TW".equals(lang))
            {
                result = "3";
            }
            else if ("en-US".equals(lang))
            {
                result = "1";
            }
        }
        catch (Exception e)
        {
            // Redis连接失败或其他异常时，使用默认语言
            log.debug("获取用户语言设置失败，使用默认语言，用户ID: {}", userId, e);
        }

        log.debug("获取的语言编码：{}, 用户ID: {}", result, userId);
        return result;
    }
}
