package com.example.demo.controller.coin;

import com.example.demo.config.interfac.Log;
import com.example.demo.domain.DTO.TranslationQueryRequest;
import com.example.demo.domain.entity.Translation;
import com.example.demo.domain.vo.coin.Result;
import com.example.demo.service.coin.TranslationService;
import com.example.demo.Util.LanguageTranslationUtil;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/language")
@RequiredArgsConstructor
@Slf4j
@CrossOrigin
public class TranslationController {

    private final TranslationService translationService;
    private final LanguageTranslationUtil languageTranslationUtil;

    // 查询所有翻译记录（可加条件）
    @PostMapping("/getTranslation")
    public Result getTranslations(@RequestBody TranslationQueryRequest request) {
        try {
            // 设置分页参数
            PageHelper.startPage(request.getPageNum(), request.getPageSize());

            String chineseSimplified = request.getChineseSimplified();
            String languageStatus = request.getLanguageStatus();

            List<Translation> translations;

            if (chineseSimplified != null && !chineseSimplified.isEmpty() &&
                    languageStatus != null && !languageStatus.isEmpty()) {
                // 同时存在模糊查询和语言状态查询
                String[] parts = languageStatus.split("/");
                if (parts.length != 2) {
                    return Result.error("languageStatus 参数格式错误，应为 'language/isTranslated'");
                }
                String language = parts[0];
                boolean isTranslated = Boolean.parseBoolean(parts[1]);
                translations = translationService.findByChineseSimplifiedAndLanguageStatus(
                        chineseSimplified, language, isTranslated);
            } else if (chineseSimplified != null && !chineseSimplified.isEmpty()) {
                // 只进行模糊查询
                translations = translationService.findByChineseSimplifiedLike(chineseSimplified);
            } else if (languageStatus != null && !languageStatus.isEmpty()) {
                // 只进行语言状态查询
                String[] parts = languageStatus.split("/");
                if (parts.length != 2) {
                    return Result.error("languageStatus 参数格式错误，应为 'language/isTranslated'");
                }
                String language = parts[0];
                boolean isTranslated = Boolean.parseBoolean(parts[1]);
                translations = translationService.findByLanguageAndTranslationStatus(language, isTranslated);
            } else {
                // 查询所有
                translations = translationService.findAll();
            }

            // 使用 PageInfo 封装分页结果
            PageInfo<Translation> pageInfo = new PageInfo<>(translations);

            // 构造返回数据
            Map<String, Object> resultData = new HashMap<>();
            resultData.put("list", pageInfo.getList());
            resultData.put("total", pageInfo.getTotal());
            resultData.put("pageNum", pageInfo.getPageNum());
            resultData.put("pageSize", pageInfo.getPageSize());

            return Result.success(resultData);
        } catch (IllegalArgumentException e) {
            return Result.error("参数错误：" + e.getMessage());
        } catch (Exception e) {
            log.error("查询翻译记录失败", e);
            return Result.error("查询翻译记录失败");
        }
    }

    // 添加新的翻译记录
    @Log("添加翻译记录")
    @PostMapping("/addTranslation")
    public Result addTranslation(@RequestBody Translation translation) {
        try {
            boolean result = translationService.add(translation);
            if (result) {
                return Result.success("添加翻译记录成功");
            } else {
                return Result.error("添加翻译记录失败");
            }
        } catch (RuntimeException e) {
            // 捕获重复插入异常
            if ("简体中文已存在".equals(e.getMessage())) {
                return Result.error("添加翻译记录失败：简体中文已存在");
            } else {
                log.error("添加翻译记录失败", e);
                return Result.error("添加翻译记录失败");
            }
        }
    }

    // 更新翻译记录
    @Log("更新翻译记录")
    @PostMapping("/updateTranslation")
    public Result updateTranslation(@RequestBody Translation translation) {
        try {
            boolean result = translationService.update(translation);
            if (result) {
                // 更新成功后刷新缓存
                languageTranslationUtil.refreshAllCache();
                return Result.success("更新翻译记录成功");
            } else {
                return Result.error("更新翻译记录失败");
            }
        } catch (Exception e) {
            log.error("更新翻译记录失败", e);
            return Result.error("更新翻译记录失败");
        }
    }

    // 删除翻译记录
    @Log("删除翻译记录")
    @PostMapping("/deleteTranslation")
    public Result deleteTranslation(@RequestBody Translation request) {
        try {
            // 先获取要删除的记录，用于后续清理缓存
            Translation translationToDelete = translationService.findById(request.getId());

            boolean result = translationService.deleteById(request.getId());
            if (result) {
                // 删除成功后清理相关缓存
                if (translationToDelete != null) {
                    languageTranslationUtil.removeFromCache(translationToDelete.getChineseSimplified());
                }
                return Result.success("删除翻译记录成功");
            } else {
                return Result.error("删除翻译记录失败");
            }
        } catch (Exception e) {
            log.error("删除翻译记录失败", e);
            return Result.error("删除翻译记录失败");
        }
    }

}