package com.yanzuoguang.mq.service;

import com.rabbitmq.client.Channel;
import com.yanzuoguang.mq.vo.MessageVo;
import com.yanzuoguang.mq.vo.QueueVo;
import com.yanzuoguang.mq.vo.req.*;
import io.swagger.annotations.ApiOperation;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;

/**
 * 消息队列服务
 *
 * @author 颜佐光
 */
public interface MqService {
    /**
     * 创建队列
     *
     * @param req 需要发送的消息
     * @return 创建队列
     */
    @ApiOperation(value = "创建队列")
    String createQueue(QueueVo req);

    /**
     * 发送消息
     *
     * @param req 需要发送的消息
     * @return 消息编号，但是没有任何意义，发送成功会更改
     */
    @ApiOperation(value = "发送消息")
    String message(MessageVo req);


    /**
     * 发送消息
     *
     * @param req 需要发送的消息
     * @param now 是否立即发送
     * @return 消息编号，但是没有任何意义，发送成功会更改
     */
    @ApiOperation(value = "发送消息")
    String message(MessageVo req, boolean now);

    /**
     * 发送错误消息
     *
     * @param req
     * @return
     */
    @ApiOperation(value = "发送错误消息")
    String messageError(MessageVo req);

    /**
     * 消息收到确认
     *
     * @param message 收到的消息
     * @param channel 　收到的通道
     */
    @ApiOperation(value = "消息收到确认")
    void basicAck(Message message, Channel channel);

    /**
     * 动态注册消费者回调队列
     *
     * @param queueName       队列名称
     * @param messageListener 　消费者
     * @return
     */
    @ApiOperation(value = "动态注册消费者回调队列")
    SimpleMessageListenerContainer setQueueConsumer(String queueName, ChannelAwareMessageListener messageListener);

    /**
     * 动态注册消费者回调队列
     *
     * @param queueName       队列名称
     * @param concurrency     　消费者数量
     * @param messageListener 　消费者
     * @return
     */
    @ApiOperation(value = "动态注册消费者回调队列")
    SimpleMessageListenerContainer setQueueConsumer(String queueName, int concurrency, ChannelAwareMessageListener messageListener);

    /**
     * 动态注册消费者回调队列
     *
     * @param queueName       队列名称
     * @param concurrency     　消费者数量
     * @param maxConcurrency  　最大消费者数量
     * @param messageListener 　消费者
     * @return
     */
    @ApiOperation(value = "动态注册消费者回调队列")
    SimpleMessageListenerContainer setQueueConsumer(String queueName, int concurrency, int maxConcurrency, ChannelAwareMessageListener messageListener);


    /**
     * 建立当前服务器的队列
     *
     * @param req 请求数据
     * @return
     */
    @ApiOperation(value = "建立当前服务器的队列")
    String createServerQueue(ServerQueueReqVo req);

    /**
     * 删除当前服务器的队列
     *
     * @param req 请求数据
     * @return
     */
    @ApiOperation(value = "删除当前服务器的队列")
    String removeServerQueue(ServerQueueReqVo req);

    /**
     * 注册当前服务器的token，超期后需要重新注册
     *
     * @param req
     * @return
     */
    @ApiOperation(value = "注册当前服务器的token，超期后需要重新注册")
    String registerServerToken(RegisterServerTokenReqVo req);

    /**
     * 删除token的执行
     *
     * @param req
     */
    @ApiOperation(value = "删除token的执行")
    void removeServerToken(RegisterServerTokenReqVo req);

    /**
     * 删除token的执行
     *
     * @param req
     */
    @ApiOperation(value = "删除token的执行")
    void removeToken(RegisterServerTokenReqVo req);

    /**
     * 注册当前消费队列的回调
     *
     * @param req      请求数据
     * @param listener 处理函数
     * @return
     */
    @ApiOperation(value = "注册当前消费队列的回调")
    String setServerQueueConsumer(ServerQueueReqVo req, ChannelAwareMessageListener listener);

    /**
     * 注册当前消费队列的回调
     *
     * @param req         请求数据
     * @param concurrency 　消费者数量
     * @param listener    处理函数
     * @return
     */
    @ApiOperation(value = "注册当前消费队列的回调")
    String setServerQueueConsumer(ServerQueueReqVo req, int concurrency, ChannelAwareMessageListener listener);

    /**
     * 发送给指定服务器消息
     *
     * @param req
     * @return
     */
    @ApiOperation(value = "发送给指定服务器消息")
    String sendServerMessage(ServerMessageReqVo req);


    /**
     * 写入当前对象
     *
     * @param message 当前消息的内容
     * @return
     */
    @ApiOperation(value = "写入当前对象")
    void logCurrent(Message message);

    /**
     * 删除当前对象
     *
     * @return
     */
    @ApiOperation(value = "写入当前对象")
    void logCurrentRemove();

    /**
     * 记录一个消息已完成
     *
     * @return
     */
    @ApiOperation(value = "记录一个消息已完成，重复时抛出CodeException异常")
    String log();

    /**
     * 记录一个消息已完成
     *
     * @param req 消息的内容
     * @return
     */
    @ApiOperation(value = "记录一个消息已完成，重复时抛出CodeException异常")
    String log(MessageLogReqVo req);

    /**
     * 删除一个消息
     *
     * @param req 消息的内容
     * @return
     */
    @ApiOperation(value = "删除一个消息")
    String logRemove(MessageLogRemoveReqVo req);

    /**
     * 删除日期
     *
     * @param day
     */
    @ApiOperation(value = "删除日期")
    void logClear(String day);


}