gold-java/src/main/java/com/example/demo/controller/coin/RechargeActivityCenterController.java

package com.example.demo.controller.coin;

import com.example.demo.config.interfac.Log;
import com.example.demo.domain.vo.coin.AreaInfo;
import com.example.demo.domain.vo.coin.Page;
import com.example.demo.domain.vo.coin.RechargeActivity;
import com.example.demo.domain.vo.coin.Result;
import com.example.demo.service.coin.RechargeActivityCenterService;
import com.example.demo.Util.LanguageTranslationUtil;
import com.example.demo.service.coin.TranslationService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @program: gold-java
 * @ClassName RechargeActivityCenterController
 * @description: 充值活动中心管理
 * @author: Double
 * @create: 2025−11-04 14:23
 * @Version 1.0
 **/

@RestController
@RequestMapping("/admin/coin/rechargeActivityCenter")
@RequiredArgsConstructor
@Slf4j
@CrossOrigin
public class RechargeActivityCenterController {

    @Autowired
    private RechargeActivityCenterService rechargeActivityCenterService;

    // 注入多语言转换工具类
    @Autowired
    private LanguageTranslationUtil languageTranslationUtil;

    @Autowired
    private TranslationService translationService;

    /**
     * 导出用户权限数据
     *
     * @param page 导出请求参数）
     * @return 导出结果（成功返回活动信息，失败返回错误信息）
     * @throws NullPointerException     当参数为空时抛出（如activity为null、关键属性为null）
     * @throws IllegalArgumentException 当参数无效时抛出（如活动ID非法、参数格式错误）
     */
    @Log("条件查询充值活动")
    @PostMapping("/queryActivity")
    public Result queryActivity(@RequestBody Page page, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            // 解析语言代码
            String languageCode = parseLanguageCode(lang);

            // 如果不是中文环境，将查询条件中的翻译文本转换为中文简体
            if (!"zh".equalsIgnoreCase(languageCode) && !"zh_cn".equalsIgnoreCase(languageCode)) {
                convertTranslatedQueryFieldsToChinese(page.getRechargeActivity(), 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);
            }
            if (page.getRechargeActivity() == null) {
                String errorMsg = languageTranslationUtil.translate("查询失败：活动信息不能为空", lang);
                return Result.error(errorMsg);
            }

            Result result = Result.success(rechargeActivityCenterService.queryActivity(page.getPageNum(), page.getPageSize(), page.getRechargeActivity()));

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

            return result;
        } catch (NullPointerException e) {
            log.error("查询活动失败：空指针异常", e);
            String errorMsg = languageTranslationUtil.translate("查询失败：数据为空", lang);
            return Result.error(errorMsg);
        } catch (IllegalArgumentException e) {
            log.error("查询活动失败：参数异常", e);
            String errorMsg = languageTranslationUtil.translate("查询失败：" + e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }

    /**
     * 新增充值活动
     *
     * @param activity 充值活动请求参数（包含活动名称、活动规则等信息）
     * @return 新增结果（成功返回提示信息，失败返回错误原因）
     * @throws NullPointerException     当请求参数为空时抛出（如activity为null、活动名称等关键属性为null）
     * @throws IllegalArgumentException 当请求参数无效时抛出（如活动名称为空字符串、参数格式不符合要求等）
     */
    @Log("新增充值活动")
    @PostMapping("/addActivity")
    public Result addActivity(@RequestBody RechargeActivity activity, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            // 解析语言代码
            String languageCode = parseLanguageCode(lang);

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

            if (activity == null) {
                String errorMsg = languageTranslationUtil.translate("添加失败：活动信息不能为空", lang);
                return Result.error(errorMsg);
            }
            if (activity.getActivityName() == null || activity.getActivityName().trim().isEmpty()) {
                String errorMsg = languageTranslationUtil.translate("添加失败：活动名称不能为空", lang);
                return Result.error(errorMsg);
            }
            if (activity.getBusinessBelong() == null || activity.getBusinessBelong().trim().isEmpty()) {
                String errorMsg = languageTranslationUtil.translate("添加失败：业绩归属地不能为空", lang);
                return Result.error(errorMsg);
            }else if (activity.getBusinessBelong().equals("活动归属地")) {
                if (activity.getArea() == null || activity.getArea().trim().isEmpty()) {
                    String errorMsg = languageTranslationUtil.translate("添加失败：地区不能为空", lang);
                    return Result.error(errorMsg);
                }
            }
            if (activity.getStartTime() == null) {
                String errorMsg = languageTranslationUtil.translate("添加失败：活动开始时间不能为空", lang);
                return Result.error(errorMsg);
            }
            if (activity.getEndTime() == null) {
                String errorMsg = languageTranslationUtil.translate("添加失败：活动结束时间不能为空", lang);
                return Result.error(errorMsg);
            }
            if (activity.getEndTime().before(activity.getStartTime())) {
                String errorMsg = languageTranslationUtil.translate("添加失败：活动结束时间必须晚于活动开始时间", lang);
                return Result.error(errorMsg);
            }
            if (activity.getCreator() == null || activity.getCreator().trim().isEmpty()) {
                String errorMsg = languageTranslationUtil.translate("添加失败：添加人不能为空", lang);
                return Result.error(errorMsg);
            }
            rechargeActivityCenterService.addActivity(activity);
            String successMsg = languageTranslationUtil.translate("添加活动成功", lang);
            return Result.success(successMsg);
        } catch (NullPointerException e) {
            log.error("添加活动失败：空指针异常", e);
            String errorMsg = languageTranslationUtil.translate("添加失败：数据为空", lang);
            return Result.error(errorMsg);
        } catch (IllegalArgumentException e) {
            log.error("添加活动失败：参数异常", e);
            String errorMsg = languageTranslationUtil.translate("添加失败：" + e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }

    /**
     * 更新充值活动
     *
     * @param activity 充值活动更新参数（包含活动ID、待更新的活动名称等信息）
     * @return 更新结果（成功返回提示信息，失败返回错误原因）
     * @throws NullPointerException     当请求参数为空时抛出（如activity为null、活动ID、活动名称等关键属性为null）
     * @throws IllegalArgumentException 当请求参数无效时抛出（如活动名称为空字符串、活动ID格式错误等）
     */
    @Log("更新充值活动")
    @PostMapping("/updateActivity")
    public Result updateActivity(@RequestBody RechargeActivity activity, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            // 解析语言代码
            String languageCode = parseLanguageCode(lang);

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

            if (activity == null) {
                String errorMsg = languageTranslationUtil.translate("添加失败：活动信息不能为空", lang);
                return Result.error(errorMsg);
            }
            if (activity.getId() == null) {
                String errorMsg = languageTranslationUtil.translate("添加失败：活动ID不能为空", lang);
                return Result.error(errorMsg);
            }
            if (activity.getActivityName() == null || activity.getActivityName().trim().isEmpty()) {
                String errorMsg = languageTranslationUtil.translate("添加失败：活动名称不能为空", lang);
                return Result.error(errorMsg);
            }
            if (activity.getBusinessBelong() == null || activity.getBusinessBelong().trim().isEmpty()) {
                String errorMsg = languageTranslationUtil.translate("添加失败：业绩归属地不能为空", lang);
                return Result.error(errorMsg);
            }else if (activity.getBusinessBelong().equals("活动归属地")) {
                if (activity.getArea() == null || activity.getArea().trim().isEmpty()) {
                    String errorMsg = languageTranslationUtil.translate("添加失败：地区不能为空", lang);
                    return Result.error(errorMsg);
                }
            }
            if (activity.getStartTime() == null) {
                String errorMsg = languageTranslationUtil.translate("添加失败：活动开始时间不能为空", lang);
                return Result.error(errorMsg);
            }
            if (activity.getEndTime() == null) {
                String errorMsg = languageTranslationUtil.translate("添加失败：活动结束时间不能为空", lang);
                return Result.error(errorMsg);
            }
            if (activity.getEndTime().before(activity.getStartTime())) {
                String errorMsg = languageTranslationUtil.translate("添加失败：活动结束时间必须晚于活动开始时间", lang);
                return Result.error(errorMsg);
            }
            if (activity.getCreator() == null || activity.getCreator().trim().isEmpty()) {
                String errorMsg = languageTranslationUtil.translate("添加失败：添加人不能为空", lang);
                return Result.error(errorMsg);
            }
            rechargeActivityCenterService.updateActivity(activity);
            String successMsg = languageTranslationUtil.translate("更新活动成功", lang);
            return Result.success(successMsg);
        } catch (NullPointerException e) {
            log.error("更新活动失败：空指针异常", e);
            String errorMsg = languageTranslationUtil.translate("更新失败：数据为空", lang);
            return Result.error(errorMsg);
        } catch (IllegalArgumentException e) {
            log.error("更新活动失败：参数异常", e);
            String errorMsg = languageTranslationUtil.translate("更新失败：" + e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }

    /**
     * 删除充值活动
     *
     * @param activity 待删除的充值活动ID
     * @return 删除结果（成功返回提示信息，失败返回错误原因）
     * @throws NullPointerException     当活动ID为空时抛出（如id为null）
     * @throws IllegalArgumentException 当活动ID无效时抛出（如id为负数、非整数格式等不符合业务要求的情况）
     */
    @Log("删除充值活动")
    @PostMapping("/deleteActivity")
    public Result deleteActivity(@RequestBody RechargeActivity activity, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            if (activity.getId() == null) {
                String errorMsg = languageTranslationUtil.translate("删除失败：活动ID不能为空", lang);
                return Result.error(errorMsg);
            }
            rechargeActivityCenterService.deleteActivity(activity);
            String successMsg = languageTranslationUtil.translate("删除活动成功", lang);
            return Result.success(successMsg);
        } catch (NullPointerException e) {
            log.error("删除活动失败：空指针异常", e);
            String errorMsg = languageTranslationUtil.translate("删除失败：数据为空", lang);
            return Result.error(errorMsg);
        } catch (IllegalArgumentException e) {
            log.error("删除活动失败：参数异常", e);
            String errorMsg = languageTranslationUtil.translate("删除失败：" + e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }

    /**
     * 根据活动 ID 查询归属地
     *
     * @param activity 充值活动请求参数（包含活动 ID）
     * @return 查询结果（成功返回归属地信息，失败返回错误信息）
     * @throws NullPointerException     当活动 ID 为空时抛出
     * @throws IllegalArgumentException 当活动 ID 无效时抛出
     */
    @Log("查询活动归属地")
    @PostMapping("/queryActivityArea")
    public Result queryActivityArea(@RequestBody RechargeActivity activity, @RequestHeader(defaultValue = "zh_CN") String lang) {
        try {
            // 解析语言代码
            String languageCode = parseLanguageCode(lang);

            if (activity.getId() == null) {
                String errorMsg = languageTranslationUtil.translate("查询失败：活动 ID 不能为空", lang);
                return Result.error(errorMsg);
            }

            AreaInfo result = rechargeActivityCenterService.queryActivityAreaById(activity.getId());

            // 如果 area 为 "0"，直接返回
            if ("0".equals(result.getArea())) {
                return Result.success(result);
            }

            // 对返回结果进行多语言转换
            if (result.getArea() != null && !result.getArea().isEmpty()) {
                result.setArea(languageTranslationUtil.translate(result.getArea(), lang));
            }
            if (result.getAreaName() != null && !result.getAreaName().isEmpty()) {
                result.setAreaName(languageTranslationUtil.translate(result.getAreaName(), lang));
            }

            return Result.success(result);
        } catch (NullPointerException e) {
            log.error("查询活动归属地失败：空指针异常", e);
            String errorMsg = languageTranslationUtil.translate("查询失败：数据为空", lang);
            return Result.error(errorMsg);
        } catch (IllegalArgumentException e) {
            log.error("查询活动归属地失败：参数异常", e);
            String errorMsg = languageTranslationUtil.translate("查询失败：" + e.getMessage(), lang);
            return Result.error(errorMsg);
        }
    }

    /**
     * 转换充值活动的多语言字段
     */
    private void translateRechargeActivities(com.github.pagehelper.PageInfo<RechargeActivity> pageInfo, String lang) {
        if (pageInfo != null && pageInfo.getList() != null) {
            for (RechargeActivity activity : pageInfo.getList()) {
                // 翻译业务归属
                if (activity.getBusinessBelong() != null) {
                    activity.setBusinessBelong(languageTranslationUtil.translate(activity.getBusinessBelong(), lang));
                }
                // 翻译地区名称
                if (activity.getAreaName() != null) {
                    activity.setAreaName(languageTranslationUtil.translate(activity.getAreaName(), 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 convertTranslatedQueryFieldsToChinese(RechargeActivity activity, String languageCode) {
        if (activity != null) {
            // 转换业务归属
            if (activity.getBusinessBelong() != null && !activity.getBusinessBelong().isEmpty()) {
                String chineseBelong = translationService.findChineseSimplifiedByTranslation(
                        activity.getBusinessBelong(), languageCode);
                activity.setBusinessBelong(chineseBelong);
            }

            // 转换地区
            if (activity.getAreaName() != null && !activity.getAreaName().isEmpty()) {
                String chineseArea = translationService.findChineseSimplifiedByTranslation(
                        activity.getAreaName(), languageCode);
                activity.setAreaName(chineseArea);
            }
        }
    }

    /**
     * 将活动字段中的翻译字段转换为中文简体
     */
    private void convertTranslatedActivityFieldsToChinese(RechargeActivity activity, String languageCode) {
        if (activity != null) {
            // 转换业务归属
            if (activity.getBusinessBelong() != null && !activity.getBusinessBelong().isEmpty()) {
                String chineseBelong = translationService.findChineseSimplifiedByTranslation(
                        activity.getBusinessBelong(), languageCode);
                activity.setBusinessBelong(chineseBelong);
            }

            // 转换地区
            if (activity.getArea() != null && !activity.getArea().isEmpty()) {
                String chineseArea = translationService.findChineseSimplifiedByTranslation(
                        activity.getArea(), languageCode);
                activity.setArea(chineseArea);
            }
        }
    }
}