package com.estate.expert.admin.controller.admin;

import com.estate.expert.admin.domain.business.device.DeviceType;
import com.estate.expert.admin.domain.common.request.PlanPageRequest;
import com.estate.expert.admin.domain.common.request.ProjectPageRequest;
import com.estate.expert.admin.domain.common.request.RecordPageRequest;
import com.estate.expert.admin.domain.standard.hierachy.HierarchyIds;
import com.estate.expert.admin.domain.standard.problem.Problem;
import com.estate.expert.admin.domain.user.User;
import com.estate.expert.admin.enums.BizResultCode;
import com.estate.expert.admin.io.processor.DataProcessorBase;
import com.estate.expert.admin.io.processor.RowDataProcessorBase;
import com.estate.expert.admin.io.processor.impl.business.DeviceProcessor;
import com.estate.expert.admin.io.processor.impl.business.PlanProcessor;
import com.estate.expert.admin.io.processor.impl.business.ProjectProcessor;
import com.estate.expert.admin.io.processor.impl.matrix.CompareMatrixProcessor;
import com.estate.expert.admin.io.processor.impl.matrix.MembershipMatrixProcessor;
import com.estate.expert.admin.io.processor.impl.record.DeviceErrorRecordProcessor;
import com.estate.expert.admin.io.processor.impl.record.SystemErrorRecordProcessor;
import com.estate.expert.admin.io.processor.impl.record.WarningRecordProcessor;
import com.estate.expert.admin.io.processor.impl.standard.ProblemProcessor;
import com.estate.expert.admin.service.*;
import com.estate.expert.admin.service.expert.DeviceExpertService;
import com.estate.expert.admin.service.expert.SysExpertService;
import com.estate.expert.common.domain.Session;
import com.estate.expert.common.rpc.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.io.InputStreamResource;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.List;

@Slf4j
@CrossOrigin
@Api(tags = "管理后台/导入导出")
@RequestMapping("/admin/io")
@Controller
@Validated
public class ExportController {

    @Resource
    private ErrorRecordService errorRecordService;

    @Resource
    private WarningRecordService warningRecordService;

    @Resource
    private ProjectService projectService;

    @Resource
    private DeviceService deviceService;

    @Resource
    private PlanService planService;

    @Resource
    private CheckTaskService checkTaskService;

    @Resource
    private ClientService clientService;

    @Resource
    private SysExpertService sysExpertService;

    @Resource
    private DeviceExpertService deviceExpertService;

    @Resource
    private HierarchyService hierarchyService;

    @Resource
    private ProblemService problemService;

    @ApiOperation("综合问题导出")
    @PostMapping("/systemError/export")
    public ResponseEntity<InputStreamResource> exportSystemErrorRecords(@Validated @RequestBody RecordPageRequest request){
        var result = errorRecordService.listSystemErrors(request.getClientId(), request.getPlanId(), request.getTaskId(),
                request.getStartDate(), request.getEndDate());
        return downloadRowData(new SystemErrorRecordProcessor(), result);
    }

    @ApiOperation("设备问题导出")
    @PostMapping("/deviceError/export")
    public ResponseEntity<InputStreamResource> exportDeviceErrorRecords(@Validated @RequestBody RecordPageRequest request){
        var result = errorRecordService.listDeviceErrors(request.getClientId(), request.getPlanId(), request.getTaskId(),
                request.getStartDate(), request.getEndDate());
        return downloadRowData(new DeviceErrorRecordProcessor(), result);
    }

    @ApiOperation("正确做法导出")
    @PostMapping("/warning/export")
    public ResponseEntity<InputStreamResource> exportWarningRecords(@Validated @RequestBody RecordPageRequest request){
        var result = warningRecordService.list(request.getClientId(), request.getPlanId(), request.getTaskId(),
                request.getStartDate(), request.getEndDate());
        return downloadRowData(new WarningRecordProcessor(), result);
    }

    @ApiOperation("项目导出")
    @PostMapping("/project/export")
    public ResponseEntity<InputStreamResource> exportProjects(@Validated @RequestBody ProjectPageRequest request){
        var result = projectService.list(request.getKeyword(), request.getProjectTypes(), request.getClientIds());
        return downloadRowData(new ProjectProcessor(clientService, projectService), result, "项目导出");
    }

    @ApiOperation("项目导入模版")
    @PostMapping("/project/template")
    public ResponseEntity<InputStreamResource> downloadProjectTemplate(){
        return downloadRowData(new ProjectProcessor(clientService, projectService), List.of());
    }

    @ApiOperation("项目导入")
    @PostMapping("/project/import")
    @ResponseBody
    public Result importProjectRecords(
            Session session,
            @RequestParam("file") MultipartFile file) {
        return importData(
            "项目",
            session,
            file,
            () -> new ProjectProcessor(clientService, projectService).loadFromWorkbook(file.getInputStream()),
            records -> projectService.importEntities((User) session.getUser(), records)
        );
    }

    @ApiOperation("设备导出")
    @PostMapping("/device/export")
    public ResponseEntity<InputStreamResource> exportDeviceRecords(@RequestParam(value = "keyword", required = false) String keyword,
                                                                   @RequestParam(value = "deviceType", required = false) DeviceType deviceType){
        var result = deviceService.list(keyword, deviceType);
        return downloadRowData(new DeviceProcessor(), result, "设备导出");
    }

    @ApiOperation("设备导入模版")
    @GetMapping("/device/template")
    public ResponseEntity<InputStreamResource> downloadDeviceTemplate(){
        return downloadRowData(new DeviceProcessor(), List.of());
    }

    @ApiOperation("设备导入")
    @PostMapping("/device/import")
    @ResponseBody
    public Result importDeviceRecords(
            Session session,
            @RequestParam("file") MultipartFile file) {
        return importData(
            "设备",
            session,
            file,
            () -> new DeviceProcessor().loadFromWorkbook(file.getInputStream()),
            records -> deviceService.importEntities((User) session.getUser(), records)
        );
    }

    //////  模糊数学专家 - 隶属度矩阵导入导出  //////

    @ApiOperation("综合体系-模糊数学-隶属度矩阵导出")
    @PostMapping("/system/fuzzy/membershipMatrix/export")
    public ResponseEntity<InputStreamResource> exportSystemFuzzyMembershipMatrix(
            @ApiParam("专家ID") @RequestParam(value = "expertId", required = false) Integer expertId) {
        if(expertId == null) {
            expertId = sysExpertService.getDefaultExpert().getId();
        }
        var matrix = sysExpertService.getMembershipMatrix(expertId);
        BizResultCode.MEMBERSHIP_MATRIX_LOAD_ERROR.check(matrix == null);

        var expert = sysExpertService.get(expertId);
        String filename = expert != null ? "综合体系-" + expert.getName() + "-隶属度矩阵" : "综合体系-隶属度矩阵";
        
        return downloadData(new MembershipMatrixProcessor(), matrix, filename);
    }

    @ApiOperation("综合体系-模糊数学-隶属度矩阵导入模版")
    @PostMapping("/system/fuzzy/membershipMatrix/template")
    public ResponseEntity<InputStreamResource> downloadSystemFuzzyMembershipMatrixTemplate() {
        return exportSystemFuzzyMembershipMatrix(null);
    }

    @ApiOperation("综合体系-模糊数学-隶属度矩阵导入")
    @PostMapping("/system/fuzzy/membershipMatrix/import")
    @ResponseBody
    public Result importSystemFuzzyMembershipMatrix(
            @ApiParam("专家ID") @RequestParam("expertId") Integer expertId,
            @RequestParam("file") MultipartFile file) {
        try {
            sysExpertService.importMembershipMatrix(expertId, file.getInputStream());
            return Result.success("隶属度矩阵导入成功");
        } catch (Exception e) {
            log.error("综合体系隶属度矩阵导入失败", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }

    @ApiOperation("设备体系-模糊数学-隶属度矩阵导出")
    @PostMapping("/device/fuzzy/membershipMatrix/export")
    public ResponseEntity<InputStreamResource> exportDeviceFuzzyMembershipMatrix(
            @ApiParam("专家ID") @RequestParam(value = "expertId", required = false) Integer expertId) {
        if(expertId == null) {
            expertId = deviceExpertService.getDefaultExpert().getId();
        }
        var matrix = deviceExpertService.getMembershipMatrix(expertId);
        BizResultCode.MEMBERSHIP_MATRIX_LOAD_ERROR.check(matrix == null);

        var expert = deviceExpertService.get(expertId);
        String filename = expert != null ? "设备体系-" + expert.getName() + "-隶属度矩阵" : "设备体系-隶属度矩阵";
        
        return downloadData(new MembershipMatrixProcessor(), matrix, filename);
    }

    @ApiOperation("设备体系-模糊数学-隶属度矩阵导入模版")
    @PostMapping("/device/fuzzy/membershipMatrix/template")
    public ResponseEntity<InputStreamResource> downloadDeviceFuzzyMembershipMatrixTemplate() {
        return exportDeviceFuzzyMembershipMatrix(null);
    }

    @ApiOperation("设备体系-模糊数学-隶属度矩阵导入")
    @PostMapping("/device/fuzzy/membershipMatrix/import")
    @ResponseBody
    public Result importDeviceFuzzyMembershipMatrix(
            @ApiParam("专家ID") @RequestParam("expertId") Integer expertId,
            @RequestParam("file") MultipartFile file) {
        try {
            deviceExpertService.importMembershipMatrix(expertId, file.getInputStream());
            return Result.success("隶属度矩阵导入成功");
        } catch (Exception e) {
            log.error("设备体系隶属度矩阵导入失败", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }

    //////  模糊数学专家 - 判断矩阵导入导出  //////

    @ApiOperation("综合体系-模糊数学-判断矩阵导出")
    @PostMapping("/system/fuzzy/compareMatrix/export")
    public ResponseEntity<InputStreamResource> exportSystemFuzzyCompareMatrix(
            @ApiParam("专家ID") @RequestParam Integer expertId) {
        var expert = sysExpertService.get(expertId);
        if(expert == null) {
            throw new RuntimeException("专家不存在");
        }
        
        var hierarchyTree = sysExpertService.getHierarchyTree(expertId);
        var compareMatrixMap = expert.getCompareMatrixMap();
        
        // 如果没有判断矩阵，自动生成默认矩阵（所有比值为1）
        if(compareMatrixMap == null || compareMatrixMap.isEmpty()) {
            compareMatrixMap = generateDefaultCompareMatrixMap(hierarchyTree);
        }
        
        String filename = "综合体系-" + expert.getName() + "-判断矩阵";
        return downloadData(new CompareMatrixProcessor(hierarchyTree), compareMatrixMap, filename);
    }

    @ApiOperation("综合体系-模糊数学-判断矩阵导入模版")
    @PostMapping("/system/fuzzy/compareMatrix/template")
    public ResponseEntity<InputStreamResource> downloadSystemFuzzyCompareMatrixTemplate(
            @ApiParam("专家ID") @RequestParam Integer expertId) {
        return exportSystemFuzzyCompareMatrix(expertId);
    }

    @ApiOperation("综合体系-模糊数学-判断矩阵导入")
    @PostMapping("/system/fuzzy/compareMatrix/import")
    @ResponseBody
    public Result importSystemFuzzyCompareMatrix(
            @ApiParam("专家ID") @RequestParam Integer expertId,
            @RequestParam("file") MultipartFile file) {
        try {
            var hierarchyTree = sysExpertService.getHierarchyTree(expertId);
            var compareMatrixMap = new CompareMatrixProcessor(hierarchyTree).loadFromWorkbook(file.getInputStream());
            
            // 验证所有矩阵
            for(var matrix : compareMatrixMap.values()) {
                CompareMatrixProcessor.validate(matrix);
            }
            
            // 更新专家的判断矩阵
            var expert = sysExpertService.get(expertId);
            expert.setCompareMatrixMap(compareMatrixMap);
            sysExpertService.edit(expert);
            
            return Result.success("判断矩阵导入成功，共导入 " + compareMatrixMap.size() + " 个节点");
        } catch (Exception e) {
            log.error("综合体系判断矩阵导入失败", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }

    @ApiOperation("设备体系-模糊数学-判断矩阵导出")
    @PostMapping("/device/fuzzy/compareMatrix/export")
    public ResponseEntity<InputStreamResource> exportDeviceFuzzyCompareMatrix(
            @ApiParam("专家ID") @RequestParam Integer expertId) {
        var expert = deviceExpertService.get(expertId);
        if(expert == null) {
            throw new RuntimeException("专家不存在");
        }
        
        var hierarchyTree = deviceExpertService.getHierarchyTree(expertId);
        var compareMatrixMap = expert.getCompareMatrixMap();
        
        // 如果没有判断矩阵，自动生成默认矩阵（所有比值为1）
        if(compareMatrixMap == null || compareMatrixMap.isEmpty()) {
            compareMatrixMap = generateDefaultCompareMatrixMap(hierarchyTree);
        }
        
        String filename = "设备体系-" + expert.getName() + "-判断矩阵";
        return downloadData(new CompareMatrixProcessor(hierarchyTree), compareMatrixMap, filename);
    }

    @ApiOperation("设备体系-模糊数学-判断矩阵导入模版")
    @PostMapping("/device/fuzzy/compareMatrix/template")
    public ResponseEntity<InputStreamResource> downloadDeviceFuzzyCompareMatrixTemplate(
            @ApiParam("专家ID") @RequestParam Integer expertId) {
        return exportDeviceFuzzyCompareMatrix(expertId);
    }

    @ApiOperation("设备体系-模糊数学-判断矩阵导入")
    @PostMapping("/device/fuzzy/compareMatrix/import")
    @ResponseBody
    public Result importDeviceFuzzyCompareMatrix(
            @ApiParam("专家ID") @RequestParam Integer expertId,
            @RequestParam("file") MultipartFile file) {
        try {
            var hierarchyTree = deviceExpertService.getHierarchyTree(expertId);
            var compareMatrixMap = new CompareMatrixProcessor(hierarchyTree).loadFromWorkbook(file.getInputStream());
            
            // 验证所有矩阵
            for(var matrix : compareMatrixMap.values()) {
                CompareMatrixProcessor.validate(matrix);
            }
            
            // 更新专家的判断矩阵
            var expert = deviceExpertService.get(expertId);
            expert.setCompareMatrixMap(compareMatrixMap);
            deviceExpertService.edit(expert);
            
            return Result.success("判断矩阵导入成功，共导入 " + compareMatrixMap.size() + " 个节点");
        } catch (Exception e) {
            log.error("设备体系判断矩阵导入失败", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }

    @ApiOperation("检查计划导出")
    @PostMapping("/plan/export")
    public ResponseEntity<InputStreamResource> exportPlans(@Validated @RequestBody PlanPageRequest request){
        var result = planService.list(request.getKeyword(), request.getPlanTypes(), request.getPlanStates(),
                request.getClientIds(), request.getCreatorId());
        return downloadRowData(new PlanProcessor(checkTaskService), result, "检查计划导出");
    }

    @ApiOperation("体系问题导出（综合体系第6层/其他体系第4层叶子节点）")
    @PostMapping("/problem/export")
    public ResponseEntity<InputStreamResource> exportProblems(
            @ApiParam("体系ID（1=综合体系-6层，其他=设备体系-4层）") @RequestParam Integer hierarchyId,
            @ApiParam("体系路径（单个节点）") @RequestParam String hierarchyPath) {
        var result = problemService.findProblems(hierarchyId, List.of(hierarchyPath), null);
        
        var hierarchy = hierarchyService.get(hierarchyId);
        String filename = hierarchy != null ? hierarchy.getName() + "-问题导出" : "问题导出";
        
        return downloadRowData(new ProblemProcessor(hierarchyService, hierarchyId), result, filename);
    }

    @ApiOperation("体系问题导入模版（综合体系第6层/其他体系第4层叶子节点）")
    @PostMapping("/problem/template")
    public ResponseEntity<InputStreamResource> downloadProblemTemplate(
            @ApiParam("体系ID（1=综合体系-6层，其他=设备体系-4层）") @RequestParam Integer hierarchyId) {
        return downloadRowData(new ProblemProcessor(hierarchyService, hierarchyId), List.of());
    }

    @ApiOperation("体系问题导入（综合体系第6层/其他体系第4层叶子节点）")
    @PostMapping("/problem/import")
    @ResponseBody
    public Result importProblems(
            Session session,
            @ApiParam("体系ID（1=综合体系-6层，其他=设备体系-4层）") @RequestParam Integer hierarchyId,
            @ApiParam("体系路径（问题将归属到此路径下）") @RequestParam String hierarchyPath,
            @RequestParam("file") MultipartFile file) {
        return importData(
            "问题",
            session,
            file,
            () -> {
                var records = new ProblemProcessor(hierarchyService, hierarchyId).loadFromWorkbook(file.getInputStream());
                // 设置所有问题的体系路径
                if(records != null) {
                    for(var problem : records) {
                        problem.setHierarchyPath(hierarchyPath);
                        problem.setHierarchyId(hierarchyId);
                    }
                    // 验证所有问题必须是叶子节点
                    validateLeafNodes(hierarchyId, records);
                }
                return records;
            },
            records -> problemService.importEntities((User) session.getUser(), records)
        );
    }

    /**
     * 生成默认的判断矩阵Map（所有比值为1）
     * 为体系树中所有有子节点的节点生成默认判断矩阵
     */
    private java.util.Map<String, com.estate.expert.admin.domain.standard.expert.matrix.CompareMatrix> generateDefaultCompareMatrixMap(
            com.estate.expert.admin.utils.tree.TreeRoot<com.estate.expert.admin.domain.standard.hierachy.HierarchyData> hierarchyTree) {
        java.util.Map<String, com.estate.expert.admin.domain.standard.expert.matrix.CompareMatrix> matrixMap = new java.util.TreeMap<>();
        
        // 递归遍历所有节点
        generateDefaultMatrixForNode(hierarchyTree.root(), matrixMap);
        
        return matrixMap;
    }
    
    /**
     * 递归为节点及其子节点生成默认判断矩阵
     */
    private void generateDefaultMatrixForNode(
            com.estate.expert.admin.utils.tree.TreeNode<com.estate.expert.admin.domain.standard.hierachy.HierarchyData> node,
            java.util.Map<String, com.estate.expert.admin.domain.standard.expert.matrix.CompareMatrix> matrixMap) {
        
        // 如果节点有子节点，则为其生成判断矩阵
        if(node.getChildren() != null && !node.getChildren().isEmpty()) {
            String nodePath = node.getPath();
            
            // 跳过根节点或无效路径
            if(!"/".equals(nodePath) && nodePath != null && nodePath.length() > 1) {
                var children = node.getChildren().values();
                String[] childNames = children.stream()
                        .map(com.estate.expert.admin.utils.tree.TreeNode::getName)
                        .toArray(String[]::new);
                
                // 创建默认矩阵（所有值为1）
                var matrix = new com.estate.expert.admin.domain.standard.expert.matrix.CompareMatrix(childNames);
                matrixMap.put(nodePath, matrix);
            }
            
            // 递归处理子节点
            for(var child : node.getChildren().values()) {
                generateDefaultMatrixForNode(child, matrixMap);
            }
        }
    }
    
    /**
     * 验证问题是否都是叶子节点
     * 综合体系（ID=1）：第6层
     * 其他体系（ID!=1）：第4层
     */
    private void validateLeafNodes(Integer hierarchyId, List<Problem> problems) {
        var hierarchy = hierarchyService.get(hierarchyId);
        if(hierarchy == null) {
            throw new RuntimeException("体系不存在");
        }
        
        var root = hierarchy.getContent();
        if(root == null) {
            throw new RuntimeException("体系结构为空");
        }
        
        // 根据体系ID确定要求的层级
        // ID=1 是综合体系（第6层），其他都是设备体系（第4层）
        int requiredDepth;
        String hierarchyName;
        if(hierarchyId == HierarchyIds.SYSTEM) {
            requiredDepth = 6;
            hierarchyName = "综合体系";
        } else {
            requiredDepth = 4;
            hierarchyName = "设备体系";
        }

        // 所有问题共享同一个体系路径，只需验证一次
        if(!problems.isEmpty()) {
            var path = problems.get(0).getHierarchyPath();
            
            if(path == null || path.trim().isEmpty()) {
                throw new RuntimeException("体系路径为空");
            }
            
            var node = root.get(path);
            if(node == null) {
                throw new RuntimeException("体系路径【" + path + "】不存在");
            }
            
            // 检查是否是要求的层级
            if(node.getDepth() != requiredDepth) {
                throw new RuntimeException("体系路径不在" + hierarchyName + "第" + requiredDepth + "层（当前在第" + node.getDepth() + "层）");
            }
            
            // 检查是否是叶子节点
            if(node.getChildren() != null && !node.getChildren().isEmpty()) {
                throw new RuntimeException("体系路径不是叶子节点（存在子节点）");
            }
        }
    }

    /**
     * 通用的数据导入方法
     * 
     * @param dataType 数据类型名称（用于日志和错误提示）
     * @param session 会话信息
     * @param file 上传的文件
     * @param loader 数据加载函数
     * @param importer 数据导入函数
     * @param <T> 数据类型
     * @return 导入结果
     */
    private <T> Result importData(
            String dataType,
            Session session,
            MultipartFile file,
            DataLoader<T> loader,
            DataImporter<T> importer) {
        try {
            // 1. 加载数据
            var records = loader.load();
            
            // 2. 验证数据
            if(records == null || records.isEmpty()) {
                return Result.error("导入文件中没有有效数据");
            }
            
            // 3. 执行导入
            importer.doImport(records);
            
            // 4. 返回成功结果
            return Result.success("成功导入 " + records.size() + " 个" + dataType);
            
        } catch (Exception e) {
            log.error("{}导入失败", dataType, e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }
    
    /**
     * 数据加载函数接口
     */
    @FunctionalInterface
    private interface DataLoader<T> {
        List<T> load() throws Exception;
    }
    
    /**
     * 数据导入函数接口
     */
    @FunctionalInterface
    private interface DataImporter<T> {
        void doImport(List<T> records);
    }

    // 生成Excel文件并写入下载的流
    @SneakyThrows
    public <T> ResponseEntity<InputStreamResource> downloadRowData(RowDataProcessorBase<T> processor, List<T> records) {
        return downloadData(processor, records);
    }

    // 生成Excel文件并写入下载的流（带文件名）
    @SneakyThrows
    public <T> ResponseEntity<InputStreamResource> downloadRowData(RowDataProcessorBase<T> processor, List<T> records, String filename) {
        return downloadData(processor, records, filename);
    }

    // 生成Excel文件并写入下载的流
    @SneakyThrows
    public <V> ResponseEntity<InputStreamResource> downloadData(DataProcessorBase<V> processor, V data) {
        return downloadData(processor, data, null);
    }

    // 生成Excel文件并写入下载的流（带文件名）
    @SneakyThrows
    public <V> ResponseEntity<InputStreamResource> downloadData(DataProcessorBase<V> processor, V data, String filename) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        processor.saveWorkbook(baos, data);

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        InputStreamResource resource = new InputStreamResource(bais);

        var responseBuilder = ResponseEntity.ok()
                .contentType(MediaType.parseMediaType("application/vnd.ms-excel;charset=UTF-8"));
        
        // 如果指定了文件名，则设置 Content-Disposition 头（支持中文）
        if(filename != null && !filename.trim().isEmpty()) {
            String encodedFilename = URLEncoder.encode(filename, StandardCharsets.UTF_8.toString()).replace("+", "%20");
            responseBuilder.header("Content-Disposition", 
                    "attachment; filename*=UTF-8''" + encodedFilename + ".xlsx");
        }
        
        return responseBuilder.body(resource);
    }

}