package com.example.demo.controller.coin;

import com.example.demo.Util.BusinessException;
import com.example.demo.Util.JWTUtil;
import com.example.demo.Util.LanguageTranslationUtil;
import com.example.demo.Util.RedisLockUtil;
import com.example.demo.config.interfac.Log;
import com.example.demo.domain.DTO.GoldDetailDTO;
import com.example.demo.domain.DTO.GoldUserDTO;
import com.example.demo.domain.entity.Admin;
import com.example.demo.domain.entity.User;
import com.example.demo.domain.vo.coin.GoldDetail;
import com.example.demo.domain.vo.coin.GoldUser;
import com.example.demo.domain.vo.coin.Page;
import com.example.demo.domain.vo.coin.Result;
import com.example.demo.service.coin.GoldDetailService;
import com.example.demo.service.coin.MarketService;
import com.example.demo.service.coin.TranslationService;
import com.example.demo.serviceImpl.coin.AiEmotionServiceImpl;
import com.github.pagehelper.PageInfo;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import java.util.Arrays;
import java.util.List;
import java.util.UUID;

/**
 * @program: GOLD
 * @ClassName GoldDetailController
 * @description:
 * @author: huangqizhen
 * @create: 2025−06-23 14:41
 * @Version 1.0
 **/

@RestController
@RequestMapping("/goldDetail")
@RequiredArgsConstructor
@Slf4j
@CrossOrigin
public class GoldDetailController {
    @Autowired
    private  GoldDetailService goldDetailService;
    @Autowired
    private LanguageTranslationUtil languageTranslationUtil;
    @Autowired
    private RedisLockUtil redisLockUtil;
    @Autowired
    private AiEmotionServiceImpl aiEmotionServiceImpl;
    @Autowired
    MarketService marketService;
    @Autowired
    private TranslationService translationService;
    @Log("获取金币明细")
    @PostMapping("/getGoldDetail")
    public Result getGoldDetail(@RequestBody Page page, @RequestHeader(defaultValue = "zh_CN") String lang) throws Exception {

        // 解析语言代码
        String languageCode = parseLanguageCode(lang);

        // 如果不是中文环境，将查询条件中的翻译文本转换为中文简体
        if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
            convertGoldDetailTranslatedFieldsToChinese(page.getGoldDetail(), languageCode);
        }

        // 获取当前请求对象
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token = request.getHeader("token");

        // 解析 token 获取用户信息
        Admin admin = (Admin) JWTUtil.getUserDetailsList(String.valueOf(token), Admin.class);
        List<String> userMarkets = Arrays.asList(StringUtils.split(admin.getMarkets(), ","));
        List<String> markets = marketService.getMarketIds(userMarkets);

        // 校验分页参数
        if (ObjectUtils.isEmpty(page.getPageNum())) {
            return Result.error("页码数为空！");
        }
        if (ObjectUtils.isEmpty(page.getPageSize())) {
            return Result.error("页大小为空！");
        }

        // 获取传入的市场列表
        List<String> requestedMarkets = page.getGoldDetail() != null ? page.getGoldDetail().getMarkets() : null;

        // 权限校验逻辑
        if (markets.contains("9") || markets.contains("9999")) {
            // 特权市场：9 或 9999，跳过权限校验，直接放行传入的 markets
            // 如果业务需要，也可以在这里做空值处理
            if (page.getGoldDetail() != null) {
                // 保持 requestedMarkets 不变，原样接受
                // 可选：如果 requestedMarkets 为 null，可设为默认值或保持 null
            }
        } else {
            // 普通用户：必须校验权限
            if (requestedMarkets == null || requestedMarkets.isEmpty()) {
                page.getGoldDetail().setMarkets(markets);
            }
            if (!markets.containsAll(requestedMarkets)) {
                return Result.error("无权限！请求的市场不在授权范围内。");
            }
            // 校验通过，保持 requestedMarkets 不变
        }

        // 返回详情数据
        Result result = Result.success(goldDetailService.getGoldDetail(
                page.getPageNum(),
                page.getPageSize(),
                page.getGoldDetail()
        ));

        // 对返回结果进行多语言转换
        if (result.getCode() == 200 && result.getData() instanceof PageInfo) {
            PageInfo<GoldDetail> pageInfo = (PageInfo<GoldDetail>) result.getData();
            translateGoldDetails(pageInfo, lang);
        }

        return result;
    }

    @Log("客户金币明细金币合计数统计")
    @PostMapping("/getTotal")
    public Result getTotal(@RequestBody Page page) throws Exception {
        Integer pageNum = page.getPageNum();
        Integer pageSize = page.getPageSize();
        GoldDetail goldDetail = page.getGoldDetail();
        // 获取当前请求对象
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token = request.getHeader("token");

        // 解析 token 获取用户信息
        Admin admin = (Admin) JWTUtil.getUserDetailsList(String.valueOf(token), Admin.class);
        List<String> userMarkets = Arrays.asList(StringUtils.split(admin.getMarkets(), ","));
        List<String> markets = marketService.getMarketIds(userMarkets);
        // 获取传入的市场列表
        List<String> requestedMarkets = page.getGoldDetail() != null ? page.getGoldDetail().getMarkets() : null;

        // 权限校验逻辑
        if (markets.contains("9") || markets.contains("9999")) {
            // 特权市场：9 或 9999，跳过权限校验，直接放行传入的 markets
            // 如果业务需要，也可以在这里做空值处理
            if (page.getGoldDetail() != null) {
                // 保持 requestedMarkets 不变，原样接受
                // 可选：如果 requestedMarkets 为 null，可设为默认值或保持 null
            }
        } else {
            // 普通用户：必须校验权限
            if (requestedMarkets == null || requestedMarkets.isEmpty()) {
                page.getGoldDetail().setMarkets(markets);
            }
            if (!markets.containsAll(requestedMarkets)) {
                return Result.error("无权限！请求的市场不在授权范围内。");
            }
            // 校验通过，保持 requestedMarkets 不变
        }

        return Result.success(goldDetailService.sumGold(pageNum,pageSize,goldDetail));
    }

    @Log("客户金币余额金币合计数统计")
    @PostMapping("/goldTotal")
    public Result GoldTotal(@RequestBody User user) throws Exception {
        // 获取当前请求对象
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token = request.getHeader("token");

        // 解析 token 获取用户信息
        Admin admin = (Admin) JWTUtil.getUserDetailsList(String.valueOf(token), Admin.class);
        List<String> userMarkets = Arrays.asList(StringUtils.split(admin.getMarkets(), ","));
        List<String> markets = marketService.getMarketIds(userMarkets);


        // 获取传入的市场列表
        List<String> requestedMarkets = user != null ? user.getMarkets() : null;

        // 权限校验逻辑
        if (markets.contains("9") || markets.contains("9999")) {
            // 特权市场：9 或 9999，跳过权限校验，直接放行传入的 markets
            // 如果业务需要，也可以在这里做空值处理
            if (user != null) {
                // 保持 requestedMarkets 不变，原样接受
                // 可选：如果 requestedMarkets 为 null，可设为默认值或保持 null
            }
        } else {
            // 普通用户：必须校验权限
            if (requestedMarkets == null || requestedMarkets.isEmpty()) {
                 user.setMarkets(markets);
            }
            if (!markets.containsAll(requestedMarkets)) {
                return Result.error("无权限！请求的市场不在授权范围内。");
            }
            // 校验通过，保持 requestedMarkets 不变
        }

        return Result.success(goldDetailService.GoldTotal(user));
    }

    @Log("获取客户金币余额记录")
    @PostMapping("/getGold")
    public Result getGold(@RequestBody Page page, @RequestHeader(defaultValue = "zh_CN") String lang) throws Exception {
        // 解析语言代码
        String languageCode = parseLanguageCode(lang);

        // 如果不是中文环境，将查询条件中的翻译文本转换为中文简体
        if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
            convertUserTranslatedFieldsToChinese(page.getUser(), languageCode);
        }

        // 获取当前请求对象
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token = request.getHeader("token");

        // 解析 token 获取用户信息
        Admin admin = (Admin) JWTUtil.getUserDetailsList(String.valueOf(token), Admin.class);
        List<String> userMarkets = Arrays.asList(StringUtils.split(admin.getMarkets(), ","));
        List<String> markets = marketService.getMarketIds(userMarkets);

        // 校验分页参数
        if (ObjectUtils.isEmpty(page.getPageNum())) {
            return Result.error("页码数为空！");
        }
        if (ObjectUtils.isEmpty(page.getPageSize())) {
            return Result.error("页大小为空！");
        }

        // 获取传入的市场列表
        List<String> requestedMarkets = page.getUser() != null ? page.getUser().getMarkets() : null;

        // 权限校验逻辑
        if (markets.contains("9") || markets.contains("9999")) {
            // 特权市场：9 或 9999，跳过权限校验，直接放行传入的 markets
            // 如果业务需要，也可以在这里做空值处理
            if (page.getUser() != null) {
                // 保持 requestedMarkets 不变，原样接受
                // 可选：如果 requestedMarkets 为 null，可设为默认值或保持 null
            }
        } else {
            // 普通用户：必须校验权限
            if (requestedMarkets == null || requestedMarkets.isEmpty()) {
                page.getUser().setMarkets(markets);
            }
            if (!markets.containsAll(requestedMarkets)) {
                return Result.error("无权限！请求的市场不在授权范围内。");
            }
            // 校验通过，保持 requestedMarkets 不变
        }

        Result result = Result.success(goldDetailService.getGold(page.getPageNum(), page.getPageSize(), page.getUser()));

        // 对返回结果进行多语言转换
        if (result.getCode() == 200 && result.getData() instanceof PageInfo) {
            PageInfo<User> pageInfo = (PageInfo<User>) result.getData();
            translateUsers(pageInfo, lang);
        }

        return result;
    }

    @PostMapping("/export")
    public Result export(@Valid @RequestBody GoldDetailDTO dto, @RequestHeader(defaultValue = "zh_CN") String lang) {
        String lockKey = "export:lock:" + dto.getToken(); // 锁的 Key（可按用户/业务区分）
        String requestId = UUID.randomUUID().toString();  // 请求 ID（防止误删锁）
        long expireTime = 5000; // 锁过期时间（5秒）s
        dto.setLang(lang); // 设置语言参数

        // 解析语言代码
        String languageCode = parseLanguageCode(lang);

        // 如果不是中文环境，将查询条件中的翻译文本转换为中文简体
        if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
            convertGoldDetailTranslatedFieldsToChinese(dto.getGoldDetail(), languageCode);
        }

        try {
            // 尝试获取锁
            if (!redisLockUtil.tryLock(lockKey, requestId, expireTime)) {
                throw new BusinessException("操作太频繁，请稍后重试");
            }
            // 执行业务逻辑
            return goldDetailService.addExportRecord(dto);
        } finally {
            // 释放锁
            redisLockUtil.unlock(lockKey, requestId);
        }
    }

    @PostMapping("/exportGold")
    public Result export(@Valid @RequestBody GoldUserDTO dto, @RequestHeader(defaultValue = "zh_CN") String lang) {
        String lockKey = "export:lock:" + dto.getToken(); // 锁的 Key（可按用户/业务区分）
        String requestId = UUID.randomUUID().toString();  // 请求 ID（防止误删锁）
        long expireTime = 5000; // 锁过期时间（5秒）s
        dto.setLang(lang);

        // 解析语言代码
        String languageCode = parseLanguageCode(lang);

        // 如果不是中文环境，将查询条件中的翻译文本转换为中文简体
        if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
            convertUserTranslatedFieldsToChinese(dto.getUser(), languageCode);
        }

        try {
            // 尝试获取锁
            if (!redisLockUtil.tryLock(lockKey, requestId, expireTime)) {
                throw new BusinessException("操作太频繁，请稍后重试");
            }
            // 执行业务逻辑
            return goldDetailService.addExportRecordGold(dto);
        } finally {
            // 释放锁
            redisLockUtil.unlock(lockKey, requestId);
        }
    }

    @PostMapping("/exportqqq")
    public Result ExcelGoldDetail(@RequestBody Page page, @RequestHeader(defaultValue = "zh_CN") String lang) throws Exception {
        // 解析语言代码
        String languageCode = parseLanguageCode(lang);

        // 如果不是中文环境，将查询条件中的翻译文本转换为中文简体
        if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
            convertGoldDetailTranslatedFieldsToChinese(page.getGoldDetail(), languageCode);
        }

        if(ObjectUtils.isEmpty(page.getPageNum())){
            String errorMsg = languageTranslationUtil.translate("页码数为空！", lang);
            return Result.error(errorMsg);
        }
        if(ObjectUtils.isEmpty(page.getPageSize())){
            String errorMsg = languageTranslationUtil.translate("页大小为空！", lang);
            return Result.error(errorMsg);
        }
        else{
            Result result = Result.success(goldDetailService.getGoldDetail(page.getPageNum(), page.getPageSize(), page.getGoldDetail()));

            // 对返回结果进行多语言转换
            if (result.getCode() == 200 && result.getData() instanceof PageInfo) {
                PageInfo<GoldDetail> pageInfo = (PageInfo<GoldDetail>) result.getData();
                translateGoldDetails(pageInfo, lang);
            }

            return result;
        }
    }

    public Result ExcelGold(@RequestBody Page page, @RequestHeader(defaultValue = "zh_CN") String lang) throws Exception {
        // 解析语言代码
        String languageCode = parseLanguageCode(lang);

        // 如果不是中文环境，将查询条件中的翻译文本转换为中文简体
        if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
            convertUserTranslatedFieldsToChinese(page.getUser(), languageCode);
        }

        if(ObjectUtils.isEmpty(page.getPageNum())){
            String errorMsg = languageTranslationUtil.translate("页码数为空！", lang);
            return Result.error(errorMsg);
        }
        if(ObjectUtils.isEmpty(page.getPageSize())){
            String errorMsg = languageTranslationUtil.translate("页大小为空！", lang);
            return Result.error(errorMsg);
        }

        Result result = Result.success(goldDetailService.getGold(page.getPageNum(), page.getPageSize(), page.getUser()));

        // 对返回结果进行多语言转换
        if (result.getCode() == 200 && result.getData() instanceof PageInfo) {
            PageInfo<User> pageInfo = (PageInfo<User>) result.getData();
            translateUsers(pageInfo, lang);
        }

        return result;
    }

    //更新用户消费次数
    @PostMapping("/updateConsumeNum")
    public Result updateConsumeNum() {
        return goldDetailService.updateConsumeNum();
    }

    /**
     * 转换金币明细信息的多语言字段
     */
    private void translateGoldDetails(PageInfo<GoldDetail> pageInfo, String lang) {
        if (pageInfo != null && pageInfo.getList() != null) {
            for (GoldDetail detail : pageInfo.getList()) {
                // 翻译市场名称("所属地区")
                if (detail.getMarket() != null) {
                    detail.setMarket(languageTranslationUtil.translate(detail.getMarket(), lang));
                }
                // 翻译类型("更新类型") - 需要根据type的值进行转换
                if (detail.getType() != null) {
                    String typeDesc = convertTypeToString(detail.getType());
                    detail.setTypeDesc(languageTranslationUtil.translate(typeDesc, lang));
                }
                // 翻译商品名称("商品名称")
                if (detail.getGoodsName() != null) {
                    detail.setGoodsName(languageTranslationUtil.translate(detail.getGoodsName(), lang));
                }
            }
        }
    }

    /**
     * 将类型数字转换为中文描述
     */
    private String convertTypeToString(Integer type) {
        if (type == null) return "";
        switch (type) {
            case 0: return "充值";
            case 1: return "消耗";
            case 2: return "退款";
            default: return "其他";
        }
    }

    /**
     * 转换用户信息的多语言字段
     */
    private void translateUsers(PageInfo<User> pageInfo, String lang) {
        if (pageInfo != null && pageInfo.getList() != null) {
            for (User user : pageInfo.getList()) {
                // 翻译市场名称
                if (user.getMarket() != null) {
                    user.setMarket(languageTranslationUtil.translate(user.getMarket(), lang));
                }
            }
        }
    }

    /**
     * 解析语言代码
     */
    private String parseLanguageCode(String langHeader) {
        if (langHeader == null || langHeader.isEmpty()) {
            return "zh";
        }
        // 处理类似 "en-US" 或 "zh-TW" 的情况
        if (langHeader.contains("-")) {
            String[] parts = langHeader.split("-");
            // 特殊处理中文繁体
            if ("zh".equalsIgnoreCase(parts[0]) && "TW".equalsIgnoreCase(parts[1])) {
                return "zh_TW";
            }
            return parts[0].toLowerCase();
        }
        return langHeader.toLowerCase();
    }

    /**
     * 将金币明细查询条件中的翻译字段转换为中文简体
     */
    private void convertGoldDetailTranslatedFieldsToChinese(GoldDetail goldDetail, String languageCode) {
        if (goldDetail != null) {
            // 转换市场名称
            if (goldDetail.getMarket() != null && !goldDetail.getMarket().isEmpty()) {
                String chineseMarket = translationService.findChineseSimplifiedByTranslation(
                        goldDetail.getMarket(), languageCode);
                goldDetail.setMarket(chineseMarket);
            }

            // 转换商品名称
            if (goldDetail.getGoodsName() != null && !goldDetail.getGoodsName().isEmpty()) {
                String chineseGoodsName = translationService.findChineseSimplifiedByTranslation(
                        goldDetail.getGoodsName(), languageCode);
                goldDetail.setGoodsName(chineseGoodsName);
            }
        }
    }

    /**
     * 将用户查询条件中的翻译字段转换为中文简体
     */
    private void convertUserTranslatedFieldsToChinese(User user, String languageCode) {
        if (user != null) {
            // 转换市场名称
            if (user.getMarket() != null && !user.getMarket().isEmpty()) {
                String chineseMarket = translationService.findChineseSimplifiedByTranslation(
                        user.getMarket(), languageCode);
                user.setMarket(chineseMarket);
            }
        }
    }
}