package com.fdkankan.modeling.constants;

import com.fdkankan.common.util.FileUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.core.env.MapPropertySource;
import org.springframework.core.env.StandardEnvironment;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Component
public class SysConstants implements ApplicationContextAware {
    private static final Logger log = LoggerFactory.getLogger(SysConstants.class);

    public static String hostName;
    public static int modelTimeOut;

    public static boolean isResidenceService = true;

    public static volatile Boolean SYSTEM_BUILDING = false;
    public static volatile Boolean SYSTEM_OFFING = false;

    private List<String> residenceServices = null;

    public static final String SYSTEM_PREFIX = "model-center";

    public static final String SCENE_BUILDING = SYSTEM_PREFIX+":scene:building:num:";
    public static final String SCENE_MESSAGE_BUILDING = SYSTEM_PREFIX+":scene:building:message:";

    public static ExecutorService executorService = Executors.newFixedThreadPool(1);

    public static Set<String> callingNum = new HashSet<>();

    public static Set<String> interrupCallingNums = new HashSet<>();

    @Value("${hostName.filePath:/opt/hosts/hosts.txt}")
    public void setHostName(String filePath){
        try {
            SysConstants.hostName = FileUtils.readFile(filePath);
            // 去除空格
            if(!ObjectUtils.isEmpty(SysConstants.hostName)){
                SysConstants.hostName = SysConstants.hostName.trim().replaceAll("\\s","");
            }
            log.error("从文件({})中获取服务器名称:{}", filePath,hostName);
            initIsResidenceService();
        } catch (Exception e) {
            log.error("从文件中获取服务器名称失败,文件路径{}", filePath);
            e.printStackTrace();
        }
    }

    /**
     * 默认超时时间2天
     * @param timeOut
     */
    @Value("${model.timeOut:48}")
    public void setModelTimeOut(int timeOut){
        SysConstants.modelTimeOut = timeOut;
    }

    /**
     * 常驻服务实例ID集合
     */
    @Value("${residenceService.hostNames:#{null}}")
    public void setResidenceServiceHostName(String[] hostNames){
        if (!ObjectUtils.isEmpty(hostNames)) {
            residenceServices = Arrays.asList(hostNames);
            initIsResidenceService();
        }
    }

    private void initIsResidenceService() {
        if(CollectionUtils.isEmpty(residenceServices) || ObjectUtils.isEmpty(SysConstants.hostName)){
            log.error("判断常驻服务失败！");
            return;
        }
        log.info("常驻服务列表：{}", residenceServices);
        log.info("当前服务名称：{}", SysConstants.hostName);
        isResidenceService = residenceServices.contains(hostName);
        log.info("当前服务是否是常驻服务：{}", isResidenceService);
    }

    @Override
    public void setApplicationContext(ApplicationContext context) throws BeansException {
        Map<String,Object> params = new HashMap<>();
        if (isResidenceService) {
            params.put("mq.consumerPriority",1);

        } else {
            params.put("mq.consumerPriority",0);
        }
        ((StandardEnvironment)context.getEnvironment()).getPropertySources()
                .addLast(new MapPropertySource("mq.consumerPriority",params));
    }
}