package com.smartor.statemachine;

import com.ruoyi.common.utils.StringUtils;
import com.smartor.common.enums.InhospStateEnum;
import com.smartor.common.exception.StateTransitionException;
import com.smartor.domain.PatMedInhosp;
import com.smartor.service.IPatMedInhospService;
import com.smartor.statemachine.handler.InhospStateHandler;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

/**
 * 住院状态机管理器
 * 负责状态转换的协调和分布式锁管理
 *
 * @author smartor
 */
@Slf4j
@Component
public class InhospStateMachine {

    @Autowired
    private IPatMedInhospService patMedInhospService;

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Autowired
    private List<InhospStateHandler> handlers;

    /**
     * 状态处理器映射表
     */
    private final Map<String, InhospStateHandler> handlerMap = new ConcurrentHashMap<>();

    /**
     * 分布式锁超时时间（秒）
     */
    private static final int LOCK_TIMEOUT = 10;

    /**
     * 分布式锁前缀
     */
    private static final String LOCK_KEY_PREFIX = "inhosp:state:lock:";

    @PostConstruct
    public void init() {
        // 初始化处理器映射
        if (CollectionUtils.isNotEmpty(handlers)) {
            for (InhospStateHandler handler : handlers) {
                handlerMap.put(handler.getStateCode(), handler);
                log.info("【InhospStateMachine】注册状态处理器：{} -> {}",
                        handler.getStateCode(), handler.getClass().getSimpleName());
            }
        }
    }

    /**
     * 执行状态转换（带分布式锁）
     *
     * @param patMedInhosp 住院记录对象
     * @param targetState 目标状态
     * @return 是否成功
     */
    public boolean transitionState(PatMedInhosp patMedInhosp, String targetState) {
        String serialnum = StringUtils.trim(patMedInhosp.getSerialnum());
        String orgid = StringUtils.trim(patMedInhosp.getOrgid());

        if (StringUtils.isEmpty(serialnum) || StringUtils.isEmpty(orgid)) {
            log.error("【InhospStateMachine】serialnum或orgid为空，无法执行状态转换");
            return false;
        }

        // 生成分布式锁key（不包含state，锁住整个患者记录）
        String lockKey = LOCK_KEY_PREFIX + serialnum + ":" + orgid;
        Boolean locked = false;

        try {
            // 尝试获取分布式锁
            locked = redisTemplate.opsForValue().setIfAbsent(lockKey, "1", LOCK_TIMEOUT, TimeUnit.SECONDS);

            if (locked == null) {
                log.warn("【InhospStateMachine】Redis不可用，降级为无锁执行，serialnum={}, orgid={}", serialnum, orgid);
                return executeStateTransition(patMedInhosp, targetState);
            }

            if (!Boolean.TRUE.equals(locked)) {
                log.warn("【InhospStateMachine】获取分布式锁失败，其他线程正在处理，serialnum={}, orgid={}", serialnum, orgid);
                return false;
            }

            // 获取锁成功，执行状态转换
            return executeStateTransition(patMedInhosp, targetState);

        } catch (Exception e) {
            log.error("【InhospStateMachine】状态转换异常：serialnum={}, orgid={}, targetState={}, 错误：{}",
                    serialnum, orgid, targetState, e.getMessage(), e);
            return false;
        } finally {
            // 释放锁
            if (Boolean.TRUE.equals(locked)) {
                try {
                    redisTemplate.delete(lockKey);
                    log.debug("【InhospStateMachine】释放分布式锁成功，lockKey={}", lockKey);
                } catch (Exception e) {
                    log.warn("【InhospStateMachine】释放分布式锁失败：lockKey={}, 错误：{}", lockKey, e.getMessage());
                }
            }
        }
    }

    /**
     * 执行状态转换逻辑
     *
     * @param patMedInhosp 住院记录对象
     * @param targetState 目标状态
     * @return 是否成功
     */
    private boolean executeStateTransition(PatMedInhosp patMedInhosp, String targetState) {
        String serialnum = patMedInhosp.getSerialnum();
        String orgid = patMedInhosp.getOrgid();

        log.info("【InhospStateMachine】开始执行状态转换：serialnum={}, orgid={}, targetState={}",
                serialnum, orgid, targetState);

        // 1. 查询当前状态
        PatMedInhosp query = new PatMedInhosp();
        query.setSerialnum(StringUtils.trim(serialnum));
        query.setOrgid(StringUtils.trim(orgid));
        query.setPatno(StringUtils.trim(patMedInhosp.getPatno()));
        query.setInhospstate(null); // 查询所有状态

        List<PatMedInhosp> existingRecords = patMedInhospService.selectPatMedInhosp(query);
        String currentState = null;

        if (CollectionUtils.isNotEmpty(existingRecords)) {
            // 如果存在多条记录，取最新的一条（理论上经过状态机后不应该有多条）
            currentState = existingRecords.get(0).getInhospstate();
            log.info("【InhospStateMachine】当前状态：{}", currentState);
        }

        // 2. 验证状态转换是否合法
        if (!InhospStateEnum.isValidTransition(currentState, targetState)) {
            log.error("【InhospStateMachine】非法的状态转换：从 [{}] 到 [{}]，serialnum={}, orgid={}",
                    currentState, targetState, serialnum, orgid);
            throw new StateTransitionException(currentState, targetState);
        }

        // 3. 获取对应的状态处理器
        InhospStateHandler handler = handlerMap.get(targetState);
        if (handler == null) {
            log.error("【InhospStateMachine】未找到状态处理器：targetState={}", targetState);
            return false;
        }

        // 4. 执行状态处理
        boolean result = handler.handle(patMedInhosp);

        if (result) {
            log.info("【InhospStateMachine】状态转换成功：serialnum={}, orgid={}, {} -> {}",
                    serialnum, orgid, currentState, targetState);
        } else {
            log.warn("【InhospStateMachine】状态转换失败：serialnum={}, orgid={}, {} -> {}",
                    serialnum, orgid, currentState, targetState);
        }

        return result;
    }

    /**
     * 获取当前状态
     *
     * @param serialnum 流水号
     * @param orgid 机构ID
     * @param patno 患者编号
     * @return 当前状态码，如果不存在返回null
     */
    public String getCurrentState(String serialnum, String orgid, String patno) {
        PatMedInhosp query = new PatMedInhosp();
        query.setSerialnum(StringUtils.trim(serialnum));
        query.setOrgid(StringUtils.trim(orgid));
        query.setPatno(StringUtils.trim(patno));
        query.setInhospstate(null);

        List<PatMedInhosp> records = patMedInhospService.selectPatMedInhosp(query);

        if (CollectionUtils.isEmpty(records)) {
            return null;
        }

        return records.get(0).getInhospstate();
    }
}