<?php

namespace app\common\helper;

use think\facade\Db;
use app\common\server\RedisHelper;

/**
 * 配置帮助类
 * 用于获取系统配置参数
 */
class ConfigHelper
{
    /**
     * 静态属性，用于存储无限赏抽奖倍数
     * 第一次获取后会缓存，避免重复查询
     * 
     * @var int|null
     */
    private static $infiniteMultiple = null;

    /**
     * 静态属性，用于存储排行榜设置
     * 
     * @var array|null
     */
    private static $rankSettings = null;

    private static $appSetting = null;

    private static $systemTest = null;

    private static $youda_env = null;

    /**
     * 获取友达环境
     * 
     * @return string 友达环境
     */
    public static function getYoudaEnv()
    {
        if (self::$youda_env !== null) {
            return self::$youda_env;
        }
        $youda_env = env('youda.youda_env', 'production');
        if ($youda_env) {
            self::$youda_env = $youda_env;
        }
        return self::$youda_env;
    }

    public static function getIsTest(){
        
    }
    /**
     * 获取应用设置
     * 
     * @return array 应用设置
     */
    public static function getAppSetting()
    {
        if (self::$appSetting !== null) {
            return self::$appSetting;
        }
        // $redis = new RedisHelper();
        // $cachedValue = $redis->get('config:app_setting');
        // if ($cachedValue !== false) {
        //     self::$appSetting = json_decode($cachedValue, true);
        //     return self::$appSetting;
        // }
        $app_setting = getConfig('app_setting');
        if ($app_setting) {
            self::$appSetting = $app_setting;
            // $redis->set('config:app_setting', json_encode($app_setting), 86400);
            // return self::$appSetting;
        }
        return self::$appSetting;
    }
    /**
     * 获取应用设置的key值
     * 
     * @param string $key 配置键名
     * @return mixed 配置值
     */
    public static function getAppSettingKey($key)
    {
        $appSetting = self::getAppSetting();
        return $appSetting[$key] ?? null;
    }


    /**
     * 获取无限赏抽奖倍数
     * 从数据库中查询key为infinite_multiple的配置，获取multiple字段
     * 将结果存入Redis缓存，有效期为1天
     * 
     * @return int 抽奖倍数，默认为1000
     */
    public static function getInfiniteMultiple(
    ) {
        // 如果静态属性已有值，直接返回
        if (self::$infiniteMultiple !== null) {
            return self::$infiniteMultiple;
        }

        // 实例化Redis助手
        $redis = new RedisHelper();

        // 设置Redis键名
        $redisKey = 'config:infinite_multiple';

        // 尝试从Redis获取
        $cachedValue = $redis->get($redisKey);
        if ($cachedValue !== false) {
            // 缓存结果到静态属性
            self::$infiniteMultiple = (int) $cachedValue;
            return self::$infiniteMultiple;
        }

        // Redis中不存在，从数据库获取
        $config = Db::name('config')
            ->where('key', 'infinite_multiple')
            ->value('value');

        // 解析JSON数据
        $configArray = json_decode($config, true);

        // 获取倍数值，默认为10000
        $multiple = isset($configArray['multiple']) ? (int) $configArray['multiple'] : 10000;

        // 存入Redis，过期时间为1天（86400秒）
        $redis->set($redisKey, $multiple, 86400);

        // 缓存结果到静态属性
        self::$infiniteMultiple = $multiple;

        return self::$infiniteMultiple;
    }

    /**
     * 获取排行榜设置
     * 从数据库中查询key为rank_setting的配置
     * 
     * @return array 排行榜设置
     */
    public static function getRankSettings()
    {
        // 如果静态属性已有值，直接返回
        if (self::$rankSettings !== null) {
            return self::$rankSettings;
        }

        // 实例化Redis助手
        $redis = new RedisHelper();

        // 设置Redis键名
        $redisKey = 'config:rank_settings';

        // 尝试从Redis获取
        $cachedValue = $redis->get($redisKey);
        if ($cachedValue !== false) {
            // 缓存结果到静态属性
            self::$rankSettings = json_decode($cachedValue, true);
            return self::$rankSettings;
        }

        // Redis中不存在，从数据库获取
        $config = Db::name('config')
            ->where('key', 'rank_setting')
            ->value('value');

        // 解析JSON数据
        $configArray = json_decode($config, true) ?: [];

        // 存入Redis，过期时间为1小时（3600秒）
        $redis->set($redisKey, json_encode($configArray), 3600);

        // 缓存结果到静态属性
        self::$rankSettings = $configArray;

        return self::$rankSettings;
    }

    /**
     * 获取特定排行榜的时间设置
     * 
     * @param string $type 排行榜类型：dadajuan(达达卷), diamond(钻石), integral(UU币), invite(邀请新人)
     * @return array 包含统计方式、开始时间和结束时间的数组
     */
    public static function getRankTime($type)
    {
        // 获取所有排行榜设置
        $settings = self::getRankSettings();

        // 根据类型设置默认的键名
        $statTypeKey = '';
        $startKey = '';
        $endKey = '';

        switch ($type) {
            case 'dadajuan':
                $statTypeKey = 'dadajuan_stat_type';
                $startKey = 'dadajuan_start_time';
                $endKey = 'dadajuan_end_time';
                break;
            case 'diamond':
                $statTypeKey = 'diamond_stat_type';
                $startKey = 'diamond_start_time';
                $endKey = 'diamond_end_time';
                break;
            case 'integral':
                $statTypeKey = 'integral_stat_type';
                $startKey = 'integral_start_time';
                $endKey = 'integral_end_time';
                break;
            case 'invite':
                $statTypeKey = 'invite_stat_type';
                $startKey = 'invite_start_time';
                $endKey = 'invite_end_time';
                break;
            case 'loss':
                $statTypeKey = 'loss_stat_type';
                $startKey = 'loss_start_time';
                $endKey = 'loss_end_time';
                break;
            case 'loss_desc':
                $statTypeKey = 'loss_stat_type';
                $startKey = 'loss_start_time';
                $endKey = 'loss_end_time';
                break;
            default:
                return [
                    'stat_type' => 'daily',
                    'start_time' => '',
                    'end_time' => ''
                ];
        }

        // 获取统计方式，默认为每天统计
        $statType = isset($settings[$statTypeKey]) ? $settings[$statTypeKey] : 'daily';

        // 根据统计方式计算时间范围
        $startTime = '';
        $endTime = '';

        // 当前时间
        $now = time();

        switch ($statType) {
            case 'daily': // 每天统计：当天0点到第二天0点
                $startTime = date('Y-m-d 00:00:00', $now);
                $endTime = date('Y-m-d 00:00:00', strtotime('+1 day', $now));
                break;

            case 'weekly': // 每周统计：本周一0点到下周一0点
                $weekStart = strtotime('this week monday', $now);
                $startTime = date('Y-m-d 00:00:00', $weekStart);
                $endTime = date('Y-m-d 00:00:00', strtotime('+1 week', $weekStart));
                break;

            case 'monthly': // 每月统计：本月1号0点到下月1号0点
                $startTime = date('Y-m-01 00:00:00', $now);
                $endTime = date('Y-m-01 00:00:00', strtotime('+1 month', $now));
                break;

            case 'yearly': // 每年统计：本年1月1号0点到下年1月1号0点
                $startTime = date('Y-01-01 00:00:00', $now);
                $endTime = date('Y-01-01 00:00:00', strtotime('+1 year', $now));
                break;

            case 'custom': // 自定义时间范围：使用设置的时间
                $startTime = isset($settings[$startKey]) && !empty($settings[$startKey]) ?
                    $settings[$startKey] : '';
                $endTime = isset($settings[$endKey]) && !empty($settings[$endKey]) ?
                    $settings[$endKey] : '';
                break;
        }

        // 返回排行榜配置
        return [
            'stat_type' => $statType,
            'start_time' => $startTime,
            'end_time' => $endTime
        ];
    }

    /**
     * 清除排行榜设置的Redis缓存
     * 在排行榜设置更新时调用，确保获取最新数据
     * 
     * @return bool 是否成功清除缓存
     */
    public static function clearRankSettingsCache()
    {
        // 重置静态属性
        self::$rankSettings = null;

        // 清除Redis缓存
        $redis = new RedisHelper();
        $redisKey = 'config:rank_settings';

        // 删除缓存，返回是否成功
        return $redis->delete($redisKey);
    }

    /**
     * 获取内测配置
     * 
     * @return array 内测配置
     */
    public static function getSystemTest()
    {
        // 如果静态属性已有值，直接返回
        if (self::$systemTest !== null) {
            return self::$systemTest;
        }

        // // 实例化Redis助手
        // $redis = new RedisHelper();

        // // 设置Redis键名
        // $redisKey = 'config:system_test';

        // // 尝试从Redis获取
        // $cachedValue = $redis->get($redisKey);
        // if ($cachedValue !== false) {
        //     // 缓存结果到静态属性
        //     self::$systemTest = json_decode($cachedValue, true);
        //     return self::$systemTest;
        // }

        // Redis中不存在，从数据库获取
        $config = Db::name('config')
            ->where('key', 'system_test')
            ->value('value');

        // 解析JSON数据
        $configArray = json_decode($config, true) ?: [];

        // 存入Redis，过期时间为1小时（3600秒）
        // $redis->set($redisKey, json_encode($configArray), 3600);

        // 缓存结果到静态属性
        self::$systemTest = $configArray;

        return self::$systemTest;
    }

    /**
     * 获取内测配置
     * 
     * @return array 内测配置
     */
    public static function getSystemTestKey($key)
    {
        // 如果静态属性已有值，直接返回
        $system_test = self::getSystemTest();
        if ($system_test != null && $system_test['enable_test'] == "1") {

            return $system_test[$key];
        }
        if ($key == "sign_multiple") {
            return "0";
        }
        if ($key == "disable_wechat_pay") {
            return "0";
        }

        return $system_test['enable_test'];
    }

    /**
     * 清除内测配置缓存
     * 
     * @return bool 是否成功清除缓存
     */
    public static function clearSystemTestCache()
    {
        // 重置静态属性
        self::$systemTest = null;

        // 清除Redis缓存
        $redis = new RedisHelper();
        $redisKey = 'config:system_test';

        // 删除缓存，返回是否成功
        return $redis->delete($redisKey);
    }
}