#include <stdlib.h>
#include <unistd.h>

#include <stdio.h>
#include <pthread.h>

#include "list.h"
#include "pthread_pool.h"
#include "task_queue.h"

#define FREE( ptr )     \
    if( ptr )           \
        free( ptr );

/* create_task -- create new task_t struct.
 * @func: function for the task.
 * @args: argument of the @func
 * return: allocated task.
 */
task_t *create_task( func_t func, void* args ) {
      task_t *tmp = (task_t*)malloc(sizeof(task_t));
      tmp->func = func;
      tmp->args = args;
      return tmp;
}

/* queue_init -- allocate structure and init values with zero/NULL. 
 * return: ptr to allocated queue.
 */
task_queue_t *queue_init( void ) {
   task_queue_t *queue = (task_queue_t*)malloc( sizeof(task_queue_t) );
   queue->size = 0;
   queue->head = NULL;
   queue->tail = NULL;
   return queue;
}

/* queue_destroy -- destory task list. Free queue. 
 * @queue: queue.
 */
void queue_destroy( task_queue_t *queue ) {
   task_list_t *tmp = queue->head;
   while( queue->head ) { 
      tmp = queue->head->next;
      FREE( queue->head->task );
      FREE( queue->head );
      queue->head = tmp;
   }
   FREE( queue );
}

/* enqueue -- add a task to the task_queue in the queue. 
 * @queue: main queue.
 * @task: task for addition.
 */
void enqueue( task_queue_t *queue, task_t *task ) {
   task_list_t *tmp = (task_list_t*)malloc(sizeof(task_list_t));
   tmp->task = task; 
   tmp->next = NULL;

   queue->size++; 
   if( queue->head != NULL ) { 
      queue->tail->next = tmp;  /* NOTE: Save current task in the last item. */
      queue->tail = tmp;        /* NOTE: Make new task the last. */
   } else {
      queue->head = tmp;
      queue->tail = tmp;
   }
}

/* dequeue -- delete and return the first element. 
 * @queue: main queue.
 * return: first task from queue.
 */
task_t *dequeue( task_queue_t *queue ) {
   task_list_t  *tmp = queue->head;
   task_t       *tmp_task;

   if( tmp == NULL ) {
        fputs( "dequeue: queue is empty.\n", stderr );
        return NULL;
   }
   tmp_task = tmp->task;
   queue->head = tmp->next;
   queue->size--;
   free( tmp );
   return tmp_task;
}
/* TODO: Need? */
int queque_size( task_queue_t *queue ) {
   return queue->size;
}

/* DEBUG */
void print_queue( task_queue_t *queue ) {   
   task_list_t *tmp  = queue->head;
   fprintf( stderr, "Queue size: %d\n", queue->size );
   while( tmp ) {
      fprintf( stderr, "Address: %p\n", (void*)tmp );
      tmp = tmp->next;
   }
}