package com.mes.interaction.largeglass.handler;

import com.mes.device.entity.DeviceConfig;
import com.mes.device.vo.DevicePlcVO;
import com.mes.interaction.BaseDeviceLogicHandler;
import com.mes.device.service.DevicePlcOperationService;
import com.mes.interaction.largeglass.config.LargeGlassConfig;
import com.mes.interaction.largeglass.model.GridRange;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.*;

/**
 * 大理片笼设备逻辑处理器
 * 负责格子范围配置、每格尺寸配置、逻辑判断等
 * 不涉及PLC写入操作，只用于逻辑判断和配置管理
 */
@Slf4j
@Component
public class LargeGlassLogicHandler extends BaseDeviceLogicHandler {

    public LargeGlassLogicHandler(DevicePlcOperationService devicePlcOperationService) {
        super(devicePlcOperationService);
    }

    @Override
    public String getDeviceType() {
        return DeviceConfig.DeviceType.LARGE_GLASS;
    }

    @Override
    protected DevicePlcVO.OperationResult doExecute(DeviceConfig deviceConfig,
                                                    String operation,
                                                    Map<String, Object> params,
                                                    Map<String, Object> logicParams) {
        try {
            LargeGlassConfig config = parseLargeGlassConfig(logicParams);
            
            switch (operation) {
                case "checkGrid":
                case "validateGrid":
                    return handleCheckGrid(deviceConfig, params, config);
                case "getGridInfo":
                    return handleGetGridInfo(deviceConfig, params, config);
                case "findAvailableGrid":
                    return handleFindAvailableGrid(deviceConfig, params, config);
                case "getGridPosition":
                    return handleGetGridPosition(deviceConfig, params, config);
                default:
                    return buildResult(deviceConfig, operation, false, 
                            "不支持的操作: " + operation);
            }
        } catch (Exception e) {
            log.error("大理片笼处理异常: deviceId={}, operation={}", 
                    deviceConfig.getId(), operation, e);
            return buildResult(deviceConfig, operation, false, 
                    "处理异常: " + e.getMessage());
        }
    }

    /**
     * 检查格子是否有效
     */
    private DevicePlcVO.OperationResult handleCheckGrid(
            DeviceConfig deviceConfig,
            Map<String, Object> params,
            LargeGlassConfig config) {
        
        Integer gridNumber = getIntegerParam(params, "gridNumber");
        if (gridNumber == null) {
            return buildResult(deviceConfig, "checkGrid", false, 
                    "未提供格子编号");
        }
        
        GridRange gridRange = findGridRange(gridNumber, config);
        if (gridRange == null) {
            return buildResult(deviceConfig, "checkGrid", false, 
                    String.format("格子编号 %d 不在配置范围内", gridNumber));
        }
        
        return buildResult(deviceConfig, "checkGrid", true, 
                String.format("格子编号 %d 有效，位于第 %d 行，范围 %d~%d", 
                        gridNumber, gridRange.getRow(), gridRange.getStart(), gridRange.getEnd()));
    }

    /**
     * 获取格子信息
     */
    private DevicePlcVO.OperationResult handleGetGridInfo(
            DeviceConfig deviceConfig,
            Map<String, Object> params,
            LargeGlassConfig config) {
        
        Integer gridNumber = getIntegerParam(params, "gridNumber");
        if (gridNumber == null) {
            return buildResult(deviceConfig, "getGridInfo", false, 
                    "未提供格子编号");
        }
        
        GridRange gridRange = findGridRange(gridNumber, config);
        if (gridRange == null) {
            return buildResult(deviceConfig, "getGridInfo", false, 
                    String.format("格子编号 %d 不在配置范围内", gridNumber));
        }
        
        Map<String, Object> gridInfo = new HashMap<>();
        gridInfo.put("gridNumber", gridNumber);
        gridInfo.put("row", gridRange.getRow());
        gridInfo.put("start", gridRange.getStart());
        gridInfo.put("end", gridRange.getEnd());
        gridInfo.put("length", config.getGridLength());
        gridInfo.put("width", config.getGridWidth());
        gridInfo.put("thickness", config.getGridThickness());
        
        return buildResult(deviceConfig, "getGridInfo", true, 
                "格子信息获取成功", gridInfo);
    }

    /**
     * 查找可用格子
     */
    private DevicePlcVO.OperationResult handleFindAvailableGrid(
            DeviceConfig deviceConfig,
            Map<String, Object> params,
            LargeGlassConfig config) {
        
        // 这里可以根据实际需求实现查找逻辑
        // 例如：查找第一个可用格子、查找指定行可用格子等
        
        List<GridRange> gridRanges = config.getGridRanges();
        if (gridRanges == null || gridRanges.isEmpty()) {
            return buildResult(deviceConfig, "findAvailableGrid", false, 
                    "未配置格子范围");
        }
        
        // 简单实现：返回第一个格子的起始位置
        GridRange firstRange = gridRanges.get(0);
        Integer availableGrid = firstRange.getStart();
        
        Map<String, Object> result = new HashMap<>();
        result.put("availableGrid", availableGrid);
        result.put("row", firstRange.getRow());
        
        return buildResult(deviceConfig, "findAvailableGrid", true, 
                String.format("找到可用格子: %d", availableGrid), result);
    }

    /**
     * 根据目标位置获取格子编号
     */
    private DevicePlcVO.OperationResult handleGetGridPosition(
            DeviceConfig deviceConfig,
            Map<String, Object> params,
            LargeGlassConfig config) {
        
        Integer targetPosition = getIntegerParam(params, "targetPosition");
        if (targetPosition == null) {
            return buildResult(deviceConfig, "getGridPosition", false, 
                    "未提供目标位置");
        }
        
        // 查找目标位置在哪个格子范围内
        GridRange gridRange = findGridRangeByPosition(targetPosition, config);
        if (gridRange == null) {
            return buildResult(deviceConfig, "getGridPosition", false, 
                    String.format("目标位置 %d 不在任何格子范围内", targetPosition));
        }
        
        // 计算格子编号（假设位置就是格子编号，或根据实际规则计算）
        Integer gridNumber = targetPosition;
        
        Map<String, Object> result = new HashMap<>();
        result.put("gridNumber", gridNumber);
        result.put("row", gridRange.getRow());
        result.put("position", targetPosition);
        
        return buildResult(deviceConfig, "getGridPosition", true, 
                String.format("目标位置 %d 对应格子编号 %d，第 %d 行", 
                        targetPosition, gridNumber, gridRange.getRow()), result);
    }

    /**
     * 解析大理片笼配置
     */
    private LargeGlassConfig parseLargeGlassConfig(Map<String, Object> logicParams) {
        LargeGlassConfig config = new LargeGlassConfig();
        
        if (logicParams == null) {
            return config;
        }
        
        // 解析格子范围配置
        @SuppressWarnings("unchecked")
        List<Map<String, Object>> gridRangesConfig = 
                (List<Map<String, Object>>) logicParams.get("gridRanges");
        
        if (gridRangesConfig != null) {
            List<GridRange> gridRanges = new ArrayList<>();
            for (Map<String, Object> rangeConfig : gridRangesConfig) {
                Integer row = getIntegerValue(rangeConfig.get("row"));
                Integer start = getIntegerValue(rangeConfig.get("start"));
                Integer end = getIntegerValue(rangeConfig.get("end"));
                
                if (row != null && start != null && end != null) {
                    gridRanges.add(new GridRange(row, start, end));
                }
            }
            config.setGridRanges(gridRanges);
        }
        
        // 解析每格尺寸
        config.setGridLength(getLogicParam(logicParams, "gridLength", 2000)); // 默认2000mm
        config.setGridWidth(getLogicParam(logicParams, "gridWidth", 1500));  // 默认1500mm
        config.setGridThickness(getLogicParam(logicParams, "gridThickness", 5)); // 默认5mm
        
        return config;
    }

    /**
     * 查找格子所在的格子范围
     */
    private GridRange findGridRange(Integer gridNumber, LargeGlassConfig config) {
        List<GridRange> gridRanges = config.getGridRanges();
        if (gridRanges == null) {
            return null;
        }
        
        for (GridRange range : gridRanges) {
            if (gridNumber >= range.getStart() && gridNumber <= range.getEnd()) {
                return range;
            }
        }
        
        return null;
    }

    /**
     * 根据位置查找格子范围
     */
    private GridRange findGridRangeByPosition(Integer position, LargeGlassConfig config) {
        List<GridRange> gridRanges = config.getGridRanges();
        if (gridRanges == null) {
            return null;
        }
        
        for (GridRange range : gridRanges) {
            if (position >= range.getStart() && position <= range.getEnd()) {
                return range;
            }
        }
        
        return null;
    }

    /**
     * 获取整数参数
     */
    private Integer getIntegerParam(Map<String, Object> params, String key) {
        if (params == null) {
            return null;
        }
        return getIntegerValue(params.get(key));
    }

    /**
     * 获取整数值
     */
    private Integer getIntegerValue(Object value) {
        if (value instanceof Number) {
            return ((Number) value).intValue();
        }
        if (value == null) {
            return null;
        }
        try {
            return Integer.parseInt(String.valueOf(value));
        } catch (NumberFormatException e) {
            return null;
        }
    }

    /**
     * 构建操作结果
     */
    private DevicePlcVO.OperationResult buildResult(DeviceConfig deviceConfig,
                                                    String operation,
                                                    boolean success,
                                                    String message) {
        return buildResult(deviceConfig, operation, success, message, null);
    }

    /**
     * 构建操作结果（带数据）
     */
    private DevicePlcVO.OperationResult buildResult(DeviceConfig deviceConfig,
                                                    String operation,
                                                    boolean success,
                                                    String message,
                                                    Map<String, Object> data) {
        DevicePlcVO.OperationResult.OperationResultBuilder builder = DevicePlcVO.OperationResult.builder()
                .deviceId(deviceConfig.getId())
                .deviceName(deviceConfig.getDeviceName())
                .deviceCode(deviceConfig.getDeviceCode())
                .projectId(deviceConfig.getProjectId() != null ? 
                        String.valueOf(deviceConfig.getProjectId()) : null)
                .operation(operation)
                .success(success)
                .message(message)
                .timestamp(LocalDateTime.now());
        
        if (data != null) {
            builder.data(data);
        }
        
        return builder.build();
    }

    @Override
    public String validateLogicParams(DeviceConfig deviceConfig) {
        Map<String, Object> logicParams = parseLogicParams(deviceConfig);
        LargeGlassConfig config = parseLargeGlassConfig(logicParams);
        
        // 验证格子范围配置
        List<GridRange> gridRanges = config.getGridRanges();
        if (gridRanges == null || gridRanges.isEmpty()) {
            return "必须配置至少一个格子范围（gridRanges）";
        }
        
        // 验证每格尺寸
        if (config.getGridLength() == null || config.getGridLength() <= 0) {
            return "格子长度（gridLength）必须大于0";
        }
        if (config.getGridWidth() == null || config.getGridWidth() <= 0) {
            return "格子宽度（gridWidth）必须大于0";
        }
        if (config.getGridThickness() == null || config.getGridThickness() <= 0) {
            return "格子厚度（gridThickness）必须大于0";
        }
        
        return null; // 验证通过
    }

    @Override
    public String getDefaultLogicParams() {
        Map<String, Object> defaultParams = new HashMap<>();
        
        // 默认格子范围配置：第一行1~52格，第二行53~101格
        List<Map<String, Object>> gridRanges = new ArrayList<>();
        
        Map<String, Object> row1 = new HashMap<>();
        row1.put("row", 1);
        row1.put("start", 1);
        row1.put("end", 52);
        gridRanges.add(row1);
        
        Map<String, Object> row2 = new HashMap<>();
        row2.put("row", 2);
        row2.put("start", 53);
        row2.put("end", 101);
        gridRanges.add(row2);
        
        defaultParams.put("gridRanges", gridRanges);
        
        // 默认每格尺寸（mm）
        defaultParams.put("gridLength", 2000);   // 长度2000mm
        defaultParams.put("gridWidth", 1500);    // 宽度1500mm
        defaultParams.put("gridThickness", 5);   // 厚度5mm
        
        try {
            return objectMapper.writeValueAsString(defaultParams);
        } catch (Exception e) {
            log.error("生成默认逻辑参数失败", e);
            return "{}";
        }
    }
}