package com.panzhihua.service_community.config;

import org.springframework.amqp.core.*;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

//@Configuration
public class RabbitmqConfig {


    public static final String PreOrder_QUEUE="huacheng.preOrder.queue";
    public static final String PreOrder_ROUTING_KEY="huacheng.preOrder.key";
    public static final String PreOrder_EXCHANGE="huacheng.preOrder.exchange";

    public static final String Order_QUEUE="huacheng.order.queue";
    public static final String Order_ROUTING_KEY="huacheng.order.key";
    public static final String Order_EXCHANGE="huacheng.order.exchange";

    public static final String RAFFLE_QUEUE="huacheng.raffle.queue";
    public static final String RAFFLE_ROUTING_KEY="huacheng.raffle.key";
    public static final String RAFFLE_EXCHANGE="huacheng.raffle.exchange";

    public static final String McsOrder_QUEUE="huacheng.mcsOrder.queue";
    public static final String McsOrder_ROUTING_KEY="huacheng.mcsOrder.key";
    public static final String McsOrder_EXCHANGE="huacheng.mcsOrder.exchange";

    public static final String ACID_QUEUE="huacheng.acid.queue";
    public static final String ACID_ROUTING_KEY="huacheng.acid.key";
    public static final String ACID_EXCHANGE="huacheng.acid.exchange";

    public static final String ACID_DANGER_QUEUE = "huacheng.acid.danger.queue";
    public static final String ACID_DANGER_ROUTING_KEY = "huacheng.acid.danger.key";
    public static final String ACID_DANGER_EXCHANGE = "huacheng.acid.danger.exchange";

    public static final String ACID_DIRECT_QUEUE = "huacheng.acid.direct.queue";
    public static final String ACID_DIRECT_ROUTING_KEY = "huacheng.acid.direct.key";
    public static final String ACID_DIRECT_EXCHANGE = "huacheng.acid.direct.exchange";

    public static final String ACID_MESSAGE_QUEUE="huacheng.acid.message.queue";
    public static final String ACID_MESSAGE_ROUTING_KEY = "huacheng.acid.message.key";
    public static final String ACID_MESSAGE_EXCHANGE = "huacheng.acid.message.exchange";

    /**
     * 服务商城订单
     */
    public static final String SHOP_ORDER_QUEUE="huacheng.shop.order.queue";
    public static final String SHOP_ORDER_ROUTING_KEY = "huacheng.shop.order.key";
    public static final String SHOP_ORDER_EXCHANGE = "huacheng.shop.order.exchange";

    @Bean
    public Queue preOrderQueue(){
        return new Queue(PreOrder_QUEUE,true,false,false,null);
    }

    @Bean
    public Exchange preOrderExchange(){
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-delayed-type", ExchangeTypes.DIRECT);
        return new CustomExchange(PreOrder_EXCHANGE,"x-delayed-message",true,false,arguments);
    }

    @Bean
    public Binding preOrderBinding(){
        return BindingBuilder.bind(preOrderQueue()).to(preOrderExchange()).with(PreOrder_ROUTING_KEY).noargs();
    }

    @Bean
    public Queue raffleQueue(){
        return new Queue(RAFFLE_QUEUE,true,false,false,null);
    }

    @Bean
    public Exchange raffleExchange(){
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-delayed-type", ExchangeTypes.DIRECT);
        return new CustomExchange(RAFFLE_EXCHANGE,"x-delayed-message",true,false,arguments);
    }

    @Bean
    public Binding raffleBinding(){
        return BindingBuilder.bind(raffleQueue()).to(raffleExchange()).with(RAFFLE_ROUTING_KEY).noargs();
    }

    @Bean
    public Queue acidQueue(){
        return new Queue(ACID_QUEUE,true,false,false,null);
    }

    @Bean
    public Exchange acidExchange(){
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-delayed-type", ExchangeTypes.DIRECT);
        return new CustomExchange(ACID_EXCHANGE,"x-delayed-message",true,false,arguments);
    }

    @Bean
    public Binding acidBinding(){
        return BindingBuilder.bind(acidQueue()).to(acidExchange()).with(ACID_ROUTING_KEY).noargs();
    }

    @Bean
    public Queue acidDangerQueue(){
        return new Queue(ACID_DANGER_QUEUE,true,false,false,null);
    }

    @Bean
    public Exchange acidDangerExchange(){
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-delayed-type", ExchangeTypes.DIRECT);
        return new CustomExchange(ACID_DANGER_EXCHANGE,"x-delayed-message",true,false,arguments);
    }

    @Bean
    public Binding acidDangerBinding(){
        return BindingBuilder.bind(acidDangerQueue()).to(acidDangerExchange()).with(ACID_DANGER_ROUTING_KEY).noargs();
    }

    @Bean
    public Queue acidDirectQueue(){
        return new Queue(ACID_DIRECT_QUEUE,true,false,false,null);
    }

    @Bean
    public Exchange acidDirectExchange(){
        return new DirectExchange(ACID_DIRECT_EXCHANGE,true,false);
    }

    @Bean
    public Binding acidDirectBinding(){
        return BindingBuilder.bind(acidDirectQueue()).to(acidDirectExchange()).with(ACID_DIRECT_ROUTING_KEY).noargs();
    }
    @Bean
    public Queue acidMessageQueue(){
        return new Queue(ACID_MESSAGE_QUEUE,true,false,false,null);
    }

    @Bean
    public Exchange acidMessageExchange(){
        return new DirectExchange(ACID_MESSAGE_EXCHANGE,true,false);
    }

    @Bean
    public Binding acidMessageBinding(){
        return BindingBuilder.bind(acidMessageQueue()).to(acidMessageExchange()).with(ACID_MESSAGE_ROUTING_KEY).noargs();
    }

    @Bean
    public Queue mcsOrderQueue(){
        return new Queue(McsOrder_QUEUE,true,false,false,null);
    }

    @Bean
    public Exchange mcsOrderExchange(){
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-delayed-type", ExchangeTypes.DIRECT);
        return new CustomExchange(McsOrder_EXCHANGE,"x-delayed-message",true,false,arguments);
    }

    @Bean
    public Binding mcsOrderBinding(){
        return BindingBuilder.bind(mcsOrderQueue()).to(mcsOrderExchange()).with(McsOrder_ROUTING_KEY).noargs();
    }

    @Bean
    public Queue orderQueue(){
        return new Queue(Order_QUEUE,true,false,false,null);
    }

    @Bean
    public Exchange orderExchange(){
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-delayed-type", ExchangeTypes.DIRECT);
        return new CustomExchange(Order_EXCHANGE,"x-delayed-message",true,false,arguments);
    }

    @Bean
    public Binding orderBinding(){
        return BindingBuilder.bind(orderQueue()).to(orderExchange()).with(Order_ROUTING_KEY).noargs();
    }

    public Queue directQueue() {
        // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
        //   return new Queue("TestDirectQueue",true,true,false);

        //一般设置一下队列的持久化就好,其余两个就是默认false
        return new Queue("directQueue",true);
    }

    //Direct交换机 起名：TestDirectExchange
    @Bean
    DirectExchange directExchange() {
        //  return new DirectExchange("TestDirectExchange",true,true);
        return new DirectExchange("directExchange",true,false);
    }

    //绑定  将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
    @Bean
    Binding bindingDirect() {
        return BindingBuilder.bind(directQueue()).to(directExchange()).with("directRouting");
    }


    public Queue pushQueue() {
        // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
        //   return new Queue("TestDirectQueue",true,true,false);

        //一般设置一下队列的持久化就好,其余两个就是默认false
        return new Queue("pushQueue",true);
    }

    //Direct交换机 起名：TestDirectExchange
    @Bean
    DirectExchange pushExchange() {
        //  return new DirectExchange("TestDirectExchange",true,true);
        return new DirectExchange("PUSH_Exchange",true,false);
    }

    //绑定  将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
    @Bean
    Binding bindingPush() {
        return BindingBuilder.bind(directQueue()).to(directExchange()).with("PUSH_ROUTING");
    }



    @Bean
    DirectExchange lonelyDirectExchange() {
        return new DirectExchange("lonelyDirectExchange");
    }

    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }


    @Bean
    public Queue shopOrderQueue(){
        return new Queue(SHOP_ORDER_QUEUE,true,false,false,null);
    }

    @Bean
    public Exchange shopOrderExchange(){
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-delayed-type", ExchangeTypes.DIRECT);
        return new CustomExchange(SHOP_ORDER_EXCHANGE,"x-delayed-message",true,false,arguments);
    }

    @Bean
    public Binding shopOrderBinding(){
        return BindingBuilder.bind(shopOrderQueue()).to(shopOrderExchange()).with(SHOP_ORDER_ROUTING_KEY).noargs();
    }
}