package com.vincent.rsf.server.common.service.impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.vincent.rsf.framework.common.Cools;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.common.domain.BaseParam;
import com.vincent.rsf.server.common.service.AsyncListExportTaskService;
import com.vincent.rsf.server.common.service.ListExportHandler;
import com.vincent.rsf.server.common.service.ListExportService;
import com.vincent.rsf.server.system.entity.ExportTask;
import com.vincent.rsf.server.system.service.ExportTaskService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.usermodel.Workbook;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Date;
import java.util.Map;
import java.util.Objects;
import java.util.UUID;
import java.util.function.Function;

@Slf4j
@Service
@RequiredArgsConstructor
public class AsyncListExportTaskServiceImpl implements AsyncListExportTaskService {
    private final ExportTaskService exportTaskService;
    private final ListExportService listExportService;

    @Value("${logging.file.path:logs}")
    private String loggingFilePath;

    @Value("${rsf.export-task.expire-days:7}")
    private int exportTaskExpireDays;

    @Override
    public ExportTask createTask(
            String resourceKey,
            String defaultReportTitle,
            Map<String, Object> payload,
            Long tenantId,
            Long userId
    ) {
        ExportTask task = new ExportTask();
        task.setTaskCode(generateTaskCode());
        task.setResourceKey(resourceKey);
        task.setReportTitle(resolveReportTitle(payload, defaultReportTitle));
        task.setStatus(ExportTask.STATUS_PENDING);
        task.setPayloadJson(JSON.toJSONString(payload));
        task.setDeleted(0);
        task.setTenantId(tenantId);
        task.setCreateBy(userId);
        task.setUpdateBy(userId);
        task.setCreateTime(new Date());
        task.setUpdateTime(new Date());
        task.setExpireTime(resolveExpireTime());
        exportTaskService.save(task);
        return task;
    }

    @Override
    public ExportTask getTask(Long taskId, String resourceKey, Long tenantId, Long userId) {
        return exportTaskService.getOne(
                buildTaskQuery(taskId, tenantId, userId)
                        .eq(ExportTask::getResourceKey, resourceKey),
                false
        );
    }

    @Override
    public ExportTask getTask(Long taskId, Long tenantId, Long userId) {
        return exportTaskService.getOne(buildTaskQuery(taskId, tenantId, userId), false);
    }

    @Override
    public File getDownloadFile(Long taskId, String resourceKey, Long tenantId, Long userId) {
        ExportTask task = getTask(taskId, resourceKey, tenantId, userId);
        return resolveDownloadFile(task);
    }

    @Override
    public File getDownloadFile(Long taskId, Long tenantId, Long userId) {
        ExportTask task = getTask(taskId, tenantId, userId);
        return resolveDownloadFile(task);
    }

    private LambdaQueryWrapper<ExportTask> buildTaskQuery(Long taskId, Long tenantId, Long userId) {
        return new LambdaQueryWrapper<ExportTask>()
                .eq(ExportTask::getId, taskId)
                .eq(ExportTask::getDeleted, 0)
                .eq(ExportTask::getTenantId, tenantId)
                .eq(ExportTask::getCreateBy, userId);
    }

    private File resolveDownloadFile(ExportTask task) {
        if (task == null) {
            throw new CoolException("导出任务不存在");
        }
        if (!Objects.equals(task.getStatus(), ExportTask.STATUS_SUCCESS)) {
            throw new CoolException("导出任务尚未完成");
        }
        if (Cools.isEmpty(task.getFilePath())) {
            throw new CoolException("导出文件不存在");
        }

        File file = new File(task.getFilePath());
        if (!file.exists()) {
            throw new CoolException("导出文件不存在");
        }
        return file;
    }

    @Override
    @Async("taskExecutor")
    public <T, P extends BaseParam> void executeAsync(
            Long taskId,
            String resourceKey,
            Map<String, Object> payload,
            Function<Map<String, Object>, P> paramBuilder,
            ListExportHandler<T, P> exportHandler
    ) {
        ExportTask task = exportTaskService.getById(taskId);
        if (task == null) {
            return;
        }

        task.setStatus(ExportTask.STATUS_PROCESSING);
        task.setUpdateTime(new Date());
        exportTaskService.updateById(task);

        try {
            ListExportService.ExportWorkbook exportWorkbook =
                    listExportService.prepareExportWorkbook(payload, paramBuilder, exportHandler);
            File outputFile = createOutputFile(taskId, resourceKey, task.getReportTitle());
            writeWorkbook(exportWorkbook.workbook(), outputFile);

            task.setStatus(ExportTask.STATUS_SUCCESS);
            task.setRowCount(exportWorkbook.rowCount());
            task.setFileName(outputFile.getName());
        task.setFilePath(outputFile.getAbsolutePath());
        task.setErrorMsg(null);
        task.setUpdateTime(new Date());
        exportTaskService.updateById(task);
        } catch (Exception error) {
            log.error("异步导出失败, resourceKey={}, taskId={}", resourceKey, taskId, error);
            task.setStatus(ExportTask.STATUS_FAILED);
            task.setErrorMsg(truncateErrorMessage(error));
            task.setUpdateTime(new Date());
            exportTaskService.updateById(task);
        }
    }

    private String resolveReportTitle(Map<String, Object> payload, String defaultReportTitle) {
        Object metaObject = payload.get("meta");
        if (metaObject instanceof Map<?, ?> metaMap) {
            Object reportTitle = metaMap.get("reportTitle");
            if (reportTitle != null && !String.valueOf(reportTitle).trim().isEmpty()) {
                return String.valueOf(reportTitle).trim();
            }
        }
        return defaultReportTitle;
    }

    private String generateTaskCode() {
        return "EXP-" + new SimpleDateFormat("yyyyMMddHHmmss").format(new Date()) + "-"
                + UUID.randomUUID().toString().replace("-", "").substring(0, 8).toUpperCase();
    }

    private Date resolveExpireTime() {
        return Date.from(Instant.now().plus(Math.max(exportTaskExpireDays, 1), ChronoUnit.DAYS));
    }

    private File createOutputFile(Long taskId, String resourceKey, String reportTitle) {
        String safeTitle = sanitizeFileName(reportTitle);
        String safeResourceKey = sanitizePathSegment(resourceKey);
        String dayFolder = new SimpleDateFormat("yyyyMMdd").format(new Date());
        File dir = new File(loggingFilePath, "export-tasks/" + safeResourceKey + "/" + dayFolder);
        if (!dir.exists() && !dir.mkdirs()) {
            throw new CoolException("导出目录创建失败");
        }

        String timestamp = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
        return new File(dir, safeTitle + "-" + taskId + "-" + timestamp + ".xlsx");
    }

    private void writeWorkbook(Workbook workbook, File outputFile) throws IOException {
        try (Workbook targetWorkbook = workbook; FileOutputStream outputStream = new FileOutputStream(outputFile)) {
            targetWorkbook.write(outputStream);
            outputStream.flush();
        }
    }

    private String sanitizeFileName(String fileName) {
        String normalized = Objects.toString(fileName, "导出报表").trim();
        if (normalized.isEmpty()) {
            normalized = "导出报表";
        }
        return normalized.replaceAll("[\\\\/:*?\"<>|]", "_");
    }

    private String sanitizePathSegment(String segment) {
        String normalized = Objects.toString(segment, "default").trim();
        if (Cools.isEmpty(normalized)) {
            normalized = "default";
        }
        return normalized.replaceAll("[\\\\/:*?\"<>|]", "_");
    }

    private String truncateErrorMessage(Exception error) {
        String message = error == null ? "" : Objects.toString(error.getMessage(), error.getClass().getSimpleName());
        if (message.length() <= 500) {
            return message;
        }
        return message.substring(0, 500);
    }
}