package com.mes.step;

import com.mes.core.StationContext;
import com.mes.device.IDeviceDriver;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 重置设备计数步骤
 * 向PLC指定地址写入指定值，用于重置设备计数器（如拉铆枪计数）
 * 支持配置多个地址的写入操作
 */
public class ResetDeviceCountStep extends AbstractStep {

    private int address = 8;   // 默认地址8
    private int value = 1;     // 默认值1
    
    // 支持清零多个地址
    private List<AddressValue> clearAddresses = new ArrayList<>();
    
    /**
     * 地址-值对
     */
    private static class AddressValue {
        int address;
        int value;
        
        AddressValue(int address, int value) {
            this.address = address;
            this.value = value;
        }
    }

    public ResetDeviceCountStep() {
        super("reset_device_count", "重置设备计数");
        this.async = false;
        this.requiresUserInteraction = false;
    }

    @Override
    public void configure(Map<String, Object> config) {
        super.configure(config);
        this.address = getConfigInt("address", 8);
        this.value = getConfigInt("value", 1);
        
        // 读取清零地址配置（可选）
        Object clearAddressesObj = config.get("clear_addresses");
        if (clearAddressesObj instanceof List) {
            List<?> list = (List<?>) clearAddressesObj;
            for (Object item : list) {
                if (item instanceof Map) {
                    Map<?, ?> map = (Map<?, ?>) item;
                    int addr = getIntValue(map.get("address"), 0);
                    int val = getIntValue(map.get("value"), 0);
                    if (addr > 0) {
                        clearAddresses.add(new AddressValue(addr, val));
                    }
                }
            }
        }
    }
    
    private int getIntValue(Object obj, int defaultValue) {
        if (obj instanceof Number) {
            return ((Number) obj).intValue();
        }
        return defaultValue;
    }

    @Override
    public boolean execute(StationContext context) {
        // 检查设备是否启用
        if (!context.isDeviceEnabled()) {
            log.info("[{}] 设备未启用，跳过重置计数", context.getStationCode());
            return true;
        }

        IDeviceDriver driver = context.getDeviceDriver();
        if (driver == null) {
            log.warn("[{}] 设备驱动未配置，跳过重置计数", context.getStationCode());
            return true;
        }

        try {
            // 1. 向指定地址写入指定值（如地址8写1，告诉PLC可以开始）
            driver.writeRegister(address, value);
            log.info("[{}] 重置设备计数：向地址{}写入{}", context.getStationCode(), address, value);

            // 可选：读取验证
            int readValue = driver.readRegister(address);
            log.debug("[{}] 验证读取地址{}的值：{}", context.getStationCode(), address, readValue);

            // 2. 清零其他地址（如地址66、68、70，清零拉铆枪计数器）
            if (!clearAddresses.isEmpty()) {
                for (AddressValue av : clearAddresses) {
                    driver.writeRegister(av.address, av.value);
                    log.info("[{}] 清零地址{}，写入值：{}", context.getStationCode(), av.address, av.value);
                }
                log.info("[{}] 已清零{}个地址", context.getStationCode(), clearAddresses.size());
            }

            context.setStatusMessage("设备计数已重置", 0);
            return true;

        } catch (Exception e) {
            log.error("[{}] 重置设备计数失败：{}", context.getStationCode(), e.getMessage());
            context.setStatusMessage("重置设备计数失败", -1);
            return false;
        }
    }

    @Override
    public void onSuccess(StationContext context) {
        super.onSuccess(context);
    }

    @Override
    public boolean canExecute(StationContext context) {
        // 质量检查通过且设备已启用
        return context.isQualityPassed() && context.isDeviceEnabled();
    }

    @Override
    public boolean canSkip(StationContext context) {
        // 设备未启用时跳过
        return !context.isDeviceEnabled();
    }

    // ========== 流程监控扩展 ==========

    @Override
    public java.util.List<StepCondition> getConditions(StationContext context) {
        java.util.List<StepCondition> conditions = new java.util.ArrayList<>();
        conditions.add(condition("qualityPassed", "质量检查通过", context.isQualityPassed()));
        conditions.add(condition("deviceEnabled", "设备已启用", context.isDeviceEnabled()));
        return conditions;
    }

    @Override
    public void simulateSuccess(StationContext context) {
        log.info("[{}] 模拟重置设备计数", context.getStationCode());
        context.setStatusMessage("设备计数已重置（模拟）", 0);
        onSuccess(context);
    }
}