#include "net_mod_socket_io.h"
#include "socket_io.h"
#include <stdint.h> 

ssize_t rio_read_until_sep(rio_t *rp, char *usrbuf, size_t maxlen, const char *sep)
{
  int n, rc;
  char c;
  char *bufp = usrbuf;
  int sep_i = 0;
  int sep_len = strlen(sep);

  for (n = 0; n < maxlen; n++)
  {
    if ((rc = rio_readnb(rp, &c, 1)) == 1)
    {
      
      *bufp++ = c;
      
      if(c == *(sep + sep_i)) {
        sep_i++;
        if(sep_i == sep_len) {
             
          break;
        } 
      } else {

        sep_i = 0;
      }

    }
    else if (rc == 0)
    {
      if (n == 0)
        return 0; /* EOF, no data read */
      else
        break;    /* EOF, some data was read */
    }
    else
      return -1;    /* Error */
  }

  if(sep_i == sep_len) {
    *(bufp - sep_len) = 0;
    return n - sep_len;
  } else {
    return -1;
  }
  
}



int is_little_endian() {
  int test_num = 0xff;
  unsigned char* byte_start = (unsigned char*) &test_num;

  if (byte_start[0] == 0xff) {
    return 1;
  }
  return 0;
}

void swap_bytes(void *pv, size_t n)
{
    assert(n > 0);

    char *p = (char *)pv;
    size_t lo, hi;
    for(lo=0, hi=n-1; hi>lo; lo++, hi--)
    {
        char tmp=p[lo];
        p[lo] = p[hi];
        p[hi] = tmp;
    }
}


//! Byte swap unsigned short
uint16_t swap_uint16( uint16_t val ) 
{
    return (val << 8) | (val >> 8 );
}

//! Byte swap short
int16_t swap_int16( int16_t val ) 
{
    return (val << 8) | ((val >> 8) & 0xFF);
}

//! Byte swap unsigned int
uint32_t swap_uint32( uint32_t val )
{
    val = ((val << 8) & 0xFF00FF00 ) | ((val >> 8) & 0xFF00FF ); 
    return (val << 16) | (val >> 16);
}

//! Byte swap int
int32_t swap_int32( int32_t val )
{
    val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF ); 
    return (val << 16) | ((val >> 16) & 0xFFFF);
}


int64_t swap_int64( int64_t val )
{
    val = ((val << 8) & 0xFF00FF00FF00FF00ULL ) | ((val >> 8) & 0x00FF00FF00FF00FFULL );
    val = ((val << 16) & 0xFFFF0000FFFF0000ULL ) | ((val >> 16) & 0x0000FFFF0000FFFFULL );
    return (val << 32) | ((val >> 32) & 0xFFFFFFFFULL);
}

uint64_t swap_uint64( uint64_t val )
{
    val = ((val << 8) & 0xFF00FF00FF00FF00ULL ) | ((val >> 8) & 0x00FF00FF00FF00FFULL );
    val = ((val << 16) & 0xFFFF0000FFFF0000ULL ) | ((val >> 16) & 0x0000FFFF0000FFFFULL );
    return (val << 32) | (val >> 32);
}