#include <stdio.h>
#include <string.h>

#include "base.h"
#include "icommand.h"
#include "iqueue.h"
#include "iblockingqueue.h"
#include "linkedqueue.h"
#include "linked_blockingqueue.h"

static void LinkedBlockingQueue_push(IQueue*, ICommand*);
static ICommand* LinkedBlockingQueue_pop(IQueue*);
static int LinkedBlockingQueue_empty(IQueue*);

LinkedBlockingQueue* LinkedBlockingQueue_construct(void* addr)
{
    if (addr == NULL) {
        return NULL;
    }

    LinkedBlockingQueue* linkedBlockingQueue = addr;
    linkedBlockingQueue->queue = &new(LinkedQueue)->iqueue;

    pthread_mutexattr_t attr;
    int err = pthread_mutexattr_init(&attr);

    if (err) {
        fprintf(stderr, "pthread_mutexattr_init error. [err=%s]",
                strerror(err));
        return NULL;
    }

    err = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);

    if (err) {
        fprintf(stderr, "pthread_mutexattr_settype error. [err=%s]",
                strerror(err));
        return NULL;
    }

    err = pthread_mutex_init(&linkedBlockingQueue->mutex, &attr);

    if (err) {
        fprintf(stderr, "pthread_mutex_init error. [err=%s]",
                strerror(err));
        return NULL;
    }

    err = pthread_cond_init(&linkedBlockingQueue->cond, NULL);

    if (err) {
        fprintf(stderr, "pthread_cond_init error. [err=%s]",
                strerror(err));
        return NULL;
    }

    linkedBlockingQueue->push = LinkedBlockingQueue_push;
    linkedBlockingQueue->pop = LinkedBlockingQueue_pop;
    linkedBlockingQueue->empty = LinkedBlockingQueue_empty;

    return linkedBlockingQueue;
}

void LinkedBlockingQueue_destruct(LinkedBlockingQueue* linkedBlockingQueue)
{
    int err = pthread_cond_destroy(&linkedBlockingQueue->cond);

    if (err) {
        fprintf(stderr, "pthread_cond_destroy error. [err=%s]",
                strerror(err));
    }

    err = pthread_mutex_destroy(&linkedBlockingQueue->mutex);

    if (err) {
        fprintf(stderr, "pthread_mutex_destroy error. [err=%s]",
                strerror(err));
    }

    LinkedQueue* linkedQueue =
        container_of(linkedBlockingQueue->queue, LinkedQueue, iqueue);
    delete(LinkedQueue, linkedQueue);
}

void LinkedBlockingQueue_push(IQueue* iqueue, ICommand* command)
{
    LinkedBlockingQueue* linkedBlockingQueue =
        container_of(iqueue, LinkedBlockingQueue, iqueue);

    int err = pthread_mutex_lock(&linkedBlockingQueue->mutex);

    if (err) {
        fprintf(stderr, "pthread_mutex_lock error. [err=%s]",
                strerror(err));
        return;
    }

    linkedBlockingQueue->queue->push(iqueue, command);

    err = pthread_mutex_unlock(&linkedBlockingQueue->mutex);

    if (err) {
        fprintf(stderr, "pthread_mutex_unlock error. [err=%s]",
                strerror(err));
    }

    err = pthread_cond_signal(&linkedBlockingQueue->cond);

    if (err) {
        fprintf(stderr, "pthread_cond_signal error. [err=%s]",
                strerror(err));
    }
}

ICommand* LinkedBlockingQueue_pop(IQueue* iqueue)
{
    LinkedBlockingQueue* linkedBlockingQueue =
        container_of(iqueue, LinkedBlockingQueue, iqueue);

    int err = pthread_mutex_lock(&linkedBlockingQueue->mutex);

    if (err) {
        fprintf(stderr, "pthread_mutex_lock error. [err=%s]",
                strerror(err));
        return NULL;
    }

    while (linkedBlockingQueue->empty(iqueue)) {
        err = pthread_cond_wait(&linkedBlockingQueue->cond,
                                &linkedBlockingQueue->mutex);

        if (err) {
            fprintf(stderr, "pthread_cond_wait error. [err=%s]",
                    strerror(err));
            return NULL;
        }
    }

    ICommand* command =
        linkedBlockingQueue->queue->pop(linkedBlockingQueue->queue);
    err = pthread_mutex_unlock(&linkedBlockingQueue->mutex);

    if (err) {
        fprintf(stderr, "pthread_mutex_unlock error. [err=%s]",
                strerror(err));
        return NULL;
    }

    return command;
}

int LinkedBlockingQueue_empty(IQueue* iqueue)
{
    LinkedBlockingQueue* linkedBlockingQueue =
        container_of(iqueue, LinkedBlockingQueue, iqueue);

    int isEmpty;
    int err = pthread_mutex_lock(&linkedBlockingQueue->mutex);

    if (err) {
        fprintf(stderr, "pthread_mutex_lock error. [err=%s]",
                strerror(err));
    }

    isEmpty = linkedBlockingQueue->queue->empty(linkedBlockingQueue->queue);

    err = pthread_mutex_unlock(&linkedBlockingQueue->mutex);

    if (err) {
        fprintf(stderr, "pthread_mutex_unlock error. [err=%s]",
                strerror(err));
    }

    return isEmpty;
}