package com.malk.eastar.util;

import cn.hutool.core.annotation.Alias;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 宜搭表单字段映射工具
 * 根据阶段属性匹配表单字段，填充时间数据
 */
public class YidaFieldMapper {

    /**
     * 阶段数据对象
     */
    public static class StageData {
        @Alias("textField_mgu5rm3f")
        private String stage;              // 阶段：textField_mgu5rm3f
        @Alias("dateField_mgu5rm3g")
        private String planStartTime;      // 计划开始时间：dateField_mgu5rm3g
        @Alias("dateField_mp4t9q5o")
        private String planStartTimeLatest; // 计划开始时间（最新）：dateField_mp4t9q5o
        @Alias("dateField_mgu5rm3h")
        private String planEndTime;        // 计划结束时间：dateField_mgu5rm3h
        @Alias("dateField_mp4t9q5p")
        private String planEndTimeLatest;  // 计划结束时间（最新）：dateField_mp4t9q5p
        @Alias("dateField_mp4t9q5q")
        private String actualStartTime;    // 实际开始时间：dateField_mp4t9q5q
        @Alias("dateField_mp4t9q5r")
        private String actualEndTime;      // 实际结束时间：dateField_mp4t9q5r

        public StageData() {}

        public StageData(String stage, String planStartTime, String planStartTimeLatest,
                        String planEndTime, String planEndTimeLatest,
                        String actualStartTime, String actualEndTime) {
            this.stage = stage;
            this.planStartTime = planStartTime;
            this.planStartTimeLatest = planStartTimeLatest;
            this.planEndTime = planEndTime;
            this.planEndTimeLatest = planEndTimeLatest;
            this.actualStartTime = actualStartTime;
            this.actualEndTime = actualEndTime;
        }

        // Getters and Setters
        public String getStage() { return stage; }
        public void setStage(String stage) { this.stage = stage; }
        
        public String getPlanStartTime() { return planStartTime; }
        public void setPlanStartTime(String planStartTime) { this.planStartTime = planStartTime; }
        
        public String getPlanStartTimeLatest() { return planStartTimeLatest; }
        public void setPlanStartTimeLatest(String planStartTimeLatest) { this.planStartTimeLatest = planStartTimeLatest; }
        
        public String getPlanEndTime() { return planEndTime; }
        public void setPlanEndTime(String planEndTime) { this.planEndTime = planEndTime; }
        
        public String getPlanEndTimeLatest() { return planEndTimeLatest; }
        public void setPlanEndTimeLatest(String planEndTimeLatest) { this.planEndTimeLatest = planEndTimeLatest; }
        
        public String getActualStartTime() { return actualStartTime; }
        public void setActualStartTime(String actualStartTime) { this.actualStartTime = actualStartTime; }
        
        public String getActualEndTime() { return actualEndTime; }
        public void setActualEndTime(String actualEndTime) { this.actualEndTime = actualEndTime; }
    }

    /**
     * 表单字段映射结果
     */
    static class FormFieldMapping {
        private Map<String, String> fieldValues = new HashMap<>();

        public void put(String fieldId, String value) {
            if (value != null && !value.isEmpty()) {
                fieldValues.put(fieldId, value);
            }
        }

        public Map<String, String> getFieldValues() {
            return fieldValues;
        }

        @Override
        public String toString() {
            return fieldValues.toString();
        }
    }

    /**
     * 阶段名称与表单字段前缀的映射关系
     * 根据之前获取的宜搭表单字段信息建立映射
     */
    private static final Map<String, String> STAGE_TO_FIELD_PREFIX = new HashMap<>();
    
    static {
        // 初始化阶段与字段前缀的映射关系
        // 格式：阶段名称 -> 表单字段名称中"-"之前的部分
        STAGE_TO_FIELD_PREFIX.put("立项", "立项");
        STAGE_TO_FIELD_PREFIX.put("白样", "白样");
        STAGE_TO_FIELD_PREFIX.put("制版", "制版");
        STAGE_TO_FIELD_PREFIX.put("产前样", "产前样");
        STAGE_TO_FIELD_PREFIX.put("大货样", "大货样");
        STAGE_TO_FIELD_PREFIX.put("大货", "大货");
        STAGE_TO_FIELD_PREFIX.put("包装", "包装");
        STAGE_TO_FIELD_PREFIX.put("出货", "出货");
        STAGE_TO_FIELD_PREFIX.put("结项", "结项");
    }

    /**
     * 表单字段ID映射表
     * 根据阶段前缀和时间类型获取对应的字段ID
     */
    private static final Map<String, Map<String, String>> FIELD_ID_MAP = new HashMap<>();
    
    static {
        // 立项阶段
        Map<String, String> lixiang = new HashMap<>();
        lixiang.put("planStartTime", "dateField_mgu5rm3g");
        lixiang.put("planStartTimeLatest", "dateField_mp4t9q5o");
        lixiang.put("planEndTime", "dateField_mgu5rm3h");
        lixiang.put("planEndTimeLatest", "dateField_mp4t9q5p");
        lixiang.put("actualStartTime", "dateField_mp4t9q5q");
        lixiang.put("actualEndTime", "dateField_mp4t9q5r");
        FIELD_ID_MAP.put("立项", lixiang);

        // 白样阶段
        Map<String, String> baiyang = new HashMap<>();
        baiyang.put("planStartTime", "dateField_mpqn6ucm");
        baiyang.put("planStartTimeLatest", "dateField_mpqn6uco");
        baiyang.put("planEndTime", "dateField_mpqn6ucq");
        baiyang.put("planEndTimeLatest", "dateField_mpqn6ucs");
        baiyang.put("actualStartTime", "dateField_mpqn6ucv");
        baiyang.put("actualEndTime", "dateField_mpqn6ucx");
        FIELD_ID_MAP.put("白样", baiyang);

        // 制版阶段
        Map<String, String> zhiban = new HashMap<>();
        zhiban.put("planStartTime", "dateField_mpqn6ud4");
        zhiban.put("planStartTimeLatest", "dateField_mpqn6ud6");
        zhiban.put("planEndTime", "dateField_mpqn6ud8");
        zhiban.put("planEndTimeLatest", "dateField_mpqn6uda");
        zhiban.put("actualStartTime", "dateField_mpqn6udd");
        zhiban.put("actualEndTime", "dateField_mpqn6udf");
        FIELD_ID_MAP.put("制版", zhiban);

        // 产前样阶段
        Map<String, String> chanqianyang = new HashMap<>();
        chanqianyang.put("planStartTime", "dateField_mpqn6udm");
        chanqianyang.put("planStartTimeLatest", "dateField_mpqn6udo");
        chanqianyang.put("planEndTime", "dateField_mpqn6udq");
        chanqianyang.put("planEndTimeLatest", "dateField_mpqn6uds");
        chanqianyang.put("actualStartTime", "dateField_mpqn6udv");
        chanqianyang.put("actualEndTime", "dateField_mpqn6udx");
        FIELD_ID_MAP.put("产前样", chanqianyang);

        // 大货样阶段
        Map<String, String> dahuoyang = new HashMap<>();
        dahuoyang.put("planStartTime", "dateField_mpqn6ue4");
        dahuoyang.put("planStartTimeLatest", "dateField_mpqn6ue6");
        dahuoyang.put("planEndTime", "dateField_mpqn6ue8");
        dahuoyang.put("planEndTimeLatest", "dateField_mpqn6uea");
        dahuoyang.put("actualStartTime", "dateField_mpqn6ued");
        dahuoyang.put("actualEndTime", "dateField_mpqn6uef");
        FIELD_ID_MAP.put("大货样", dahuoyang);

        // 大货阶段
        Map<String, String> dahuo = new HashMap<>();
        dahuo.put("planStartTime", "dateField_mpqn6uem");
        dahuo.put("planStartTimeLatest", "dateField_mpqn6ueo");
        dahuo.put("planEndTime", "dateField_mpqn6ueq");
        dahuo.put("planEndTimeLatest", "dateField_mpqn6ues");
        dahuo.put("actualStartTime", "dateField_mpqn6uev");
        dahuo.put("actualEndTime", "dateField_mpqn6uex");
        FIELD_ID_MAP.put("大货", dahuo);

        // 包装阶段
        Map<String, String> baozhuang = new HashMap<>();
        baozhuang.put("planStartTime", "dateField_mpqn6uf4");
        baozhuang.put("planStartTimeLatest", "dateField_mpqn6uf6");
        baozhuang.put("planEndTime", "dateField_mpqn6uf8");
        baozhuang.put("planEndTimeLatest", "dateField_mpqn6ufa");
        baozhuang.put("actualStartTime", "dateField_mpqn6ufd");
        baozhuang.put("actualEndTime", "dateField_mpqn6uff");
        FIELD_ID_MAP.put("包装", baozhuang);

        // 出货阶段
        Map<String, String> chuhuo = new HashMap<>();
        chuhuo.put("planStartTime", "dateField_mpqn6ufm");
        chuhuo.put("planStartTimeLatest", "dateField_mpqn6ufo");
        chuhuo.put("planEndTime", "dateField_mpqn6ufq");
        chuhuo.put("planEndTimeLatest", "dateField_mpqn6ufs");
        chuhuo.put("actualStartTime", "dateField_mpqn6ufv");
        chuhuo.put("actualEndTime", "dateField_mpqn6ufx");
        FIELD_ID_MAP.put("出货", chuhuo);

        // 结项阶段
        Map<String, String> jiexiang = new HashMap<>();
        jiexiang.put("planStartTime", "dateField_mpqn6ug4");
        jiexiang.put("planStartTimeLatest", "dateField_mpqn6ug6");
        jiexiang.put("planEndTime", "dateField_mpqn6ug8");
        jiexiang.put("planEndTimeLatest", "dateField_mpqn6uga");
        jiexiang.put("actualStartTime", "dateField_mpqn6ugd");
        jiexiang.put("actualEndTime", "dateField_mpqn6ugf");
        FIELD_ID_MAP.put("结项", jiexiang);
    }

    /**
     * 根据阶段数据列表生成表单字段映射
     * 
     * @param stageDataList 阶段数据对象集合
     * @return 表单字段ID到值的映射Map
     */
    public static Map<String, String> mapStageDataToFormFields(List<StageData> stageDataList) {
        if (stageDataList == null || stageDataList.isEmpty()) {
            return new HashMap<>();
        }

        Map<String, String> result = new HashMap<>();

        for (StageData stageData : stageDataList) {
            String stage = stageData.getStage();
            
            if (stage == null || stage.isEmpty()) {
                continue;
            }

            // 查找匹配的阶段前缀
            String matchedPrefix = findMatchingStagePrefix(stage);
            
            if (matchedPrefix == null) {
                System.out.println("警告：未找到阶段 '" + stage + "' 对应的表单字段前缀");
                continue;
            }

            // 获取该阶段的字段ID映射
            Map<String, String> fieldIdMap = FIELD_ID_MAP.get(matchedPrefix);
            
            if (fieldIdMap == null) {
                System.out.println("警告：阶段 '" + matchedPrefix + "' 没有配置字段ID映射");
                continue;
            }

            // 填充时间数据到对应的字段
            fillTimeData(result, fieldIdMap, stageData);
        }

        return result;
    }

    /**
     * 查找匹配的阶段前缀
     * 
     * @param stage 阶段值
     * @return 匹配的阶段前缀，未找到返回null
     */
    private static String findMatchingStagePrefix(String stage) {
        // 直接匹配
        if (STAGE_TO_FIELD_PREFIX.containsKey(stage)) {
            return stage;
        }

        // 尝试模糊匹配：检查阶段值是否包含某个已知阶段名称
        for (String knownStage : STAGE_TO_FIELD_PREFIX.keySet()) {
            if (stage.contains(knownStage) || knownStage.contains(stage)) {
                return knownStage;
            }
        }

        return null;
    }

    /**
     * 填充时间数据到结果Map
     * 
     * @param result 结果Map
     * @param fieldIdMap 字段ID映射
     * @param stageData 阶段数据
     */
    private static void fillTimeData(Map<String, String> result, 
                                    Map<String, String> fieldIdMap, 
                                    StageData stageData) {
        // 计划开始时间
        if (stageData.getPlanStartTime() != null && !stageData.getPlanStartTime().isEmpty()) {
            String fieldId = fieldIdMap.get("planStartTime");
            if (fieldId != null) {
                result.put(fieldId, stageData.getPlanStartTime());
            }
        }

        // 计划开始时间（最新）
        if (stageData.getPlanStartTimeLatest() != null && !stageData.getPlanStartTimeLatest().isEmpty()) {
            String fieldId = fieldIdMap.get("planStartTimeLatest");
            if (fieldId != null) {
                result.put(fieldId, stageData.getPlanStartTimeLatest());
            }
        }

        // 计划结束时间
        if (stageData.getPlanEndTime() != null && !stageData.getPlanEndTime().isEmpty()) {
            String fieldId = fieldIdMap.get("planEndTime");
            if (fieldId != null) {
                result.put(fieldId, stageData.getPlanEndTime());
            }
        }

        // 计划结束时间（最新）
        if (stageData.getPlanEndTimeLatest() != null && !stageData.getPlanEndTimeLatest().isEmpty()) {
            String fieldId = fieldIdMap.get("planEndTimeLatest");
            if (fieldId != null) {
                result.put(fieldId, stageData.getPlanEndTimeLatest());
            }
        }

        // 实际开始时间
        if (stageData.getActualStartTime() != null && !stageData.getActualStartTime().isEmpty()) {
            String fieldId = fieldIdMap.get("actualStartTime");
            if (fieldId != null) {
                result.put(fieldId, stageData.getActualStartTime());
            }
        }

        // 实际结束时间
        if (stageData.getActualEndTime() != null && !stageData.getActualEndTime().isEmpty()) {
            String fieldId = fieldIdMap.get("actualEndTime");
            if (fieldId != null) {
                result.put(fieldId, stageData.getActualEndTime());
            }
        }
    }

    /**
     * 测试方法
     */
    public static void main(String[] args) {
        // 创建测试数据
        List<StageData> stageDataList = new ArrayList<>();
        
        // 立项阶段数据
        StageData lixiang = new StageData(
            "立项",
            "2024-01-01",
            "2024-01-02",
            "2024-01-10",
            "2024-01-11",
            "2024-01-03",
            "2024-01-09"
        );
        stageDataList.add(lixiang);

        // 白样阶段数据
        StageData baiyang = new StageData(
            "白样",
            "2024-01-15",
            "2024-01-16",
            "2024-01-25",
            "2024-01-26",
            "2024-01-17",
            "2024-01-24"
        );
        stageDataList.add(baiyang);

        // 制版阶段数据
        StageData zhiban = new StageData(
            "制版",
            "2024-02-01",
            "2024-02-02",
            "2024-02-10",
            "2024-02-11",
            "2024-02-03",
            "2024-02-09"
        );
        stageDataList.add(zhiban);

        // 执行映射
        Map<String, String> formFields = mapStageDataToFormFields(stageDataList);

        // 输出结果
        System.out.println("=== 表单字段映射结果 ===");
        System.out.println("共映射 " + formFields.size() + " 个字段\n");
        
        // 按阶段分组展示
        Map<String, List<Map.Entry<String, String>>> groupedByStage = new LinkedHashMap<>();
        
        for (Map.Entry<String, String> entry : formFields.entrySet()) {
            String fieldId = entry.getKey();
            String stage = getStageByFieldId(fieldId);
            
            groupedByStage.computeIfAbsent(stage, k -> new ArrayList<>()).add(entry);
        }
        
        for (Map.Entry<String, List<Map.Entry<String, String>>> entry : groupedByStage.entrySet()) {
            System.out.println("【" + entry.getKey() + "】");
            for (Map.Entry<String, String> field : entry.getValue()) {
                System.out.println("  " + field.getKey() + " = " + field.getValue());
            }
            System.out.println();
        }
    }

    /**
     * 根据字段ID获取阶段名称（用于展示）
     */
    private static String getStageByFieldId(String fieldId) {
        for (Map.Entry<String, Map<String, String>> entry : FIELD_ID_MAP.entrySet()) {
            if (entry.getValue().containsValue(fieldId)) {
                return entry.getKey();
            }
        }
        return "未知";
    }
}