package com.zy.ai.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.core.annotations.ManagerAuth;
import com.core.common.R;
import com.zy.ai.entity.AiDataAnalysisReport;
import com.zy.ai.service.AiDataAnalysisReportService;
import com.zy.ai.service.DataAnalysisCoordinatorService;
import com.zy.common.web.BaseController;
import com.zy.system.service.ConfigService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

@Slf4j
@RestController
@RequestMapping("/ai/dataAnalysis")
@RequiredArgsConstructor
public class DataAnalysisController extends BaseController {

    private static final int DEFAULT_LIMIT = 20;
    private static final int MAX_LIMIT = 100;

    private final DataAnalysisCoordinatorService dataAnalysisCoordinatorService;
    private final AiDataAnalysisReportService aiDataAnalysisReportService;
    private final ConfigService configService;

    @GetMapping("/enabled/auth")
    @ManagerAuth(memo = "查询AI数据分析功能开关")
    public R getEnabled() {
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("enabled", dataAnalysisCoordinatorService.isEnabled());
        result.put("scheduledPeriods", configService.getConfigValue("aiDataAnalysisScheduledPeriods", "YESTERDAY"));
        result.put("cron", configService.getConfigValue("aiDataAnalysisCron", "0 0 1 * * ?"));
        result.put("uploadEnabled", "1".equals(configService.getConfigValue("aiDataAnalysisUploadEnabled", "0")));
        result.put("uploadUrl", configService.getConfigValue("aiDataAnalysisUploadUrl", ""));
        return R.ok(result);
    }

    @PostMapping("/enabled/auth")
    @ManagerAuth(memo = "修改AI数据分析功能开关")
    public R setEnabled(@RequestParam("enabled") String enabled) {
        boolean isEnabled = "1".equals(enabled) || "true".equalsIgnoreCase(enabled);
        log.info("AI数据分析开关切换: enabled={}, 原值={}", enabled, dataAnalysisCoordinatorService.isEnabled());
        dataAnalysisCoordinatorService.setEnabled(isEnabled);
        boolean saved = dataAnalysisCoordinatorService.isEnabled();
        log.info("AI数据分析开关保存结果: {}", saved);
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("enabled", saved);
        return R.ok(result);
    }

    @PostMapping("/trigger/auth")
    @ManagerAuth(memo = "手动触发AI数据分析")
    public R trigger(@RequestParam("periodType") String periodType) {
        return R.ok(dataAnalysisCoordinatorService.runManualAnalysis(periodType));
    }

    @GetMapping("/reports/auth")
    @ManagerAuth(memo = "查看AI数据分析报告列表")
    public R listReports(
            @RequestParam(value = "periodType", required = false) String periodType,
            @RequestParam(value = "limit", required = false) Integer limit) {
        int safeLimit = normalizeLimit(limit);
        QueryWrapper<AiDataAnalysisReport> wrapper = new QueryWrapper<>();
        if (periodType != null && !periodType.trim().isEmpty()) {
            wrapper.eq("period_type", periodType.trim());
        }
        wrapper.orderByDesc("create_time").last("limit " + safeLimit);
        List<AiDataAnalysisReport> reports = aiDataAnalysisReportService.list(wrapper);
        return R.ok(toReportSummaries(reports));
    }

    @GetMapping("/report/{id}/auth")
    @ManagerAuth(memo = "查看AI数据分析报告详情")
    public R getReport(@PathVariable("id") Long id) {
        AiDataAnalysisReport report = aiDataAnalysisReportService.getById(id);
        if (report == null) {
            return R.error("报告不存在");
        }
        return R.ok(toReportDetail(report));
    }

    private int normalizeLimit(Integer limit) {
        if (limit == null || limit <= 0) {
            return DEFAULT_LIMIT;
        }
        return Math.min(limit, MAX_LIMIT);
    }

    private List<Map<String, Object>> toReportSummaries(List<AiDataAnalysisReport> reports) {
        List<Map<String, Object>> result = new ArrayList<>();
        if (reports == null || reports.isEmpty()) {
            return result;
        }
        for (AiDataAnalysisReport report : reports) {
            result.add(toReportSummary(report));
        }
        return result;
    }

    private Map<String, Object> toReportSummary(AiDataAnalysisReport report) {
        LinkedHashMap<String, Object> item = new LinkedHashMap<>();
        item.put("id", report.getId());
        item.put("periodType", report.getPeriodType());
        item.put("triggerType", report.getTriggerType());
        item.put("status", report.getStatus());
        item.put("createTime", report.getCreateTime());
        item.put("finishTime", report.getFinishTime());
        item.put("llmCallCount", report.getLlmCallCount());
        item.put("totalTokens", report.getTotalTokens());
        item.put("uploadStatus", report.getUploadStatus());
        return item;
    }

    private Map<String, Object> toReportDetail(AiDataAnalysisReport report) {
        LinkedHashMap<String, Object> item = new LinkedHashMap<>();
        item.put("id", report.getId());
        item.put("periodType", report.getPeriodType());
        item.put("periodStart", report.getPeriodStart());
        item.put("periodEnd", report.getPeriodEnd());
        item.put("triggerType", report.getTriggerType());
        item.put("status", report.getStatus());
        item.put("summary", report.getSummary());
        item.put("structuredData", report.getStructuredData());
        item.put("llmCallCount", report.getLlmCallCount());
        item.put("promptTokens", report.getPromptTokens());
        item.put("completionTokens", report.getCompletionTokens());
        item.put("totalTokens", report.getTotalTokens());
        item.put("errorMessage", report.getErrorMessage());
        item.put("localFilePath", report.getLocalFilePath());
        item.put("uploadStatus", report.getUploadStatus());
        item.put("createTime", report.getCreateTime());
        item.put("finishTime", report.getFinishTime());
        return item;
    }
}