<?php
// +----------------------------------------------------------------------
// | Niucloud-admin 企业快速开发的多应用管理平台
// +----------------------------------------------------------------------
// | 官方网址：https://www.niucloud.com
// +----------------------------------------------------------------------
// | niucloud团队 版权所有 开源版本可自由商用
// +----------------------------------------------------------------------
// | Author: Niucloud Team
// +----------------------------------------------------------------------

namespace app\service\api\common;

use app\model\dict\Dict;
use core\base\BaseApiService;

/**
 * 字典批量获取服务
 * Class DictService
 * @package app\service\api\common
 */
class DictService extends BaseApiService
{
    public function __construct()
    {
        parent::__construct();
        $this->model = new Dict();
    }

    /**
     * 批量获取字典数据
     * @param array $keys 字典key数组
     * @return array
     */
    public function getBatchDict(array $keys = []): array
    {
        if (empty($keys)) {
            return [];
        }

        // 验证keys参数
        $validKeys = array_filter($keys, function($key) {
            return is_string($key) && !empty(trim($key));
        });

        if (empty($validKeys)) {
            return [];
        }

        try {
            // 批量查询字典数据
            $dictData = $this->model
                ->whereIn('key', $validKeys)
                ->field('key, dictionary')
                ->select()
                ->toArray();

            $result = [];
            
            foreach ($dictData as $dict) {
                $key = $dict['key'];
                $dictionary = $dict['dictionary'];
                
                // 解析字典值 - 手动处理JSON解析
                if (!empty($dictionary)) {
                    if (is_array($dictionary)) {
                        // 已经是数组格式，直接使用
                        $result[$key] = $dictionary;
                    } else if (is_string($dictionary)) {
                        // 处理JSON字符串，可能包含转义字符
                        
                        // 首先尝试直接解析
                        $decodedValue = json_decode($dictionary, true);
                        if (json_last_error() === JSON_ERROR_NONE) {
                            if (is_array($decodedValue)) {
                                // 解析结果是数组，直接使用
                                $result[$key] = $decodedValue;
                            } else if (is_string($decodedValue)) {
                                // 解析结果是字符串，可能是双重JSON编码，尝试再次解析
                                $secondDecodedValue = json_decode($decodedValue, true);
                                if (json_last_error() === JSON_ERROR_NONE && is_array($secondDecodedValue)) {
                                    $result[$key] = $secondDecodedValue;
                                } else {
                                    // 字符串解析失败，使用字符串解析方法
                                    $result[$key] = $this->parseStringValue($decodedValue);
                                }
                            } else {
                                $result[$key] = [];
                            }
                        } else {
                            // JSON解析失败，尝试其他方法
                            $cleanedDictionary = stripcslashes($dictionary);
                            $decodedValue = json_decode($cleanedDictionary, true);
                            if (json_last_error() === JSON_ERROR_NONE && is_array($decodedValue)) {
                                $result[$key] = $decodedValue;
                            } else {
                                // 使用字符串解析方法作为最后手段
                                $result[$key] = $this->parseStringValue($dictionary);
                            }
                        }
                    } else {
                        $result[$key] = [];
                    }
                } else {
                    $result[$key] = [];
                }
            }

            // 为没有找到的key返回空数组
            foreach ($validKeys as $key) {
                if (!isset($result[$key])) {
                    $result[$key] = [];
                }
            }

            return $result;

        } catch (\Exception $e) {
            // 记录错误日志
            trace('批量获取字典数据失败: ' . $e->getMessage(), 'error');
            
            // 返回空结果
            $result = [];
            foreach ($validKeys as $key) {
                $result[$key] = [];
            }
            return $result;
        }
    }

    /**
     * 获取单个字典数据（带缓存）
     * @param string $key 字典key
     * @param bool $useCache 是否使用缓存
     * @return array
     */
    public function getDict(string $key, bool $useCache = true): array
    {
        if (empty($key)) {
            return [];
        }

        $cacheKey = "dict_cache_{$key}";
        
        // 如果使用缓存，先尝试从缓存获取
        if ($useCache) {
            $cached = cache($cacheKey);
            if ($cached !== false) {
                return $cached;
            }
        }

        try {
            $dict = $this->model
                ->where('key', $key)
                ->field('dictionary')
                ->find();

            $result = [];
            if ($dict && !empty($dict['dictionary'])) {
                if (is_array($dict['dictionary'])) {
                    $result = $dict['dictionary'];
                } else {
                    $decodedValue = json_decode($dict['dictionary'], true);
                    if (json_last_error() === JSON_ERROR_NONE && is_array($decodedValue)) {
                        $result = $decodedValue;
                    } else {
                        $result = $this->parseStringValue($dict['dictionary']);
                    }
                }
            }

            // 缓存结果（缓存30分钟）
            if ($useCache) {
                cache($cacheKey, $result, 1800);
            }

            return $result;

        } catch (\Exception $e) {
            trace('获取字典数据失败: ' . $e->getMessage(), 'error');
            return [];
        }
    }

    /**
     * 清除字典缓存
     * @param string|array $keys 要清除的字典key，为空则清除所有字典缓存
     * @return bool
     */
    public function clearDictCache($keys = null): bool
    {
        try {
            if (is_null($keys)) {
                // 清除所有字典缓存（需要实现cache标签功能或使用其他方式）
                // 这里简化处理，实际项目中可以使用cache标签
                return true;
            }

            if (is_string($keys)) {
                $keys = [$keys];
            }

            if (is_array($keys)) {
                foreach ($keys as $key) {
                    cache("dict_cache_{$key}", null);
                }
                return true;
            }

            return false;
        } catch (\Exception $e) {
            trace('清除字典缓存失败: ' . $e->getMessage(), 'error');
            return false;
        }
    }

    /**
     * 解析字符串格式的字典值
     * @param string $value
     * @return array
     */
    private function parseStringValue(string $value): array
    {
        // 尝试按行分割，每行格式如：key|value 或 key:value
        $lines = array_filter(explode("\n", $value));
        $result = [];

        foreach ($lines as $line) {
            $line = trim($line);
            if (empty($line)) {
                continue;
            }

            // 尝试多种分隔符
            $separators = ['|', ':', '=', ','];
            $parsed = false;

            foreach ($separators as $sep) {
                if (strpos($line, $sep) !== false) {
                    $parts = explode($sep, $line, 2);
                    if (count($parts) === 2) {
                        $result[] = [
                            'name' => trim($parts[1]),
                            'value' => trim($parts[0]),
                            'sort' => count($result),
                            'memo' => ''
                        ];
                        $parsed = true;
                        break;
                    }
                }
            }

            // 如果没有找到分隔符，将整行作为值，索引作为key
            if (!$parsed) {
                $result[] = [
                    'name' => $line,
                    'value' => (string)count($result),
                    'sort' => count($result),
                    'memo' => ''
                ];
            }
        }

        return $result;
    }

    /**
     * 获取常用字典映射
     * @return array
     */
    public function getCommonDictMapping(): array
    {
        return [
            // 客户来源相关
            'source_channel' => 'SourceChannel',
            'source' => 'source',
            'purchasing_power' => 'customer_purchasing_power',
            'cognitive_idea' => 'cognitive_concept',
            'decision_maker' => 'decision_maker',
            'initial_intent' => 'preliminarycustomerintention',
            'status' => 'kh_status',
            'distance' => 'distance',
            
            // 人员管理相关
            'gender' => 'gender',
            'education' => 'education',
            'position' => 'position',
            'department' => 'department',
            
            // 课程相关
            'course_type' => 'course_type',
            'course_level' => 'course_level',
            'course_status' => 'course_status',
            
            // 其他常用字典
            'yes_no' => 'yes_no',
            'enable_disable' => 'enable_disable'
        ];
    }

    /**
     * 根据业务场景获取字典keys
     * @param string $scene 业务场景
     * @return array
     */
    public function getDictKeysByScene(string $scene): array
    {
        $sceneMapping = [
            'customer_add' => [
                'SourceChannel', 'source', 'customer_purchasing_power', 
                'cognitive_concept', 'decision_maker', 'preliminarycustomerintention', 
                'kh_status', 'distance'
            ],
            'personnel_add' => [
                'gender', 'education', 'position', 'department', 'enable_disable'
            ],
            'course_add' => [
                'course_type', 'course_level', 'course_status', 'enable_disable'
            ]
        ];

        return $sceneMapping[$scene] ?? [];
    }
}