#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <sys/types.h>
#include <poll.h>
#include <unistd.h>

#include "librez.h"
#include "modify.h"
#include "myserv.h"
#include "myqueue.h"
#include "simple_list.h"

static void	librez_myqueue_buffer(t_slist **reftab, t_slist **line, t_slist *d_list, int *buffsize)
{
  t_slist	*p_list;
  char		*p;

  p = memchr(d_list->buf, '\n', d_list->nbytes);
  p_list = malloc(sizeof(t_slist));
  p_list->nbytes = p ? p - (char *)d_list->buf : d_list->nbytes;
  p_list->buf = malloc(p_list->nbytes * sizeof(char *));
  memcpy(p_list->buf, d_list->buf, p_list->nbytes);
  d_list->buf = (char *)d_list->buf + p_list->nbytes;
  d_list->nbytes -= p_list->nbytes;
  if (((char *)p_list->buf)[p_list->nbytes - 1] == '\r')
    {
      --p_list->nbytes;
      --*buffsize;
    }
  p_list->next = NULL;
  simple_list_push(reftab, p_list);
  if (d_list->nbytes)
    {
      --*buffsize;
      p_list = simple_list_splice(reftab);
      p_list = simple_list_join(&p_list);
      if (((char *)p_list->buf)[p_list->nbytes - 1] == '\r')
	{
	  --p_list->nbytes;
	  --*buffsize;
	}
      simple_list_push(line, p_list);
    }
  d_list->buf = (char *)d_list->buf + 1;
  --d_list->nbytes;
  while (d_list->nbytes > 0)
    if ((p = memchr(d_list->buf, '\n', d_list->nbytes)))
      {
	--*buffsize;
	p_list = malloc(sizeof(t_slist));
	p_list->nbytes = p - (char *)d_list->buf;
	p_list->buf = malloc((p_list->nbytes + 1) * sizeof(char *));
	memcpy(p_list->buf, d_list->buf, p_list->nbytes);
	d_list->buf = (char *)d_list->buf + p_list->nbytes + 1;
	d_list->nbytes -= (p_list->nbytes + 1);
	if (((char *)p_list->buf)[p_list->nbytes - 1] == '\r')
	  {
	    --p_list->nbytes;
	    --*buffsize;
	  }
	p_list->next = NULL;
	simple_list_push(line, p_list);
      }
    else
      {
	p_list = malloc(sizeof(t_slist));
	p_list->nbytes = d_list->nbytes;
	p_list->buf = malloc(p_list->nbytes * sizeof(char *));
	memcpy(p_list->buf, d_list->buf, p_list->nbytes);
	d_list->buf = (char *)d_list->buf + p_list->nbytes;
	d_list->nbytes -= p_list->nbytes;
	p_list->next = NULL;
	simple_list_push(reftab, p_list);
      }
}

void		librez_myqueue_rdnorm(t_rez *d_rez, int ifds)
{
  t_slist	**reftab;
  t_slist	**line;
  t_slist	d_list;
  char		buf[256];

  reftab = (t_slist **)&d_rez->buffer[ifds][LIBREZ_BUFFER_QUEUE_RDNORM];
  line = (t_slist **)&d_rez->buffer[ifds][LIBREZ_BUFFER_LINE_RDNORM];
  d_list.buf = buf;
  if (d_rez->ssl[d_rez->tl_ifds_2_rezid[ifds]])
    {
      d_list.nbytes = SSL_read(d_rez->ssl[d_rez->tl_ifds_2_rezid[ifds]], buf, sizeof(buf));
    }
  else
    d_list.nbytes = read(d_rez->fds[ifds].fd, buf, sizeof(buf));
  d_rez->buffer_size[ifds][LIBREZ_BUFFER_ISIZE] += d_list.nbytes;
  if (d_rez->buffsize[LIBREZ_BUFFER_ISIZE] &&
      d_rez->buffer_size[ifds][LIBREZ_BUFFER_ISIZE] > d_rez->buffsize[LIBREZ_BUFFER_ISIZE])
    {
      librez_myserv_hup(ifds, d_rez);
      return ;
    }
  librez_myqueue_buffer(reftab, line, &d_list, &d_rez->buffer_size[ifds][LIBREZ_BUFFER_ISIZE]);
}

void		librez_myqueue_wrnorm(t_rez *d_rez, int ifds, t_slist *d_list)
{
  t_slist	**reftab;
  t_slist	**line;
  t_slist	*p_list;
  t_slist	c_list;
  int		nb;

  reftab = (t_slist **)&d_rez->buffer[ifds][LIBREZ_BUFFER_QUEUE_WRNORM];
  line = (t_slist **)&d_rez->buffer[ifds][LIBREZ_BUFFER_LINE_WRNORM];
  if (d_list)
    {
      c_list.buf = d_list->buf;
      c_list.nbytes = d_list->nbytes;
      d_rez->buffer_size[ifds][LIBREZ_BUFFER_OSIZE] += c_list.nbytes;
      if (d_rez->buffsize[LIBREZ_BUFFER_OSIZE] &&
	  d_rez->buffer_size[ifds][LIBREZ_BUFFER_OSIZE] > d_rez->buffsize[LIBREZ_BUFFER_OSIZE])
	{
	  librez_myserv_hup(ifds, d_rez);
	  return ;
	}
      librez_myqueue_buffer(reftab, line, &c_list, &d_rez->buffer_size[ifds][LIBREZ_BUFFER_OSIZE]);
      if (*line)
	librez_modify(d_rez, ifds, !0);
    }
  else
    {
      p_list = *line;
      if (((char *)p_list->buf)[p_list->nbytes - 1] != '\n')
	{
	  p_list = malloc(sizeof(t_slist));
	  p_list->buf = malloc(((*line)->nbytes + 1) * sizeof(char *));
	  memcpy(p_list->buf, (*line)->buf, (*line)->nbytes);
	  memcpy((char *)p_list->buf + (*line)->nbytes, "\n", 1);
	  p_list->nbytes = (*line)->nbytes + 1;
	  ++d_rez->buffer_size[ifds][LIBREZ_BUFFER_OSIZE];
	  simple_list_delete(line);
	  p_list->next = NULL;
	  simple_list_unshift(line, p_list);
	}
      if (d_rez->ssl[d_rez->tl_ifds_2_rezid[ifds]])
	{
	  nb = SSL_write(d_rez->ssl[d_rez->tl_ifds_2_rezid[ifds]], p_list->buf, p_list->nbytes);
	}
      else
	nb = write(d_rez->fds[ifds].fd, p_list->buf, p_list->nbytes);
      memmove(p_list->buf, (char *)p_list->buf + nb, p_list->nbytes - nb);
      p_list->nbytes -= nb;
      d_rez->buffer_size[ifds][LIBREZ_BUFFER_OSIZE] -= nb;
      if (!p_list->nbytes)
	simple_list_delete(line);
      if (!*line)
	librez_modify(d_rez, ifds, 0);
    }
}

void		librez_myqueue_pfnorm(t_rez *d_rez, t_librez_fd rezid, const char *format, ...)
{
  t_slist	d_list;
  va_list	ap;

  va_start(ap, format);
  d_list.nbytes = vasprintf((char **)&d_list.buf, format, ap);
  va_end(ap);
  librez_myqueue_wrnorm(d_rez, d_rez->tl_rezid_2_ifds[rezid], &d_list);
  free(d_list.buf);
}

void		librez_myqueue_vpfnorm(t_rez *d_rez, t_librez_fd rezid, const char *format, va_list ap)
{
  t_slist	d_list;

  d_list.nbytes = vasprintf((char **)&d_list.buf, format, ap);
  librez_myqueue_wrnorm(d_rez, d_rez->tl_rezid_2_ifds[rezid], &d_list);
  free(d_list.buf);
}