package com.example.demo.controller.coin;

import com.example.demo.Util.JWTUtil;
import com.example.demo.Util.LanguageTranslationUtil;
import com.example.demo.config.interfac.Log;
import com.example.demo.domain.entity.Admin;
import com.example.demo.service.coin.AuditService;
import com.example.demo.service.coin.TranslationService;
import com.example.demo.serviceImpl.coin.AuditServiceImpl;
import com.github.pagehelper.PageInfo;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import com.example.demo.domain.vo.coin.*;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @program: gold-java
 * @ClassName AuditController
 * @description: 审核模块
 * @author: Ethan
 * @create: 2025−06-19 17:30
 * @Version 1.0
 **/

@RestController
@RequestMapping("/audit")
@RequiredArgsConstructor
@Slf4j

@CrossOrigin
public class AuditController {

    @Autowired
    private AuditService auditService;

    @Autowired
    private LanguageTranslationUtil languageTranslationUtil;

    @Autowired
    private TranslationService translationService;

    //审核订单
    @Log("审核订单")
    @PostMapping("audit")
    public ResponseEntity<Map<String, Object>> auditOrder(@RequestBody AuditRequest request) throws Exception {
        boolean result = auditService.auditOrder(request.getToken(), request.getOrderCode(), request.getAuditId(),
                request.getAction(), request.getRejectReason(), request.getPrice(), request.getLinkId(), request.getRefundModel()
        );

        Map<String, Object> resp = new HashMap<>();
        resp.put("success", result);
        if (!result) {
            resp.put("message", AuditServiceImpl.AuditContext.getFailMsg());
        } else {
            resp.put("message", "审核成功");
        }

        AuditServiceImpl.AuditContext.clear(); // 必须清理
        return ResponseEntity.ok(resp);
    }

    //多条件查询充值审核订单列表
    @Log("查询充值审核订单列表")
    @PostMapping("selectRecharge")
    public PageInfo<RechargeAudit> searchRechargeAudit(
            @RequestBody Page page,
            @RequestHeader(defaultValue = "zh_CN") String lang) throws Exception {
        Integer pageNum = page.getPageNum();
        Integer pageSize = page.getPageSize();
        RechargeAudit rechargeAudit = page.getRechargeAudit();

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

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

        //解token权限
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token = request.getHeader("token");
        Admin admin = (Admin) JWTUtil.getUserDetailsList(String.valueOf(token), Admin.class);
        if (admin != null) {
            List<String> list = Arrays.asList(admin.getMarkets().split(","));
            rechargeAudit.setMarkets(list);
        }

        PageInfo<RechargeAudit> pageInfo = auditService.selectRechargeBy(pageNum, pageSize, rechargeAudit);
        // 对结果进行多语言转换
        translateRechargeAuditResults(pageInfo, lang);
        return pageInfo;
    }


    //多条件查询退款审核订单列表
    @Log("查询退款审核订单列表")
    @PostMapping("selectRefund")
    public PageInfo<RefundAudit> searchRefundAudit(
            @RequestBody Page page,
            @RequestHeader(defaultValue = "zh_CN") String lang) throws Exception {
        Integer pageNum = page.getPageNum();
        Integer pageSize = page.getPageSize();
        RefundAudit refundAudit = page.getRefundAudit();

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

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

        //解token权限
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token = request.getHeader("token");
        Admin admin = (Admin) JWTUtil.getUserDetailsList(String.valueOf(token), Admin.class);
        if (admin != null) {
            List<String> list = Arrays.asList(admin.getMarkets().split(","));
            refundAudit.setMarkets(list);
        }

        PageInfo<RefundAudit> pageInfo = auditService.selectRefundBy(pageNum, pageSize, refundAudit);
        // 对结果进行多语言转换
        translateRefundAuditResults(pageInfo, lang);
        return pageInfo;
    }

    //充值审核合计数
    @Log("充值审核合计数")
    @PostMapping("sumRechargeGold")
    public Gold sumRechargeGold(@RequestBody Page page)throws  Exception {
        Integer pageNum = page.getPageNum();
        Integer pageSize = page.getPageSize();
        RechargeAudit rechargeAudit = page.getRechargeAudit();
        //解token权限
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token = request.getHeader("token");
        Admin admin = (Admin) JWTUtil.getUserDetailsList(String.valueOf(token), Admin.class);
        if (admin != null) {
            List<String> list = Arrays.asList(admin.getMarkets().split(","));
            rechargeAudit.setMarkets(list);
        }
        return auditService.sumRechargeGold(pageNum, pageSize, rechargeAudit);
    }
    //退款审核合计数
    @Log("退款审核合计数")
    @PostMapping("sumRefundGold")
    public Gold sumRefundGold(@RequestBody Page page) throws  Exception{
        Integer pageNum = page.getPageNum();
        Integer pageSize = page.getPageSize();
        RefundAudit refundAudit = page.getRefundAudit();
        //解token权限
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token = request.getHeader("token");
        Admin admin = (Admin) JWTUtil.getUserDetailsList(String.valueOf(token), Admin.class);
        if (admin != null) {
            List<String> list = Arrays.asList(admin.getMarkets().split(","));
            refundAudit.setMarkets(list);
        }
        return auditService.sumRefundGold(pageNum, pageSize, refundAudit);
    }
    /**
     * 转换充值审核结果的多语言字段
     */
    private void translateRechargeAuditResults(PageInfo<RechargeAudit> pageInfo, String lang) {
        if (pageInfo != null && pageInfo.getList() != null) {
            for (RechargeAudit audit : pageInfo.getList()) {
                // 翻译市场名称
                if (audit.getMarket() != null) {
                    audit.setMarket(languageTranslationUtil.translate(audit.getMarket(), lang));
                }
                // 翻译汇率名称
                if (audit.getRateName() != null) {
                    audit.setRateName(languageTranslationUtil.translate(audit.getRateName(), lang));
                }
                // 翻译支付方式
                if (audit.getPayModel() != null) {
                    audit.setPayModel(languageTranslationUtil.translate(audit.getPayModel(), lang));
                }
                // 翻译备注
                if (audit.getRemark() != null) {
                    audit.setRemark(languageTranslationUtil.translate(audit.getRemark(), lang));
                }
            }
        }
    }

    /**
     * 转换退款审核结果的多语言字段
     */
    private void translateRefundAuditResults(PageInfo<RefundAudit> pageInfo, String lang) {
        if (pageInfo != null && pageInfo.getList() != null) {
            for (RefundAudit audit : pageInfo.getList()) {
                // 翻译市场名称
                if (audit.getMarket() != null) {
                    audit.setMarket(languageTranslationUtil.translate(audit.getMarket(), lang));
                }
                // 翻译商品名称
                if (audit.getGoodsName() != null) {
                    audit.setGoodsName(languageTranslationUtil.translate(audit.getGoodsName(), lang));
                }
                // 翻译退款方式
                if (audit.getRefundModel() != null) {
                    // refundModel是数字，需要先转换为对应的中文描述再翻译
                    String refundModelDesc = convertRefundModelToString(audit.getRefundModel());
                    audit.setRefundModelDesc(languageTranslationUtil.translate(refundModelDesc, lang));
                }
                // 翻译退款类型
                if (audit.getRefundType() != null) {
                    audit.setRefundType(languageTranslationUtil.translate(audit.getRefundType(), lang));
                }
                // 翻译备注
                if (audit.getRemark() != null) {
                    audit.setRemark(languageTranslationUtil.translate(audit.getRemark(), lang));
                }
            }
        }
    }

    /**
     * 将退款方式数字转换为中文描述
     */
    private String convertRefundModelToString(Integer refundModel) {
        if (refundModel == null) return "";
        switch (refundModel) {
            case 0:
                return "全部退款";
            case 1:
                return "部分退款";
            default:
                return "未知退款方式";
        }
    }

    /**
     * 解析语言代码
     */
    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 convertRechargeTranslatedFieldsToChinese(RechargeAudit rechargeAudit, String languageCode) {
        if (rechargeAudit != null) {
            // 转换市场名称
            if (rechargeAudit.getMarket() != null && !rechargeAudit.getMarket().isEmpty()) {
                String chineseMarket = translationService.findChineseSimplifiedByTranslation(
                        rechargeAudit.getMarket(), languageCode);
                rechargeAudit.setMarket(chineseMarket);
            }

            // 转换汇率名称
            if (rechargeAudit.getRateName() != null && !rechargeAudit.getRateName().isEmpty()) {
                String chineseRateName = translationService.findChineseSimplifiedByTranslation(
                        rechargeAudit.getRateName(), languageCode);
                rechargeAudit.setRateName(chineseRateName);
            }

            // 转换支付方式
            if (rechargeAudit.getPayModel() != null && !rechargeAudit.getPayModel().isEmpty()) {
                String chinesePayModel = translationService.findChineseSimplifiedByTranslation(
                        rechargeAudit.getPayModel(), languageCode);
                rechargeAudit.setPayModel(chinesePayModel);
            }

            // 转换备注
            if (rechargeAudit.getRemark() != null && !rechargeAudit.getRemark().isEmpty()) {
                String chineseRemark = translationService.findChineseSimplifiedByTranslation(
                        rechargeAudit.getRemark(), languageCode);
                rechargeAudit.setRemark(chineseRemark);
            }
        }
    }

    /**
     * 将退款审核查询条件中的翻译字段转换为中文简体
     */
    private void convertRefundTranslatedFieldsToChinese(RefundAudit refundAudit, String languageCode) {
        if (refundAudit != null) {
            // 转换市场名称
            if (refundAudit.getMarket() != null && !refundAudit.getMarket().isEmpty()) {
                String chineseMarket = translationService.findChineseSimplifiedByTranslation(
                        refundAudit.getMarket(), languageCode);
                refundAudit.setMarket(chineseMarket);
            }

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

            // 转换退款类型
            if (refundAudit.getRefundType() != null && !refundAudit.getRefundType().isEmpty()) {
                String chineseRefundType = translationService.findChineseSimplifiedByTranslation(
                        refundAudit.getRefundType(), languageCode);
                refundAudit.setRefundType(chineseRefundType);
            }

            // 转换备注
            if (refundAudit.getRemark() != null && !refundAudit.getRemark().isEmpty()) {
                String chineseRemark = translationService.findChineseSimplifiedByTranslation(
                        refundAudit.getRemark(), languageCode);
                refundAudit.setRemark(chineseRemark);
            }
        }
    }

}