package com.eternal.rfid;


import com.eternal.event.DeviceWorkEvent;
import com.eternal.monitor.AbstractEquipmentManager;
import com.eternal.monitor.constant.ErrorTypeEnums;
import com.eternal.monitor.constant.StatusTypeEnums;
import com.eternal.monitor.entity.Device;
import com.eternal.monitor.entity.DeviceErrorType;
import com.eternal.monitor.entity.DeviceStatus;
import com.eternal.monitor.entity.DeviceType;
import com.eternal.rfid.params.UF3ReaderConfig;
import com.eternal.rfid.service.UF3RFIDReader;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * description: 略
 *
 * @author senzhi
 * @since 2026/1/19 17:14
 */
@Slf4j
@Service("UF3RFIDReader")
public class RfidReaderServer extends AbstractEquipmentManager {
    @Autowired
    private ApplicationEventPublisher eventPublisher;

    @Autowired
    private UF3ReaderConfig readerConfig;

    @Getter
    private final List<UF3RFIDReader> readers = new ArrayList<>();
    /**
     * 是否允许读写器工作
     */
    private boolean enableWork = true;

    public void setEnableWork(boolean enableWork) {
        log.info("RfidReaderServer work mode changed. from {} --> {}", this.enableWork, enableWork);
        this.enableWork = enableWork;
    }

    @EventListener(DeviceWorkEvent.class)
    public void onDeviceWorkEvent(DeviceWorkEvent event) {
        setEnableWork(event.isEnableWork());
    }

    private final static int maxTryTime = 3;

    private final AtomicInteger currentRunIndex = new AtomicInteger(-1);
    private final AtomicInteger tryTime = new AtomicInteger(0);

    @PostConstruct
    public void init() {
        String readerKey = readerConfig.getReaderKey();
        String[] antennasKey = new String[4];
        for (int j = 0; j < 4; j++) {
            antennasKey[j] = "reader" + 1 + "-antenna" + (j + 1);
        }
        UF3RFIDReader uf3RFIDReader = new UF3RFIDReader(readerKey, "uf3-rfid-reader", antennasKey, "reader-antenna");
        readers.add(uf3RFIDReader);
        start();
    }

    @Override
    public void start() {
        for (int i = 0; i < readers.size(); i++) {
            UF3RFIDReader uf3RFIDReader = readers.get(i);
            uf3RFIDReader.setUpdateDeviceStatusConsumer(this::updateDeviceStatus);
            uf3RFIDReader.setEventConsumer(event -> eventPublisher.publishEvent(event));
            uf3RFIDReader.init(i, readerConfig);

        }
        log.info("RfidReaderServer create finished,reader number:{}", readers.size());
    }

    @Scheduled(initialDelay = 100, fixedDelay = 3000)
    public void checkingTimer() {
        try {
            if (enableWork) {
                if (currentRunIndex.get() < 0) {
                    currentRunIndex.set(0);
                }

                UF3RFIDReader uf3RFIDReader = readers.get(currentRunIndex.get());
                if (uf3RFIDReader.isOnline()) {
                    log.debug("ZebraReader<ip:{}> is online", uf3RFIDReader.getIp());
                    return;
                }

                log.info("Try to connect to ZebraReader<ip:{}>，attempts：{}", uf3RFIDReader.getIp(), tryTime.get());
                uf3RFIDReader.start();
                if (uf3RFIDReader.isOnline()) {
                    tryTime.set(0);
                    return;
                }

                // 超过最大尝试次数，切换下一个读写器
                if (tryTime.incrementAndGet() > maxTryTime) {
                    log.warn("The ZebraReader<{}> exceeds the maximum attempts number<{}>, switch to the next reader", uf3RFIDReader.getIp(), maxTryTime);

                    // 重置尝试次数
                    tryTime.set(0);
                    // 切换下一个读写器
                    currentRunIndex.incrementAndGet();
                    if (currentRunIndex.get() >= readers.size()) {
                        currentRunIndex.set(0);
                    }
                }
            } else {
                if (currentRunIndex.get() < 0) {
                    log.debug("The node is not ACTIVE, do not connect to RFIDReader");
                    return;
                }
                UF3RFIDReader zebraRFIDReader = readers.get(currentRunIndex.get());
                zebraRFIDReader.disconnectReader();
                currentRunIndex.set(-1);

                log.info("The node is not ACTIVE, disconnect from RFIDReader");
            }
        } catch (Exception e) {
            log.error("RfidReaderServer checkingTimer error", e);
        }
    }

    /**
     * 启动读
     */
    public void startRead() {
        if (enableWork) {
            if (currentRunIndex.get() < 0) {
                log.warn("It is not working and cannot be started.");
                return;
            }
            UF3RFIDReader zebraRFIDReader = readers.get(currentRunIndex.get());
            try {
                zebraRFIDReader.startRead();
            } catch (Exception e) {
                log.error("Failed to start read.", e);
            }

        }

    }

    /**
     * 停止读
     */
    public void stopRead() {
        if (enableWork) {
            if (currentRunIndex.get() < 0) {
                log.warn("It is not working and cannot be stopped.");
                return;
            }
            UF3RFIDReader zebraRFIDReader = readers.get(currentRunIndex.get());
            zebraRFIDReader.stopRead();
        }
    }


    @PreDestroy
    public void destroy() {
        if (enableWork) {
            if (currentRunIndex.get() < 0) {
                return;
            }

            UF3RFIDReader zebraRFIDReader = readers.get(currentRunIndex.get());
            zebraRFIDReader.disconnectReader();
            currentRunIndex.set(-1);

            log.info("Close the rfid-reader before closing the application");
        }
    }

    @Override
    public void initDevices() {
        for (UF3RFIDReader reader : readers) {
            int index = reader.getIndex();
            // 添加设备类型
            DeviceType readerType = new DeviceType();
            readerType.setDeviceTypeKey("zebra-rfid-reader");
            readerType.setName("东集读写器");
            readerType.setTypeDescription("东集读写器");
            addDeviceType(readerType);
            DeviceType antennaType = new DeviceType();
            antennaType.setDeviceTypeKey("reader-antenna");
            antennaType.setName("读写器天线");
            antennaType.setTypeDescription("RFID读写器天线");
            addDeviceType(antennaType);

            // 添加状态
            for (StatusTypeEnums.Common value : StatusTypeEnums.Common.values()) {
                // 读写器状态
                DeviceStatus readerStatus = new DeviceStatus();
                readerStatus.setDeviceTypeKey(readerType.getDeviceTypeKey());
                readerStatus.setDeviceStatusKey(value.getKey());
                readerStatus.setName(value.getName());
                readerStatus.setStatusDescription(value.getDescription());
                addDeviceStatusType(readerStatus);
                // 天线状态
                DeviceStatus antennaStatus = new DeviceStatus();
                antennaStatus.setDeviceTypeKey(antennaType.getDeviceTypeKey());
                antennaStatus.setDeviceStatusKey(value.getKey());
                antennaStatus.setName(value.getName());
                antennaStatus.setStatusDescription(value.getDescription());
                addDeviceStatusType(antennaStatus);
            }

            // 添加错误码
            for (ErrorTypeEnums.Common value : ErrorTypeEnums.Common.values()) {
                DeviceErrorType readerErrorType = new DeviceErrorType(readerType.getDeviceTypeKey(), value.getKey(), value.getName(), value.getDescription());
                addDeviceErrorType(readerErrorType);
                DeviceErrorType antennaErrorType = new DeviceErrorType(readerType.getDeviceTypeKey(), value.getKey(), value.getName(), value.getDescription());
                addDeviceErrorType(antennaErrorType);
            }

            // 添加设备
            Device readerDevice = new Device();
            readerDevice.setDeviceKey(reader.getReaderKey());
            readerDevice.setName(readerConfig.getEquipType() + (index + 1));
            readerDevice.setDeviceTypeKey(readerType.getDeviceTypeKey());
            readerDevice.setDeviceStatusKey(StatusTypeEnums.Common.UNKNOWN.getKey());
            addDevice(readerDevice);
            for (int i = 0; i < 4; i++) {
                Device antennaDevice = new Device();
                antennaDevice.setParentDeviceKey(readerDevice.getDeviceKey());
                antennaDevice.setDeviceKey(reader.getAntennasKey()[i]);
                antennaDevice.setName("reader" + (index + 1) + "-antenna" + (i + 1));
                antennaDevice.setDeviceTypeKey(antennaType.getDeviceTypeKey());
                antennaDevice.setDeviceStatusKey(StatusTypeEnums.Common.UNKNOWN.getKey());
                antennaDevice.setParentDeviceKey(readerDevice.getDeviceKey());
                addDevice(antennaDevice);
            }
        }

    }
}