/*
 * $Id$
 *
    Copyright (c) 2016-2020 Chung, Hyung-Hwan. All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:
    1. Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.
    2. Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.

    THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
    IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
    THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


str_t* FN(open) (mio_t* mio, mio_oow_t xtnsize, mio_oow_t capa)
{
	str_t* str;

	str = (str_t*)mio_allocmem(mio, MIO_SIZEOF(str_t) + xtnsize);
	if (str)
	{
		if (FN(init)(str, mio, capa) <= -1)
		{
			mio_freemem (mio, str);
			str = MIO_NULL;
		}
		else
		{
			MIO_MEMSET (str + 1, 0, xtnsize);
		}
	}
	return str;
}

void FN(close) (str_t* str)
{
	FN(fini) (str);
	mio_freemem (str->mio, str);
}

int FN(init) (str_t* str, mio_t* mio, mio_oow_t capa)
{
	MIO_MEMSET (str, 0, MIO_SIZEOF(str_t));

	str->mio = mio;
	str->sizer = MIO_NULL;

	if (capa == 0) str->val.ptr = MIO_NULL;
	else
	{
		str->val.ptr = (char_t*)mio_allocmem(mio, MIO_SIZEOF(char_t) * (capa + 1));
		if (!str->val.ptr) return -1;
		str->val.ptr[0] = '\0';
	}

	str->val.len = 0;
	str->capa = capa;

	return 0;
}

void FN(fini) (str_t* str)
{
	if (str->val.ptr) mio_freemem (str->mio, str->val.ptr);
}

int FN(yield) (str_t* str, cstr_t* buf, mio_oow_t newcapa)
{
	char_t* tmp;

	if (newcapa == 0) tmp = MIO_NULL;
	else
	{
		tmp = (char_t*)mio_allocmem(str->mio, MIO_SIZEOF(char_t) * (newcapa + 1));
		if (!tmp) return -1;
		tmp[0] = '\0';
	}

	if (buf) *buf = str->val;

	str->val.ptr = tmp;
	str->val.len = 0;
	str->capa = newcapa;

	return 0;
}

char_t* FN(yieldptr) (str_t* str, mio_oow_t newcapa)
{
	cstr_t mx;
	if (FN(yield)(str, &mx, newcapa) <= -1) return MIO_NULL;
	return mx.ptr;
}


mio_oow_t FN(setcapa) (str_t* str, mio_oow_t capa)
{
	char_t* tmp;

	if (capa == str->capa) return capa;

	tmp = (char_t*)mio_reallocmem(str->mio, str->val.ptr, MIO_SIZEOF(char_t) * (capa+1));
	if (!tmp) return (mio_oow_t)-1;

	if (capa < str->val.len)
	{
		str->val.len = capa;
		tmp[capa] = '\0';
	}

	str->capa = capa;
	str->val.ptr = tmp;

	return str->capa;
}

mio_oow_t FN(setlen) (str_t* str, mio_oow_t len)
{
	if (len == str->val.len) return len;
	if (len < str->val.len) 
	{
		str->val.len = len;
		str->val.ptr[len] = '\0';
		return len;
	}

	if (len > str->capa)
	{
		if (FN(setcapa)(str, len) == (mio_oow_t)-1) return (mio_oow_t)-1;
	}

	while (str->val.len < len) str->val.ptr[str->val.len++] = ' ';
	str->val.ptr[str->val.len] = '\0';
	return str->val.len;
}

void FN(clear) (str_t* str)
{
	str->val.len = 0;
	if (str->val.ptr)
	{
		MIO_ASSERT (str->mio, str->capa >= 1);
		str->val.ptr[0] = '\0';
	}
}

void FN(swap) (str_t* str, str_t* str1)
{
	str_t tmp;

	tmp.val.ptr = str->val.ptr;
	tmp.val.len = str->val.len;
	tmp.capa = str->capa;
	tmp.mio = str->mio;

	str->val.ptr = str1->val.ptr;
	str->val.len = str1->val.len;
	str->capa = str1->capa;
	str->mio = str1->mio;

	str1->val.ptr = tmp.val.ptr;
	str1->val.len = tmp.val.len;
	str1->capa = tmp.capa;
	str1->mio = tmp.mio;
}


mio_oow_t FN(cpy) (str_t* str, const char_t* s)
{
	/* TODO: improve it */
	return FN(ncpy)(str, s, count_chars(s));
}

mio_oow_t FN(ncpy) (str_t* str, const char_t* s, mio_oow_t len)
{
	if (len > str->capa || str->capa <= 0)
	{
		mio_oow_t tmp;

		/* if the current capacity is 0 and the string len to copy is 0
		 * we can't simply pass 'len' as the new capapcity.
		 * ecs_setcapa() won't do anything the current capacity of 0
		 * is the same as new capacity required. note that when str->capa 
		 * is 0, str->val.ptr is MIO_NULL. However, this is copying operation.
		 * Copying a zero-length string may indicate that str->val.ptr must
		 * not be MIO_NULL. so I simply pass 1 as the new capacity */
		tmp = FN(setcapa)(str, ((str->capa <= 0 && len <= 0)? 1: len));
		if (tmp == (mio_oow_t)-1) return (mio_oow_t)-1;
	}

	MIO_MEMCPY (&str->val.ptr[0], s, len * MIO_SIZEOF(*s));
	str->val.ptr[len] = '\0';
	str->val.len = len;
	return len;
}

mio_oow_t FN(cat) (str_t* str, const char_t* s)
{
	/* TODO: improve it. no counting */
	return FN(ncat)(str, s, count_chars(s));
}

static int FN(resize_for_ncat) (str_t* str, mio_oow_t len)
{
	if (len > str->capa - str->val.len) 
	{
		mio_oow_t ncapa, mincapa;

		/* let the minimum capacity be as large as 
		 * to fit in the new substring */
		mincapa = str->val.len + len;

		if (!str->sizer)
		{
			/* increase the capacity by the length to add */
			ncapa = mincapa;
			/* if the new capacity is less than the double,
			 * just double it */
			if (ncapa < str->capa * 2) ncapa = str->capa * 2;
		}
		else
		{
			/* let the user determine the new capacity.
			 * pass the minimum capacity required as a hint */
			ncapa = str->sizer(str, mincapa);
			/* if no change in capacity, return current length */
			if (ncapa == str->capa) return 0;
		}

		/* change the capacity */
		do
		{
			if (FN(setcapa)(str, ncapa) != (mio_oow_t)-1) break;
			if (ncapa <= mincapa) return -1;
			ncapa--;
		}
		while (1);
	}
	else if (str->capa <= 0 && len <= 0)
	{
		MIO_ASSERT (str->mio, str->val.ptr == MIO_NULL);
		MIO_ASSERT (str->mio, str->val.len <= 0);
		if (FN(setcapa)(str, 1) == (mio_oow_t)-1) return -1;
	}

	return 1;
}

mio_oow_t FN(ncat) (str_t* str, const char_t* s, mio_oow_t len)
{
	int n;
	mio_oow_t i, j;

	n = FN(resize_for_ncat)(str, len);
	if (n <= -1) return (mio_oow_t)-1;
	if (n == 0) return str->val.len;

	if (len > str->capa - str->val.len) 
	{
		/* copy as many characters as the number of cells available.
		 * if the capacity has been decreased, len is adjusted here */
		len = str->capa - str->val.len;
	}

	/*
	MIO_MEMCPY (&str->val.ptr[str->val.len], s, len*MIO_SIZEOF(*s));
	str->val.len += len;
	str->val.ptr[str->val.len] = T('\0');
	*/
	for (i = 0, j = str->val.len ; i < len; j++, i++) str->val.ptr[j] = s[i];
	str->val.ptr[j] = '\0';
	str->val.len = j;

	return str->val.len;
}

mio_oow_t FN(nrcat) (str_t* str, const char_t* s, mio_oow_t len)
{
	int n;
	mio_oow_t i, j;

	n = FN(resize_for_ncat)(str, len);
	if (n <= -1) return (mio_oow_t)-1;
	if (n == 0) return str->val.len;

	if (len > str->capa - str->val.len) len = str->capa - str->val.len;

	for (i = len, j = str->val.len ; i > 0; j++) str->val.ptr[j] = s[--i];
	str->val.ptr[j] = '\0';
	str->val.len = j;

	return str->val.len;
}

mio_oow_t FN(ccat) (str_t* str, char_t c)
{
	return FN(ncat)(str, &c, 1);
}

mio_oow_t FN(nccat) (str_t* str, char_t c, mio_oow_t len)
{
	while (len > 0)
	{
		if (FN(ncat)(str, &c, 1) == (mio_oow_t)-1) return (mio_oow_t)-1;
		len--;
	}
	return str->val.len;
}

mio_oow_t FN(del) (str_t* str, mio_oow_t index, mio_oow_t size)
{
	if (str->val.ptr && index < str->val.len && size > 0)
	{
		mio_oow_t nidx = index + size;
		if (nidx >= str->val.len)
		{
			str->val.ptr[index] = '\0';
			str->val.len = index;
		}
		else
		{
			MIO_MEMMOVE (&str->val.ptr[index], &str->val.ptr[nidx], MIO_SIZEOF(*str->val.ptr) * (str->val.len - nidx + 1));
			str->val.len -= size;
		}
	}

	return str->val.len;
}

mio_oow_t FN(amend) (str_t* str, mio_oow_t pos, mio_oow_t len, const char_t* repl)
{
	mio_oow_t max_len;
	mio_oow_t repl_len = count_chars(repl);

	if (pos >= str->val.len) pos = str->val.len;
	max_len = str->val.len - pos;
	if (len > max_len) len = max_len;

	if (len > repl_len)
	{
		FN(del) (str, pos, len - repl_len);
	}
	else if (len < repl_len)
	{
		mio_oow_t old_ecs_len = str->val.len;
		if (FN(setlen)(str, str->val.len + repl_len - len) == (mio_oow_t)-1) return (mio_oow_t)-1;
		MIO_MEMMOVE (&str->val.ptr[pos + repl_len], &str->val.ptr[pos + len], MIO_SIZEOF(*repl) * (old_ecs_len - (pos + len)));
	}

	if (repl_len > 0) MIO_MEMMOVE (&str->val.ptr[pos], repl, MIO_SIZEOF(*repl) * repl_len); 
	return str->val.len;
}

static int FN(put_bchars) (mio_fmtout_t* fmtout, const mio_bch_t* ptr, mio_oow_t len)
{
#if defined(BUILD_UECS)
	mio_uecs_t* uecs = (mio_uecs_t*)fmtout->ctx;
	if (mio_uecs_ncatbchars(uecs, ptr, len, uecs->mio->_cmgr, 1) == (mio_oow_t)-1) return -1;
#else
	mio_becs_t* becs = (mio_becs_t*)fmtout->ctx;
	if (mio_becs_ncat(becs, ptr, len) == (mio_oow_t)-1) return -1;
#endif
	return 1; /* success. carry on */
}

static int FN(put_uchars) (mio_fmtout_t* fmtout, const mio_uch_t* ptr, mio_oow_t len)
{
#if defined(BUILD_UECS)
	mio_uecs_t* uecs = (mio_uecs_t*)fmtout->ctx;
	if (mio_uecs_ncat(uecs, ptr, len) == (mio_oow_t)-1) return -1;
#else
	mio_becs_t* becs = (mio_becs_t*)fmtout->ctx;
	if (mio_becs_ncatuchars(becs, ptr, len, becs->mio->_cmgr) == (mio_oow_t)-1) return -1;
#endif
	return 1; /* success. carry on */
}

mio_oow_t FN(vfcat) (str_t* str, const char_t* fmt, va_list ap)
{
	mio_fmtout_t fo;

	MIO_MEMSET (&fo, 0, MIO_SIZEOF(fo));
	fo.putbchars = FN(put_bchars);
	fo.putuchars = FN(put_uchars);
	fo.ctx = str;

#if defined(BUILD_UECS)
	if (mio_ufmt_outv(&fo, fmt, ap) <= -1) return -1;
#else
	if (mio_bfmt_outv(&fo, fmt, ap) <= -1) return -1;
#endif
	return str->val.len;
}

mio_oow_t FN(fcat) (str_t* str, const char_t* fmt, ...)
{
	mio_oow_t x;
	va_list ap;

	va_start (ap, fmt);
	x = FN(vfcat)(str, fmt, ap);
	va_end (ap);

	return x;
}

mio_oow_t FN(vfmt) (str_t* str, const char_t* fmt, va_list ap)
{
	mio_fmtout_t fo;

	MIO_MEMSET (&fo, 0, MIO_SIZEOF(fo));
	fo.putbchars = FN(put_bchars);
	fo.putuchars = FN(put_uchars);
	fo.ctx = str;

	FN(clear) (str);

#if defined(BUILD_UECS)
	if (mio_ufmt_outv(&fo, fmt, ap) <= -1) return -1;
#else
	if (mio_bfmt_outv(&fo, fmt, ap) <= -1) return -1;
#endif
	return str->val.len;
}

mio_oow_t FN(fmt) (str_t* str, const char_t* fmt, ...)
{
	mio_oow_t x;
	va_list ap;

	va_start (ap, fmt);
	x = FN(vfmt)(str, fmt, ap);
	va_end (ap);

	return x;
}