package com.controller;

import com.collector.CollectScheduler;
import com.common.entity.DeviceApiCollectLog;
import com.common.entity.DeviceApiConfig;
import com.common.service.DeviceApiCollectLogService;
import com.common.service.DeviceApiConfigService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

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

/**
 * API 采集配置管理接口
 */
@RestController
@RequestMapping("/api/collect")
public class DeviceApiCollectController {

    @Autowired
    private DeviceApiConfigService configService;

    @Autowired
    private DeviceApiCollectLogService collectLogService;

    @Autowired
    private CollectScheduler collectScheduler;

    /**
     * 全量回补功能开关，默认禁用
     */
    @Value("${device.collect.full.enabled:false}")
    private boolean fullCollectEnabled;

    /**
     * 手动触发采集（功能测试用）
     * 按配置ID立即执行一次采集，不走定时调度。
     *
     * @param id       设备配置ID
     * @param dataType 数据类型（可选，为空则采集配置中所有类型）
     * @param minutes  回看窗口分钟数（可选，默认最近1小时）
     */
    @PostMapping("/trigger")
    public Map<String, Object> trigger(@RequestParam Long id,
                                       @RequestParam(required = false) String dataType,
                                       @RequestParam(required = false) Integer minutes) {
        Map<String, Object> result = collectScheduler.collectNow(id, dataType, minutes);
        return success(result);
    }

    /**
     * 手动全量回补采集（同步执行，默认禁用）
     * 把 [startTime, endTime] 区间内历史数据（如天眼 weblog）按子窗口由旧到新滚动逐段完整采集，
     * 用于首次部署全量导入 / 漏采补数。区间较大时请求会持续较久，请按需控制 backDays/startTime。
     * 该功能由配置项 device.collect.full.enabled 控制，默认 false（禁用）。
     *
     * @param id              设备配置ID
     * @param dataType        数据类型，逗号分隔，如 weblog；为空则取配置中所有类型
     * @param startTime       起始时间（毫秒时间戳，可选）
     * @param endTime         结束时间（毫秒时间戳，可选，默认当前时间-1分钟）
     * @param backDays        回看天数（startTime 为空时生效，默认1天）
     * @param windowMinutes   子窗口分钟数（可选，默认30分钟）
     * @param continueOnError 单个子窗口失败是否继续（可选，默认false，失败即终止）
     */
    @PostMapping("/full")
    public Map<String, Object> submitFull(@RequestParam Long id,
                                          @RequestParam(required = false) String dataType,
                                          @RequestParam(required = false) Long startTime,
                                          @RequestParam(required = false) Long endTime,
                                          @RequestParam(required = false) Integer backDays,
                                          @RequestParam(required = false) Integer windowMinutes,
                                          @RequestParam(required = false) Boolean continueOnError) {
        if (!fullCollectEnabled) {
            Map<String, Object> result = new HashMap<>();
            result.put("code", 1);
            result.put("message", "全量回补功能已禁用，请先设置 device.collect.full.enabled=true 后重启服务");
            return result;
        }
        return success(collectScheduler.collectFull(id, dataType, startTime, endTime,
                backDays, windowMinutes, continueOnError));
    }

    /**
     * 查询所有采集配置
     */
    @GetMapping("/config/list")
    public Map<String, Object> listConfig() {
        List<DeviceApiConfig> list = configService.listAll();
        return success(list);
    }

    /**
     * 查询启用的采集配置
     */
    @GetMapping("/config/enabled")
    public Map<String, Object> listEnabled() {
        List<DeviceApiConfig> list = configService.listEnabled();
        return success(list);
    }

    /**
     * 新增采集配置
     */
    @PostMapping("/config/add")
    public Map<String, Object> addConfig(@RequestBody DeviceApiConfig config) {
        if (config.getEnabled() == null) {
            config.setEnabled(1);
        }
        configService.add(config);
        return success("新增成功");
    }

    /**
     * 更新采集配置
     */
    @PostMapping("/config/update")
    public Map<String, Object> updateConfig(@RequestBody DeviceApiConfig config) {
        configService.update(config);
        return success("更新成功");
    }

    /**
     * 启用/停用采集配置
     */
    @PostMapping("/config/enabled")
    public Map<String, Object> updateEnabled(@RequestParam Long id, @RequestParam Integer enabled) {
        configService.updateEnabled(id, enabled);
        return success("操作成功");
    }

    /**
     * 删除采集配置
     */
    @PostMapping("/config/delete")
    public Map<String, Object> deleteConfig(@RequestParam Long id) {
        configService.delete(id);
        return success("删除成功");
    }

    /**
     * 查询采集日志（按设备类型）
     */
    @GetMapping("/log/device-type")
    public Map<String, Object> listLogByType(@RequestParam String deviceType) {
        List<DeviceApiCollectLog> list = collectLogService.listByDeviceType(deviceType);
        return success(list);
    }

    /**
     * 清理指定日期前的采集日志
     */
    @PostMapping("/log/clean")
    public Map<String, Object> cleanLog(@RequestParam String beforeDate) {
        LocalDateTime before = LocalDateTime.parse(beforeDate);
        int count = collectLogService.cleanBefore(before);
        Map<String, Object> data = new HashMap<>();
        data.put("deleted", count);
        return success(data);
    }

    /**
     * 采集器健康检查
     */
    @GetMapping("/health")
    public Map<String, Object> health() {
        Map<String, Object> data = new HashMap<>();
        data.put("status", "UP");
        data.put("time", LocalDateTime.now().toString());
        return success(data);
    }

    private Map<String, Object> success(Object data) {
        Map<String, Object> result = new HashMap<>();
        result.put("code", 0);
        result.put("message", "success");
        result.put("data", data);
        return result;
    }
}