#include <stdarg.h>

#include "mock.h"

const amqp_table_t amqp_empty_table = { 0, nullptr };

AmqpMock* amqp_mock_instance = nullptr;

amqp_connection_state_t AmqpMock::defaultConnectionState = reinterpret_cast<amqp_connection_state_t>(1);
amqp_socket_t* AmqpMock::defaultSocket = reinterpret_cast<amqp_socket_t*>(2);
amqp_rpc_reply_t AmqpMock::defaultRpcReply {
    static_cast<amqp_response_type_enum>(AMQP_RESPONSE_NORMAL),
    { 0, nullptr },
    0
};

void AmqpMock::setInstance(AmqpMock* value)
{
    amqp_mock_instance = value;
}

void AmqpMock::clearInstance(AmqpMock* value)
{
    if (amqp_mock_instance == value)
    amqp_mock_instance = nullptr;
}

const char* amqp_error_string2(int err)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_error_string2(err) : nullptr); }

amqp_channel_open_ok_t* amqp_channel_open(amqp_connection_state_t state, amqp_channel_t channel)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_channel_open(state, channel) : nullptr); }

amqp_rpc_reply_t amqp_get_rpc_reply(amqp_connection_state_t state)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_get_rpc_reply(state) : AmqpMock::defaultRpcReply); }

amqp_rpc_reply_t amqp_channel_close(amqp_connection_state_t state, amqp_channel_t channel, int code)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_channel_close(state, channel, code) : amqp_rpc_reply_t {  }); }

amqp_queue_declare_ok_t* amqp_queue_declare(amqp_connection_state_t state, amqp_channel_t channel, amqp_bytes_t queue, amqp_boolean_t passive, amqp_boolean_t durable, amqp_boolean_t exclusive, amqp_boolean_t auto_delete, amqp_table_t arguments)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_queue_declare(state, channel, queue, passive, durable, exclusive, auto_delete, arguments) : nullptr); }

void amqp_release_buffers(amqp_connection_state_t state)
    { if (amqp_mock_instance) amqp_mock_instance->amqp_release_buffers(state); }

amqp_rpc_reply_t amqp_consume_message(amqp_connection_state_t state, amqp_envelope_t *envelope, struct timeval *timeout, int flags)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_consume_message(state, envelope, timeout, flags) : AmqpMock::defaultRpcReply); }

int amqp_simple_wait_frame_noblock(amqp_connection_state_t state, amqp_frame_t *decoded_frame, struct timeval *tv)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_simple_wait_frame_noblock(state, decoded_frame, tv) : 0); }

amqp_rpc_reply_t amqp_read_message(amqp_connection_state_t state, amqp_channel_t channel, amqp_message_t *message, int flags)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_read_message(state, channel, message, flags) : AmqpMock::defaultRpcReply); }

amqp_rpc_reply_t amqp_connection_close(amqp_connection_state_t state, int code)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_connection_close(state, code) : AmqpMock::defaultRpcReply); }

void amqp_destroy_envelope(amqp_envelope_t *envelope)
    { if (amqp_mock_instance) amqp_mock_instance->amqp_destroy_envelope(envelope); }

void amqp_destroy_message(amqp_message_t *message)
    { if (amqp_mock_instance) amqp_mock_instance->amqp_destroy_message(message); }

int amqp_destroy_connection(amqp_connection_state_t state)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_destroy_connection(state) : 0); }

void amqp_maybe_release_buffers(amqp_connection_state_t state)
    { if (amqp_mock_instance) amqp_mock_instance->amqp_maybe_release_buffers(state); }

amqp_connection_state_t amqp_new_connection(void)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_new_connection() : AmqpMock::defaultConnectionState); }

amqp_socket_t* amqp_tcp_socket_new(amqp_connection_state_t state)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_tcp_socket_new(state) : AmqpMock::defaultSocket); }

int amqp_socket_open(amqp_socket_t *self, const char *host, int port)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_socket_open(self, host, port) : 0); }

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wvarargs"
amqp_rpc_reply_t amqp_login(amqp_connection_state_t state, char const *vhost, int channel_max, int frame_max, int heartbeat, amqp_sasl_method_enum sasl_method, ...)
{
    if (!amqp_mock_instance)
        return AmqpMock::defaultRpcReply;
    amqp_rpc_reply_t ret;
    va_list args;
    va_start(args, sasl_method);
    switch (sasl_method)
    {
        case AMQP_SASL_METHOD_PLAIN:
        {
            const char* username = va_arg(args, const char*);
            const char* password = va_arg(args, const char*);
            ret = amqp_mock_instance->amqp_login_plain(state, vhost, channel_max, frame_max, heartbeat, sasl_method, username, password);
        }
        break;

        case AMQP_SASL_METHOD_EXTERNAL:
        {
            const char* token = va_arg(args, const char*);
            ret = amqp_mock_instance->amqp_login_external(state, vhost, channel_max, frame_max, heartbeat, sasl_method, token);
        }
        break;

        default:
            ret = AmqpMock::defaultRpcReply;
    }
    va_end(args);
    return ret;
}
#pragma clang diagnostic pop

amqp_queue_bind_ok_t* amqp_queue_bind(amqp_connection_state_t state, amqp_channel_t channel, amqp_bytes_t queue, amqp_bytes_t exchange, amqp_bytes_t routing_key, amqp_table_t arguments)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_queue_bind(state, channel, queue, exchange, routing_key, arguments) : nullptr); }

int amqp_basic_publish(amqp_connection_state_t state, amqp_channel_t channel, amqp_bytes_t exchange, amqp_bytes_t routing_key, amqp_boolean_t mandatory, amqp_boolean_t immediate, struct amqp_basic_properties_t_ const *properties, amqp_bytes_t body)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_basic_publish(state, channel, exchange, routing_key, mandatory, immediate, properties, body) : 0); }

amqp_basic_consume_ok_t* amqp_basic_consume(amqp_connection_state_t state, amqp_channel_t channel, amqp_bytes_t queue, amqp_bytes_t consumer_tag, amqp_boolean_t no_local, amqp_boolean_t no_ack, amqp_boolean_t exclusive, amqp_table_t arguments)
    { return (amqp_mock_instance ? amqp_mock_instance->amqp_basic_consume(state, channel, queue, consumer_tag, no_local, no_ack, exclusive, arguments) : nullptr); }