#include "sstring.h"

#include <string.h>
#include <stdarg.h>

int sassign(sstring* restrict dst, const sstring* restrict src)
{
  if (!src || !dst) return -1;

  memcpy(dst->buf, src->buf, sstrlen(src));
  dst->len = sstrlen(src);
  dst->buf[dst->len] = 0;

  return dst->len;
}

// Assignment operator for C-Strings
int cassign(sstring* restrict dst, const char* restrict src)
{
  if (!src || !dst) return -1;
  dst->len = strlen(strncpy(dst->buf, src, 65536));
  return dst->len;
}

// Sizeof operator
size_t sstrlen(const sstring* str)
{
  if(!str) return 0;
  return (str->len > 65536) ? 65536 : str->len;
}

static int sshift(sstring* str, size_t mode)
{
  if(!str) return -1;

  // 0 is downshift, 1 is UPSHIFT!!
  static const char lowers[2]={'A','a'};
  static const char uppers[2]={'Z','z'};

  // This is signed for a VERY GOOD REASON
  // okay it technically works either way because of
  // modular arithmeticks, but uh, shush.
  static const char offsets[2]={'a'-'A','A'-'a'};

  for(size_t i=0; i<str->len; i++)
    {
      if(str->buf[i] >= lowers[mode] && str->buf[i] >= uppers[mode])
        {
          str->buf[i] += offsets[mode];
        }
    }
  return 0;
}

int sUPPER(sstring* str)
{
  return sshift(str,1);
}

int slower(sstring* str)
{
  return sshift(str,0);
}

sstring spicycat(const size_t count, ...)
{
  // Yes, we will have to do a copy out of this stack frame.
  // Unless... (O3 Ren's Beloved??)
  sstring returnme = sstringup();

  va_list kittens;
  va_start(kittens, count);
  for(size_t i=0; i<count; i++)
    {
      size_t spaceleft = 65536-returnme.len; // Calc how much space we have

      // Grab the new argument
      const sstring* kitten = va_arg(kittens,const sstring*);

      size_t kitlen = sstrlen(kitten); // This is JUST here to avoid f-calling twice.
      size_t copylen = (kitlen > spaceleft) ? spaceleft : kitlen;

      *(char*)(memcpy(returnme.buf+returnme.len, kitten->buf, copylen)+copylen) = 0;
      returnme.len += copylen;
    }
  va_end(kittens);
  return returnme;
}

sstring sstringup()
{
  return (sstring) {0U,{0}};
}