package com.zy.asrs.controller;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.core.annotations.ManagerAuth;
import com.core.common.Cools;
import com.core.common.R;
import com.zy.asrs.domain.NotifyDto;
import com.zy.asrs.domain.NotifySendResult;
import com.zy.asrs.domain.param.NotifyResendParam;
import com.zy.asrs.domain.vo.NotifyReportVo;
import com.zy.asrs.entity.HttpRequestLog;
import com.zy.asrs.service.HttpRequestLogService;
import com.zy.asrs.service.NotifyAsyncService;
import com.zy.asrs.utils.NotifyUtils;
import com.zy.common.utils.RedisUtil;
import com.zy.common.web.BaseController;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

@RestController
public class NotifyReportController extends BaseController {

    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private NotifyUtils notifyUtils;
    @Autowired
    private NotifyAsyncService notifyAsyncService;
    @Autowired
    private HttpRequestLogService httpRequestLogService;
    @Autowired
    private ConfigService configService;

    @RequestMapping(value = "/notifyReport/summary/auth")
    @ManagerAuth
    public R summary() {
        Map<String, Object> result = new HashMap<>();
        String notifyEnable = getConfigValue("notifyEnable");
        String notifyUri = getConfigValue("notifyUri");
        String notifyUriPath = getConfigValue("notifyUriPath");
        String endpoint = buildNotifyEndpoint(notifyUri, notifyUriPath);

        result.put("notifyEnable", notifyEnable);
        result.put("notifyEnable$", "Y".equalsIgnoreCase(notifyEnable) ? "已开启" : "已关闭");
        result.put("notifyUri", notifyUri);
        result.put("notifyUriPath", notifyUriPath);
        result.put("notifyEndpoint", endpoint);
        result.put("queueCount", loadQueueRecords(null, null).size());
        if (!Cools.isEmpty(endpoint)) {
            result.put("logCount", httpRequestLogService.selectCount(new EntityWrapper<HttpRequestLog>().eq("name", endpoint)));
        } else {
            result.put("logCount", 0);
        }
        return R.ok(result);
    }

    @RequestMapping(value = "/notifyReport/queue/list/auth")
    @ManagerAuth
    public R queueList(@RequestParam(defaultValue = "1") Integer curr,
                       @RequestParam(defaultValue = "15") Integer limit,
                       @RequestParam(required = false) String notifyType,
                       @RequestParam(required = false) Integer device,
                       @RequestParam(required = false) String taskNo,
                       @RequestParam(required = false) String superTaskNo,
                       @RequestParam(required = false) String msgType,
                       @RequestParam(required = false) String condition) {
        List<NotifyReportVo> records = loadQueueRecords(notifyType, device);
        List<NotifyReportVo> filtered = new ArrayList<>();
        for (NotifyReportVo record : records) {
            if (!matchesQueue(record, notifyType, device, taskNo, superTaskNo, msgType, condition)) {
                continue;
            }
            filtered.add(record);
        }
        filtered.sort(Comparator.comparing(NotifyReportVo::getId, Comparator.nullsLast(Long::compareTo)).reversed());
        return R.ok(buildPage(curr, limit, filtered));
    }

    @RequestMapping(value = "/notifyReport/log/list/auth")
    @ManagerAuth
    public R logList(@RequestParam(defaultValue = "1") Integer curr,
                     @RequestParam(defaultValue = "15") Integer limit,
                     @RequestParam(required = false) String notifyType,
                     @RequestParam(required = false) Integer device,
                     @RequestParam(required = false) String taskNo,
                     @RequestParam(required = false) String superTaskNo,
                     @RequestParam(required = false) String msgType,
                     @RequestParam(required = false) Integer result,
                     @RequestParam(required = false) String condition) {
        String endpoint = buildNotifyEndpoint(getConfigValue("notifyUri"), getConfigValue("notifyUriPath"));
        EntityWrapper<HttpRequestLog> wrapper = new EntityWrapper<>();
        if (!Cools.isEmpty(endpoint)) {
            wrapper.eq("name", endpoint);
        } else {
            wrapper.like("request", "\"notifyType\"");
        }
        if (!Cools.isEmpty(taskNo)) {
            wrapper.like("request", taskNo);
        }
        if (!Cools.isEmpty(superTaskNo)) {
            wrapper.like("request", superTaskNo);
        }
        if (!Cools.isEmpty(msgType)) {
            wrapper.like("request", msgType);
        }
        if (!Cools.isEmpty(notifyType)) {
            wrapper.like("request", "\"notifyType\":\"" + notifyType + "\"");
        }
        if (device != null) {
            wrapper.like("request", "\"device\":" + device);
        }
        if (!Cools.isEmpty(condition)) {
            wrapper.andNew().like("request", condition).or().like("response", condition);
        }
        if (result != null) {
            wrapper.eq("result", result);
        }
        wrapper.orderBy("create_time", false);

        Page<HttpRequestLog> logPage = httpRequestLogService.selectPage(new Page<>(curr, limit), wrapper);
        Page<NotifyReportVo> resultPage = new Page<>(curr, limit);
        resultPage.setTotal(logPage.getTotal());

        List<NotifyReportVo> rows = new ArrayList<>();
        for (HttpRequestLog log : logPage.getRecords()) {
            rows.add(buildLogVo(log));
        }
        resultPage.setRecords(rows);
        return R.ok(resultPage);
    }

    @RequestMapping(value = "/notifyReport/resend/auth")
    @ManagerAuth
    public R resend(@RequestBody NotifyResendParam param) {
        if (param == null || Cools.isEmpty(param.getSourceType())) {
            return R.error("补发参数不能为空");
        }

        String notifyUri = getConfigValue("notifyUri");
        String notifyUriPath = getConfigValue("notifyUriPath");
        if (Cools.isEmpty(notifyUri) || Cools.isEmpty(notifyUriPath)) {
            return R.error("请先配置 notifyUri 和 notifyUriPath");
        }

        List<Map<String, Object>> details = new ArrayList<>();
        int successCount = 0;
        int failCount = 0;

        if ("queue".equalsIgnoreCase(param.getSourceType())) {
            if (Cools.isEmpty(param.getRedisKeys())) {
                return R.error("请选择要补发的队列通知");
            }
            for (String redisKey : param.getRedisKeys()) {
                Map<String, Object> detail = resendQueue(redisKey, notifyUri, notifyUriPath);
                details.add(detail);
                if (Boolean.TRUE.equals(detail.get("success"))) {
                    successCount++;
                } else {
                    failCount++;
                }
            }
        } else if ("log".equalsIgnoreCase(param.getSourceType())) {
            if (Cools.isEmpty(param.getLogIds())) {
                return R.error("请选择要补发的通知日志");
            }
            for (Long logId : param.getLogIds()) {
                Map<String, Object> detail = resendLog(logId, notifyUri, notifyUriPath);
                details.add(detail);
                if (Boolean.TRUE.equals(detail.get("success"))) {
                    successCount++;
                } else {
                    failCount++;
                }
            }
        } else {
            return R.error("不支持的补发来源");
        }

        Map<String, Object> result = new HashMap<>();
        result.put("successCount", successCount);
        result.put("failCount", failCount);
        result.put("allSuccess", failCount == 0);
        result.put("details", details);
        return R.ok(result);
    }

    private Page<NotifyReportVo> buildPage(Integer curr, Integer limit, List<NotifyReportVo> records) {
        Page<NotifyReportVo> page = new Page<>(curr, limit);
        page.setTotal(records.size());

        int fromIndex = Math.max((curr - 1) * limit, 0);
        if (fromIndex >= records.size()) {
            page.setRecords(new ArrayList<>());
            return page;
        }
        int toIndex = Math.min(fromIndex + limit, records.size());
        page.setRecords(new ArrayList<>(records.subList(fromIndex, toIndex)));
        return page;
    }

    private List<NotifyReportVo> loadQueueRecords(String notifyType, Integer device) {
        Set<String> keys = new LinkedHashSet<>();
        List<String> notifyTypes = new ArrayList<>();
        if (!Cools.isEmpty(notifyType)) {
            notifyTypes.add(notifyType);
        } else {
            notifyTypes.addAll(notifyUtils.getSupportedNotifyTypes());
        }

        for (String item : notifyTypes) {
            String prefix = notifyUtils.getKeyPrefix(item);
            if (Cools.isEmpty(prefix)) {
                continue;
            }

            String pattern = device == null ? prefix + "*" : prefix + device + "_*";
            Set matched = redisUtil.keys(pattern);
            if (matched == null) {
                continue;
            }
            for (Object key : matched) {
                if (key != null) {
                    keys.add(String.valueOf(key));
                }
            }
        }

        List<NotifyReportVo> rows = new ArrayList<>();
        for (String key : keys) {
            Object object = redisUtil.get(key);
            if (!(object instanceof NotifyDto)) {
                continue;
            }
            rows.add(buildQueueVo(key, (NotifyDto) object));
        }
        return rows;
    }

    private NotifyReportVo buildQueueVo(String redisKey, NotifyDto dto) {
        NotifyReportVo vo = new NotifyReportVo();
        vo.setSourceType("queue");
        vo.setRedisKey(redisKey);
        vo.setId(dto.getId());
        vo.setNotifyType(dto.getNotifyType());
        vo.setDevice(dto.getDevice());
        vo.setTaskNo(dto.getTaskNo());
        vo.setSuperTaskNo(dto.getSuperTaskNo());
        vo.setMsgType(dto.getMsgType());
        vo.setMsgDesc(dto.getMsgDesc());
        vo.setData(dto.getData());
        vo.setFailTimes(dto.getFailTimes());
        vo.setRetryTimes(dto.getRetryTimes());
        vo.setRetryTime(dto.getRetryTime());
        vo.setLastRetryTime(dto.getLastRetryTime());
        vo.setRequestPayload(JSON.toJSONString(dto));
        return vo;
    }

    private NotifyReportVo buildLogVo(HttpRequestLog log) {
        NotifyReportVo vo = new NotifyReportVo();
        vo.setSourceType("log");
        vo.setLogId(log.getId());
        vo.setCreateTime(log.getCreateTime());
        vo.setResult(log.getResult());
        vo.setResponse(log.getResponse());
        vo.setRequestPayload(log.getRequest());

        NotifyDto dto = parseNotifyDto(log.getRequest());
        if (dto != null) {
            vo.setId(dto.getId());
            vo.setNotifyType(dto.getNotifyType());
            vo.setDevice(dto.getDevice());
            vo.setTaskNo(dto.getTaskNo());
            vo.setSuperTaskNo(dto.getSuperTaskNo());
            vo.setMsgType(dto.getMsgType());
            vo.setMsgDesc(dto.getMsgDesc());
            vo.setData(dto.getData());
            vo.setFailTimes(dto.getFailTimes());
            vo.setRetryTimes(dto.getRetryTimes());
            vo.setRetryTime(dto.getRetryTime());
            vo.setLastRetryTime(dto.getLastRetryTime());
        } else {
            vo.setData(log.getRequest());
        }
        return vo;
    }

    private boolean matchesQueue(NotifyReportVo record, String notifyType, Integer device, String taskNo,
                                 String superTaskNo, String msgType, String condition) {
        if (!Cools.isEmpty(notifyType) && !notifyType.equals(record.getNotifyType())) {
            return false;
        }
        if (device != null && !device.equals(record.getDevice())) {
            return false;
        }
        if (!containsValue(record.getTaskNo(), taskNo)) {
            return false;
        }
        if (!containsValue(record.getSuperTaskNo(), superTaskNo)) {
            return false;
        }
        if (!containsValue(record.getMsgType(), msgType) && !containsValue(record.getMsgDesc(), msgType)) {
            return false;
        }
        if (Cools.isEmpty(condition)) {
            return true;
        }
        return containsValue(record.getTaskNo(), condition)
                || containsValue(record.getSuperTaskNo(), condition)
                || containsValue(record.getMsgType(), condition)
                || containsValue(record.getMsgDesc(), condition)
                || containsValue(record.getData(), condition)
                || containsValue(record.getNotifyType$(), condition)
                || containsValue(record.getRedisKey(), condition);
    }

    private boolean containsValue(String source, String target) {
        if (Cools.isEmpty(target)) {
            return true;
        }
        if (Cools.isEmpty(source)) {
            return false;
        }
        return source.contains(target);
    }

    private Map<String, Object> resendQueue(String redisKey, String notifyUri, String notifyUriPath) {
        Map<String, Object> detail = new HashMap<>();
        detail.put("sourceType", "queue");
        detail.put("redisKey", redisKey);

        Object object = redisUtil.get(redisKey);
        if (!(object instanceof NotifyDto)) {
            detail.put("success", false);
            detail.put("message", "队列通知不存在或已被消费");
            return detail;
        }

        NotifyDto notifyDto = (NotifyDto) object;
        NotifySendResult result = notifyAsyncService.sendNotifyNow(notifyUri, notifyUriPath, redisKey, notifyDto, true, false);
        detail.put("success", result.isSuccess());
        detail.put("message", result.getMessage());
        detail.put("taskNo", notifyDto.getTaskNo());
        detail.put("superTaskNo", notifyDto.getSuperTaskNo());
        detail.put("response", result.getResponse());
        return detail;
    }

    private Map<String, Object> resendLog(Long logId, String notifyUri, String notifyUriPath) {
        Map<String, Object> detail = new HashMap<>();
        detail.put("sourceType", "log");
        detail.put("logId", logId);

        HttpRequestLog log = httpRequestLogService.selectById(logId);
        if (log == null) {
            detail.put("success", false);
            detail.put("message", "通知日志不存在");
            return detail;
        }

        NotifyDto notifyDto = parseNotifyDto(log.getRequest());
        if (notifyDto == null) {
            detail.put("success", false);
            detail.put("message", "日志请求报文无法解析为通知对象");
            return detail;
        }

        NotifySendResult result = notifyAsyncService.sendNotifyNow(notifyUri, notifyUriPath, null, notifyDto, false, false);
        detail.put("success", result.isSuccess());
        detail.put("message", result.getMessage());
        detail.put("taskNo", notifyDto.getTaskNo());
        detail.put("superTaskNo", notifyDto.getSuperTaskNo());
        detail.put("response", result.getResponse());
        return detail;
    }

    private NotifyDto parseNotifyDto(String request) {
        if (Cools.isEmpty(request)) {
            return null;
        }
        try {
            return JSON.parseObject(request, NotifyDto.class);
        } catch (Exception ignored) {
            return null;
        }
    }

    private String getConfigValue(String code) {
        Config config = configService.selectOne(new EntityWrapper<Config>().eq("code", code));
        return config == null ? null : config.getValue();
    }

    private String buildNotifyEndpoint(String notifyUri, String notifyUriPath) {
        if (Cools.isEmpty(notifyUri) || Cools.isEmpty(notifyUriPath)) {
            return null;
        }
        return notifyUri + notifyUriPath;
    }
}