package com.topdraw.config;

import lombok.Data;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.RabbitListenerContainerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.amqp.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.naming.ConfigurationException;
import java.util.Map;
import java.util.Objects;

@Data
//@Configuration
public class RabbitMqSourceConfig {

    /*@Value("${mutil-mq.service.host}")
    private String serviceHost;
    @Value("${mutil-mq.service.port}")
    private Integer servicePort;
    @Value("${mutil-mq.service.username}")
    private String serviceUserName;
    @Value("${mutil-mq.service.password}")
    private String servicePassword;
    @Value("${mutil-mq.service.virtual-host}")
    private String serviceVirtualHost;

    public static final String SERVICE_ = "serviceRabbitListenerContainerFactory";

    @Bean(name = "serviceConnectionFactory")
    @Primary
    public ConnectionFactory serviceConnectionFactory(){
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(serviceHost);
        connectionFactory.setPort(servicePort);
        connectionFactory.setUsername(serviceUserName);
        connectionFactory.setPassword(servicePassword);
        connectionFactory.setVirtualHost(serviceVirtualHost);
        return connectionFactory;
    }

    @Bean(name = SERVICE_)
    @Primary
    public RabbitListenerContainerFactory serviceRabbitListenerContainerFactory(
            SimpleRabbitListenerContainerFactoryConfigurer containerFactoryConfigurer,
            @Qualifier("serviceConnectionFactory") ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        containerFactoryConfigurer.configure(factory, connectionFactory);
        return factory;
    }

    @Bean(name = "serviceRabbitTemplate")
    public RabbitTemplate serviceRabbitTemplate(ConnectionFactory serviceConnectionFactory){
        RabbitTemplate rabbitTemplate = new RabbitTemplate(serviceConnectionFactory);
        return rabbitTemplate;
    }

    @Bean(name = "serviceRabbitAdmin")
    public RabbitAdmin serviceRabbitAdmin(
            @Qualifier("serviceConnectionFactory") ConnectionFactory connectionFactory) {
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
        rabbitAdmin.setAutoStartup(true);
        return rabbitAdmin;
    }


    public static final String MANAGEMENT_ = "managementRabbitListenerContainerFactory";

    @Value("${mutil-mq.management.host}")
    private String managementHost;
    @Value("${mutil-mq.management.port}")
    private Integer managementPort;
    @Value("${mutil-mq.management.username}")
    private String managementUserName;
    @Value("${mutil-mq.management.password}")
    private String managementPassword;
    @Value("${mutil-mq.management.virtual-host}")
    private String managementVirtualHost;

    @Bean(name = "managementConnectionFactory")
    public ConnectionFactory managementConnectionFactory(){
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(managementHost);
        connectionFactory.setPort(managementPort);
        connectionFactory.setUsername(managementUserName);
        connectionFactory.setPassword(managementPassword);
        connectionFactory.setVirtualHost(managementVirtualHost);
        return connectionFactory;
    }

    @Bean(name = MANAGEMENT_)
    public RabbitListenerContainerFactory managementRabbitListenerContainerFactory(
            SimpleRabbitListenerContainerFactoryConfigurer containerFactoryConfigurer,
            @Qualifier("managementConnectionFactory") ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        containerFactoryConfigurer.configure(factory, connectionFactory);
        return factory;
    }

    @Bean(name = "managementRabbitTemplate")
    public RabbitTemplate managementRabbitTemplate(ConnectionFactory managementConnectionFactory){
        RabbitTemplate rabbitTemplate = new RabbitTemplate(managementConnectionFactory);
        return rabbitTemplate;
    }

    @Bean(name = "managementRabbitAdmin")
    public RabbitAdmin managementRabbitAdmin(
            @Qualifier("managementConnectionFactory") ConnectionFactory connectionFactory) {
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
        rabbitAdmin.setAutoStartup(true);
        return rabbitAdmin;
    }*/


    /**************************************************数据源*************************************************************/


   /* @Value("${service.platform}")
    private String platform;
    @Value("${service.active}")
    private String active;

    public String getActiveSource() throws ConfigurationException {

        if (StringUtils.isBlank(platform))
            throw new ConfigurationException("【error】=> platform is none !! ");

        if (StringUtils.isBlank(active))
            throw new ConfigurationException("【error】=> active is none !! ");

        if (active.equalsIgnoreCase("service,management") || active.equalsIgnoreCase("management,service")) {
            return "service,management";
        }

        return active;
    }

    private String chargeSource(String active) {

        if (active.equalsIgnoreCase("management")) {
            return MANAGEMENT_;
        }

        if (active.equalsIgnoreCase("service")) {
            return SERVICE_;
        }

        return null;
    }*/

    /**************************************************uc-getaway 2 uc-consumer*************************************************************/



    /*@Value("#{rabbitMqCustomConfig.ucgGrowthReportInfo()}")
    private Map<String, String> ucgGrowthReportInfo;

    public static final String GROWTH_REPORT_EXCHANGE = "growthReport.exchange";
    public static final String GROWTH_REPORT_QUEUE = "growthReport.queue";

    public String getGrowthReportQueue(){
        if (Objects.nonNull(ucgGrowthReportInfo)) {
            if (MapUtils.isNotEmpty(ucgGrowthReportInfo)) {
                String queue = ucgGrowthReportInfo.get("queue");
                return queue;
            }
        }

        return GROWTH_REPORT_QUEUE;
    }

    public String getGrowthReportSource(){
        if (Objects.nonNull(ucgGrowthReportInfo)) {
            if (MapUtils.isNotEmpty(ucgGrowthReportInfo)) {
                String source = ucgGrowthReportInfo.get("active");
                if (StringUtils.isNotBlank(source)) {
                    return this.chargeSource(source);
                } else {
                    return SERVICE_;
                }
            }
        }

        return SERVICE_;
    }

    public String getGrowthReportStartUp(){
        if (Objects.nonNull(ucgGrowthReportInfo)) {
            if (MapUtils.isNotEmpty(ucgGrowthReportInfo)) {
                String source = ucgGrowthReportInfo.get("active");
                if (StringUtils.isNotBlank(source)) {
                    return "true";
                }
            }
        }

        return "false";
    }

    public static final String EVENT_EXCHANGE = "event.exchange";
    public static final String EVENT_QUEUE = "event.queue";

    @Value("#{rabbitMqCustomConfig.getUcgEventInfo()}")
    private Map<String, String> ucgEventInfo;

    public String getUcgEventQueue(){
        if (Objects.nonNull(ucgEventInfo)) {
            if (MapUtils.isNotEmpty(ucgEventInfo)) {
                String queue = ucgEventInfo.get("queue");
                return queue;
            }
        }

        return EVENT_QUEUE;
    }

    public String getUcgEventSource(){
        if (Objects.nonNull(ucgEventInfo)) {
            if (MapUtils.isNotEmpty(ucgEventInfo)) {
                String source = ucgEventInfo.get("active");
                if (StringUtils.isNotBlank(source)) {
                    return this.chargeSource(source);
                } else {
                    return SERVICE_;
                }
            }
        }

        return SERVICE_;
    }

    public String getUcgEventStartUp(){
        if (Objects.nonNull(ucgEventInfo)) {
            if (MapUtils.isNotEmpty(ucgEventInfo)) {
                String source = ucgEventInfo.get("active");
                if (StringUtils.isNotBlank(source)) {
                    return "true";
                }
            }
        }

        return "false";
    }

    public static final String COLLECTION_EXCHANGE = "collection.exchange";
    public static final String COLLECTION_QUEUE = "collection.queue";

    @Value("#{rabbitMqCustomConfig.getUcgCollectionInfo()}")
    private Map<String, String> ucgIptvCollectionInfo;

    public String getUcgCollectionQueue(){
        if (Objects.nonNull(ucgIptvCollectionInfo)) {
            if (MapUtils.isNotEmpty(ucgIptvCollectionInfo)) {
                String queue = ucgIptvCollectionInfo.get("queue");
                return queue;
            }
        }

        return COLLECTION_QUEUE;
    }

    public String getUcgCollectionQueueAdd(){
        return "queue.collection.add";
    }

    public String getUcgCollectionQueueDelete(){
        return "queue.collection.delete";
    }

    public String getUcgCollectionQueueDeleteAll(){
        return "queue.collection.deleteall";
    }

    public String getUcgCollectionSource(){
        if (Objects.nonNull(ucgIptvCollectionInfo)) {
            if (MapUtils.isNotEmpty(ucgIptvCollectionInfo)) {
                String source = ucgIptvCollectionInfo.get("active");
                if (StringUtils.isNotBlank(source)) {
                    return this.chargeSource(source);
                } else {
                    return SERVICE_;
                }
            }
        }

        return SERVICE_;
    }

    public String getUcgCollectionStartUp(){
        if (Objects.nonNull(ucgIptvCollectionInfo)) {
            if (MapUtils.isNotEmpty(ucgIptvCollectionInfo)) {
                String source = ucgIptvCollectionInfo.get("active");
                if (StringUtils.isNotBlank(source)) {
                    return "true";
                }
            }
        }

        return "false";
    }

    public static final String VIEW_RECORD_EXCHANGE = "viewRecord.exchange";
    public static final String VIEW_RECORD_QUEUE = "viewRecord.queue";

    @Value("#{rabbitMqCustomConfig.getViewRecordInfo()}")
    private Map<String, String> viewRecordInfo;

    public String getViewRecordQueue(){
        if (Objects.nonNull(viewRecordInfo)) {
            if (MapUtils.isNotEmpty(viewRecordInfo)) {
                String queue = viewRecordInfo.get("queue");
                return queue;
            }
        }

        return VIEW_RECORD_QUEUE;
    }

    public String getViewRecordSource(){
        if (Objects.nonNull(viewRecordInfo)) {
            if (MapUtils.isNotEmpty(viewRecordInfo)) {
                String source = viewRecordInfo.get("active");
                if (StringUtils.isNotBlank(source)) {
                    return this.chargeSource(source);
                } else {
                    return SERVICE_;
                }
            }
        }

        return SERVICE_;
    }

    public String getViewRecordStartUp(){
        if (Objects.nonNull(viewRecordInfo)) {
            if (MapUtils.isNotEmpty(viewRecordInfo)) {
                String source = viewRecordInfo.get("active");
                if (StringUtils.isNotBlank(source)) {
                    return "true";
                }
            }
        }

        return "false";
    }*/

    /**************************************************uc-engine 2 uc-consumer*************************************************************/

    /*public static final String UCE_EXCHANGE = "uce.exchange";
    public static final String UCE_QUEUE = "uce.queue";

    @Value("#{rabbitMqCustomConfig.getUceInfo()}")
    private Map<String, String> uceInfo;

    public String getUceQueue(){
        if (Objects.nonNull(uceInfo)) {
            if (MapUtils.isNotEmpty(uceInfo)) {
                String queue = uceInfo.get("queue");
                return queue;
            }
        }

        return UCE_QUEUE;
    }

    public String getUceSource(){
        if (Objects.nonNull(uceInfo)) {
            if (MapUtils.isNotEmpty(uceInfo)) {
                String source = uceInfo.get("active");
                if (StringUtils.isNotBlank(source)) {
                    return this.chargeSource(source);
                } else {
                    return MANAGEMENT_;
                }
            }
        }

        return MANAGEMENT_;
    }

    public String getUceStartUp(){
        if (Objects.nonNull(uceInfo)) {
            if (MapUtils.isNotEmpty(uceInfo)) {
                String source = uceInfo.get("active");
                if (StringUtils.isNotBlank(source)) {
                    return "true";
                }
            }
        }

        return "false";
    }




    public String getMemberInfoAsyncQueue(){
        return "queue.MemberInfoSync";
    }*/

    /**************************************************eventBus*************************************************************/
    /*public static final String UC_EVENTBUS_EXCHANGE = "uc.eventbus";
    public static final String UC_EVENTBUS_KEY = "uc.eventbus.*.topic";
    public static final String UC_EVENTBUS_QUEUE = "uc.eventbus";

    @Value("#{rabbitMqCustomConfig.getEventBusInfo()}")
    private Map<String, String> eventBusInfo;

    public String getEventBusQueue(){
        if (Objects.nonNull(eventBusInfo)) {
            if (MapUtils.isNotEmpty(eventBusInfo)) {
                String queue = eventBusInfo.get("queue");
                return queue;
            }
        }
        return UC_EVENTBUS_QUEUE;
    }

    public String getEventBusSource(){
        if (Objects.nonNull(eventBusInfo)) {
            if (MapUtils.isNotEmpty(eventBusInfo)) {
                String source = eventBusInfo.get("active");
                if (StringUtils.isNotBlank(source)) {
                    return this.chargeSource(source);
                } else {
                    return SERVICE_;
                }
            }
        }

        return SERVICE_;
    }

    public String getEventBusStartUp(){
        if (Objects.nonNull(eventBusInfo)) {
            if (MapUtils.isNotEmpty(eventBusInfo)) {
                String source = eventBusInfo.get("active");
                if (StringUtils.isNotBlank(source)) {
                    return "true";
                }
            }
        }
        return "false";
    }*/

    /**************************************************wechat*************************************************************/

    /*public static final String WEIXIN_EXCHANGE = "weixin.subOrUnSub.direct";
    public static final String WEIXIN_SUBORUNSUB_QUEUE = "weixin.subOrUnSub.queue";

    @Value("#{rabbitMqCustomConfig.getWechatInfo()}")
    private Map<String, String> wechatInfo;

    public String getWechatQueue(){
        if (Objects.nonNull(wechatInfo)) {
            if (MapUtils.isNotEmpty(wechatInfo)) {
                String queue = wechatInfo.get("queue");
                return queue;
            }
        }
        return WEIXIN_SUBORUNSUB_QUEUE;
    }

    public String getWechatSource(){
        if (Objects.nonNull(wechatInfo)) {
            if (MapUtils.isNotEmpty(wechatInfo)) {
                String source = wechatInfo.get("active");
                if (StringUtils.isNotBlank(source)) {
                    return this.chargeSource(source);
                } else {
                    return SERVICE_;
                }
            }
        }

        return SERVICE_;
    }

    public String getWechatStartUp(){
        if (Objects.nonNull(wechatInfo)) {
            if (MapUtils.isNotEmpty(wechatInfo)) {
                String source = wechatInfo.get("active");
                if (StringUtils.isNotBlank(source)) {
                    return "true";
                }
            }
        }

        return "false";
    }*/
}