#include "lxz_config.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "lxz_types.h"
#include "os_port.h"
#include "lxz_runlog.h"
#include "lxz_debug.h"
#include "lxz_dstring.h"
#include "lxz_dbg_vmem.h"

#define LXZ_MIN_FREE_SIZE 1

/******************************************************************************/
// DESCRIPTION:
//         new a buffer.
// PARAM: i_size_free, free size of space
// RETURN: p_new_buffer, NULL, fail; NON-NULL, success.
/******************************************************************************/
lxz_dstring_t* lxz_dstring_new(sint32 i_len_tryget)
{
    lxz_dstring_t * p_new_dstring = NULL;
    sint32 i_free_size = LXZ_MIN_FREE_SIZE;

    p_new_dstring = (lxz_dstring_t *)malloc(sizeof(lxz_dstring_t));
    if (NULL == p_new_dstring)
    {
        return p_new_dstring;
    }

    memset(p_new_dstring, 0, sizeof(lxz_dstring_t));
    p_new_dstring->pt_string = (uint08 *)malloc(i_len_tryget + i_free_size);
    if (NULL == p_new_dstring->pt_string)
    {
        free(p_new_dstring);
        p_new_dstring = NULL;
        return p_new_dstring;
    }

    memset(p_new_dstring->pt_string, 0, i_len_tryget + i_free_size);
    p_new_dstring->it_length = 0;
    p_new_dstring->it_size = i_len_tryget + i_free_size;

    return p_new_dstring;
}

/******************************************************************************/
//  DESCRIPTION:
//           Append and save data into the specified buffer.
//  Param: p_lsbuf, specified buffer
//  Param: p_data_buf, a data buffer
//  Param: i_str_len, the number of bytes data stored in the buffer
//  Return: i_op_status, 0, fail; 1, success.
//  History:
/******************************************************************************/
sint32 lxz_dstring_append(lxz_dstring_t* p_a_dstring, uint08* p_data_buf, sint32 i_str_len)
{
    sint32 i_op_status = 0;

    sint32 i_free_size = LXZ_MIN_FREE_SIZE;

    if (NULL == p_a_dstring)
    {
        return i_op_status;
    }

    if (NULL == p_a_dstring->pt_string)
    {
        p_a_dstring->pt_string = (uint08 *)malloc(i_str_len + i_free_size);
        if (NULL == p_a_dstring->pt_string)
        {
            return i_op_status;
        }

        i_op_status = 1;
        p_a_dstring->it_size = i_str_len + i_free_size;
        p_a_dstring->it_length = i_str_len;
        memset(p_a_dstring->pt_string, 0, i_str_len + i_free_size);
        memcpy(p_a_dstring->pt_string, p_data_buf, i_str_len);
    }
    else
    {
        if ((i_str_len + p_a_dstring->it_length)> (p_a_dstring->it_size - i_free_size))
        {
            sint32 u_total_len = 0;
            uint08 * p_tmp_ptr = NULL;

            u_total_len = i_str_len + p_a_dstring->it_length;
            p_tmp_ptr = (uint08 *)malloc(u_total_len + i_free_size);
            if (NULL == p_tmp_ptr)
            {
                return i_op_status;
            }

            i_op_status = 1;
            memset(p_tmp_ptr, 0, u_total_len + i_free_size);
            memcpy(p_tmp_ptr, p_a_dstring->pt_string, p_a_dstring->it_length);
            memcpy(&(p_tmp_ptr[p_a_dstring->it_length]), p_data_buf, i_str_len);

            free(p_a_dstring->pt_string);
            p_a_dstring->pt_string = p_tmp_ptr;
            p_a_dstring->it_length += i_str_len;
            p_a_dstring->it_size = u_total_len + i_free_size;
        }
        else
        {
            i_op_status = 1;
            memcpy(&(p_a_dstring->pt_string[p_a_dstring->it_length]), p_data_buf, i_str_len);
            p_a_dstring->it_length += i_str_len;
        }
    }

    return i_op_status;
}

/******************************************************************************/
//  DESCRIPTION:
//           Append and save data into the specified buffer.
//  Param: p_lsbuf, specified buffer
//  Param: p_data_buf, a data buffer
//  Param: i_str_len, the number of bytes data stored in the buffer
//  Return: i_op_status, 0, fail; 1, success.
//  History:
/******************************************************************************/
sint32 lxz_dstring_merge(lxz_dstring_t* p_dst_dstring, lxz_dstring_t* p_src_dstring)
{
    sint32 i_op_status = 0;

    sint32 i_free_size = LXZ_MIN_FREE_SIZE;

    if ((NULL == p_dst_dstring) || (NULL == p_src_dstring))
    {
        return i_op_status;
    }

    if ((NULL == p_src_dstring->pt_string) || (0 == p_src_dstring->it_size))
    {
        i_op_status = 1;
        return i_op_status;
    }

    if (NULL == p_dst_dstring->pt_string)
    {
        p_dst_dstring->pt_string = (uint08 *)malloc(p_src_dstring->it_size + i_free_size);
        if (NULL == p_dst_dstring->pt_string)
        {
            return i_op_status;
        }

        i_op_status = 1;
        p_dst_dstring->it_size = p_src_dstring->it_size + i_free_size;
        p_dst_dstring->it_size = p_src_dstring->it_size;
        memset(p_dst_dstring->pt_string, 0, p_dst_dstring->it_size);
        memcpy(p_dst_dstring->pt_string, p_src_dstring->pt_string, p_src_dstring->it_size);
    }
    else
    {
        if ((p_src_dstring->it_size + p_dst_dstring->it_size) > (p_dst_dstring->it_size - i_free_size))
        {
            sint32 u_total_len = 0;
            uint08 * p_tmp_ptr = NULL;

            u_total_len = p_src_dstring->it_size + p_dst_dstring->it_size;
            p_tmp_ptr = (uint08 *)malloc(u_total_len + i_free_size);
            if (NULL == p_tmp_ptr)
            {
                return i_op_status;
            }

            i_op_status = 1;
            memset(p_tmp_ptr, 0, u_total_len + i_free_size);
            memcpy(p_tmp_ptr, p_dst_dstring->pt_string, p_dst_dstring->it_size);
            memcpy(&(p_tmp_ptr[p_dst_dstring->it_size]), p_src_dstring->pt_string, p_src_dstring->it_size);

            free(p_dst_dstring->pt_string);
            p_dst_dstring->pt_string = p_tmp_ptr;
            p_dst_dstring->it_size = u_total_len + i_free_size;
            p_dst_dstring->it_size = u_total_len;
        }
        else
        {
            i_op_status = 1;
            memcpy(&(p_dst_dstring->pt_string[p_dst_dstring->it_size]), p_src_dstring->pt_string, p_src_dstring->it_size);
            p_dst_dstring->it_size += p_src_dstring->it_size;
        }
    }

    return i_op_status;
}

/******************************************************************************/
//  DESCRIPTION:
//           Get string from a dstring object.
//  Param: [i]p_a_dstringing, a dstring object
//  Param: [io]p_buf_data, string buffer
//  Param: [i]i_buf_size, the size of the string buffer;
//  Return: i_len_string, the length of the string.
//  History:
/******************************************************************************/
sint32 lxz_dstring_get(lxz_dstring_t* p_a_dstringing, uint08* p_buf_data, sint32 i_buf_size)
{
    sint32 i_len_string = 0;

    if ((NULL == p_a_dstringing) || (NULL == p_a_dstringing->pt_string))
    {
        return i_len_string;
    }

    if (i_buf_size < p_a_dstringing->it_length)
    {
        return i_len_string;
    }

    memset(p_buf_data, 0, i_buf_size);
    memcpy(p_buf_data, p_a_dstringing->pt_string, p_a_dstringing->it_length);
    i_len_string = p_a_dstringing->it_length;

    return i_len_string;
}

/******************************************************************************/
//  DESCRIPTION:
//           copy content of a dstring to another.
//  Param: [io]p_dst_dstring, 
//  Param: [i]p_src_dstring, 
//  Return: i_op_status, 0, fail; 1, success.
//  History:
/******************************************************************************/
sint32 lxz_dstring_copy(lxz_dstring_t* p_dst_dstring, lxz_dstring_t* p_src_dstring)
{
    sint32 i_op_status = 0;

    sint32 i_it_size = 0;

    if (NULL == p_dst_dstring)
    {
        return i_op_status;
    }

    if ((NULL == p_src_dstring) || (NULL == p_src_dstring->pt_string))
    {
        return i_op_status;
    }

    i_it_size = p_src_dstring->it_size;
    if (NULL == p_dst_dstring->pt_string)
    {
        p_dst_dstring->pt_string = (uint08 *)malloc(i_it_size);
        if (NULL == p_dst_dstring->pt_string)
        {
            return i_op_status;
        }

        p_dst_dstring->it_size = i_it_size;
    }
    else
    {
        if (i_it_size > (p_dst_dstring->it_size))
        {
            free(p_dst_dstring->pt_string);
            p_dst_dstring->pt_string = (uint08 *)malloc(i_it_size);
            if (NULL == p_dst_dstring->pt_string)
            {
                return i_op_status;
            }

            p_dst_dstring->it_size = i_it_size;
        }
    }

    i_op_status = 1;
    memset(p_dst_dstring->pt_string, 0, i_it_size);
    memcpy(p_dst_dstring->pt_string, p_src_dstring->pt_string, i_it_size);
    p_dst_dstring->it_length = p_src_dstring->it_length;

    return i_op_status;
}

/******************************************************************************/
//  DESCRIPTION:
//           clear the content of a dstring and release related resources.
//  Param: [i]p_lsbuf, 
//  Return: i_op_status, 0, fail; 1, success.
//  History:
/******************************************************************************/
sint32 lxz_dstring_clear(lxz_dstring_t* p_a_dstring)
{
    sint32 i_op_status = 1;

    if (NULL == p_a_dstring)
    {
        return i_op_status;
    }

    p_a_dstring->it_size = 0;
    p_a_dstring->it_size = 0;
    if (NULL != p_a_dstring->pt_string)
    {
        free(p_a_dstring->pt_string);
        p_a_dstring->pt_string = NULL;
    }

    return i_op_status;
}

/******************************************************************************/
//  DESCRIPTION:
//           compare the content of two buffers, 
//  Param: p_dst_dstringfer, specified buffer
//  Param: p_src_dstringfer, specified buffer
//  Return: i_is_equal, 0, equal; 1, not equal.
//  History:
/******************************************************************************/
sint32 lxz_dstring_compare(lxz_dstring_t* p_dst_dstring, lxz_dstring_t* p_src_dstring)
{
    sint32 i_is_equal = 1;

    if ((NULL == p_dst_dstring) || (NULL == p_src_dstring))
    {
        return i_is_equal;
    }

    if ((NULL == p_dst_dstring->pt_string) || (NULL == p_src_dstring->pt_string))
    {
        return i_is_equal;
    }

    if (p_dst_dstring->it_size != p_src_dstring->it_size)
    {
        return i_is_equal;
    }

    if (0 == memcmp(p_dst_dstring->pt_string, p_src_dstring->pt_string, p_dst_dstring->it_size))
    {
        i_is_equal = 0;
    }

    return i_is_equal;
}

/******************************************************************************/
//  DESCRIPTION:
//           delete the specified buffer
//  Param: p_dst_dstringfer, specified buffer
//  Return: i_op_status, 0, fail; 1, success.
//  History:
/******************************************************************************/
sint32 lxz_dstring_delete(lxz_dstring_t* p_a_dstring)
{
    sint32 i_op_status = 1;

    if (NULL == p_a_dstring)
    {
        return i_op_status;
    }

    if (NULL != p_a_dstring->pt_string)
    {
        free(p_a_dstring->pt_string);
        p_a_dstring->pt_string = NULL;
    }

    free(p_a_dstring);

    return i_op_status;
}

/******************************************************************************/
//  DESCRIPTION:
//           delete the specified buffer
//  Param: p_dst_dstringfer, specified buffer
//  Return: i_op_status, 0, fail; 1, success.
//  History:
/******************************************************************************/
sint32 lxz_dstring_upcase(lxz_dstring_t* p_a_dstring)
{
    sint32 i_op_status = 1;

    sint32 i = 0;
    
    if (NULL == p_a_dstring)
    {
        return i_op_status;
    }
    
    if (NULL != p_a_dstring->pt_string)
    {
        while (i < p_a_dstring->it_length)
        {
            if ((p_a_dstring->pt_string[i] >= 'a') && (p_a_dstring->pt_string[i] <= 'z'))
            {
                p_a_dstring->pt_string[i] = p_a_dstring->pt_string[i] - 'a' + 'A';
            }
            
            i++;
        }
        p_a_dstring->pt_string = NULL;
    }
    
    return i_op_status;
}

/******************************************************************************/
//  DESCRIPTION:
//           compare the content of two buffers, 
//  Param: p_dst_dstringfer, specified buffer
//  Param: p_src_dstringfer, specified buffer
//  Return: i_is_equal, 0, equal; 1, not equal.
//  History:
/******************************************************************************/
sint32 lxz_dstring_strncmp(lxz_dstring_t* p_dst_dstring, uint08* p_ascii_str, sint32 i_str_len)
{
    sint32 i_is_equal = 1;
    
    if (NULL == p_dst_dstring)
    {
        return i_is_equal;
    }
    
    if ((NULL == p_dst_dstring->pt_string) || (NULL == p_ascii_str))
    {
        return i_is_equal;
    }
    
    if (0 == memcmp(p_dst_dstring->pt_string, p_ascii_str, i_str_len))
    {
        i_is_equal = 0;
    }
    
    return i_is_equal;
}


sint32 lxz_dstring_deltail(lxz_dstring_t* p_dst_dstring, uint08 c)
{
    sint32 i = 0;
    
    if ((NULL == p_dst_dstring) || (NULL == p_dst_dstring->pt_string))
    {
        return 0;
    }

    i = p_dst_dstring->it_length - 1;
    while (i > 0)
    {
        if (p_dst_dstring->pt_string[i] != c)
        {
            break;
        }

        i--;
    }

    p_dst_dstring->it_length = i + 1;
    p_dst_dstring->pt_string[p_dst_dstring->it_length] = '\0';
    
    return 1;
}

sint32 lxz_dstring_getlength(lxz_dstring_t* p_a_dstringing)
{
    sint32 i_len_dstr = 0;
    
    if ((NULL == p_a_dstringing) || (NULL == p_a_dstringing->pt_string))
    {
        return 0;
    }

    if (p_a_dstringing->it_length < p_a_dstringing->it_size)
    {
        i_len_dstr = p_a_dstringing->it_length;
    }

    return i_len_dstr;
}

sint32 lxz_dstring_framelength(lxz_dstring_t* p_dst_dstring, uint08 u_cur_endchar)
{
    sint32 i = 0;
    sint32 i_len_frame = 0;
    sint32 i_posi_framehead = 0;
    sint32 i_find_framehead = 0;
    sint32 i_posi_frametail = 0;
    sint32 i_find_frametail = 0;

    if ((NULL == p_dst_dstring) || (NULL == p_dst_dstring->pt_string))
    {
        return 0;
    }

    /* 当没有数据或者只有一个字符时，没有意义 */
    if (p_dst_dstring->it_length <= 1)
    {
        return 0;
    }

    i = 1;
    while (i < p_dst_dstring->it_length)
    {
        if ((p_dst_dstring->pt_string[i - 1] == u_cur_endchar)
            && (p_dst_dstring->pt_string[i] != u_cur_endchar))
        {
            i_posi_framehead = i - 1;
            i_find_framehead = 1;
            break;
        }
        i++;
    }

    if (i_find_framehead != 1)
    {
        p_dst_dstring->it_length = 0;
        return 0;
    }

    if (i_posi_framehead != 0)
    {
        i = i_posi_framehead;
        memmove(&(p_dst_dstring->pt_string[0]), &(p_dst_dstring->pt_string[i]), p_dst_dstring->it_length - i);
        p_dst_dstring->it_length = p_dst_dstring->it_length - i;
    }

    i = 1;
    while (i < p_dst_dstring->it_length)
    {
        if ((p_dst_dstring->pt_string[i - 1] != u_cur_endchar)
            && (p_dst_dstring->pt_string[i] == u_cur_endchar))
        {
            i_posi_frametail = i;
            i_find_frametail = 1;
            i_len_frame = i + 1;
            break;
        }
        i++;
    }
    
    return i_len_frame;
}

sint32 lxz_dstring_read(lxz_dstring_t* p_cur_dstring, uint08* p_buf_tryread, sint32 i_nb_tryread)
{
    sint32 i_ret_len = 0;
    
    sint32 i_str_len = 0;
    sint32 i_free_size = LXZ_MIN_FREE_SIZE;
    
    if ((NULL == p_cur_dstring) || (NULL == p_cur_dstring->pt_string))
    {
        return i_ret_len;
    }
    
    if (i_nb_tryread < p_cur_dstring->it_length)
    {
        memset(p_buf_tryread, 0, i_nb_tryread);
        memcpy(p_buf_tryread, p_cur_dstring->pt_string, i_nb_tryread);
        i_ret_len = i_nb_tryread;
        
        memmove(&(p_cur_dstring->pt_string[0]), &(p_cur_dstring->pt_string[i_nb_tryread]), p_cur_dstring->it_length - i_nb_tryread);
        p_cur_dstring->it_length = p_cur_dstring->it_length - i_nb_tryread;
    }
    
    return i_ret_len;
}

/******************************************************************************/
//  DESCRIPTION:
//           digital string or not.
//  Param: [i]p_dst_dstring, 
//  Return: i_op_status, 0, no; 1, yes.
//  History:
/******************************************************************************/
sint32 lxz_dstring_digital_isdigital(lxz_dstring_t* p_a_dstring)
{
    sint32 i_is_digital = 0;
    sint32 i_is_negative = 0;
    sint08 i_1st_char = 0;

    sint32 i = 0;
    sint32 i_len_string = 0;
    sint32 i_nb_dots = 0;

    if ((NULL == p_a_dstring) || (NULL == p_a_dstring->pt_string))
    {
        return i_is_digital;
    }

    i_len_string = p_a_dstring->it_length;
    if (i_len_string <= 0)
    {
        return i_is_digital;
    }

    i_1st_char = p_a_dstring->pt_string[0];
    if (i_len_string == 1)
    {
        if ((i_1st_char < '0') || (i_1st_char > '9'))
        {
            return i_is_digital;
        }
        else
        {
            i_is_digital = 1;
            return i_is_digital;
        }
    }

    if ('.' == i_1st_char)
    {
        return i_is_digital;
    }

    i = 0;
    if ('-' == i_1st_char)
    {
        i = 1;
        i_is_negative = 1;
    }

    i_is_digital = 1;
    while (i < i_len_string)
    {
        if ((p_a_dstring->pt_string[i] < '0') || (p_a_dstring->pt_string[i] > '9'))
        {
            if ('.' != p_a_dstring->pt_string[i])
            {
                i_is_digital = 0;
                break;
            }

            i_nb_dots = i_nb_dots + 1;
            if (i_nb_dots > 1)
            {
                i_is_digital = 0;
                break;
            }
        }

        i = i + 1;
    }

    if ((i_is_digital == 1) && (i_is_negative == 1))
    {
        i_is_digital = -1;
    }

    return i_is_digital;
}

/******************************************************************************/
//  DESCRIPTION:
//           copy content of a dstring to another.
//  Param: [io]p_dst_dstring, 
//  Param: [i]p_src_dstring, 
//  Return: i_op_status, 0, fail; 1, success.
//  History:
/******************************************************************************/
sint32 lxz_dstring_add(lxz_dstring_t* p_dst_dstring, lxz_dstring_t* p_src_dstring)
{
    sint32 i_op_status = 0;

    sint32 i_dst_isdigital = 0;
    sint32 i_src_isdigital = 0;

    sint32 i_len_dst_integer = 0;
    sint32 i_len_dst_decimal = 0;
    sint32 i_len_src_integer = 0;
    sint32 i_len_src_decimal = 0;

    if ((NULL == p_dst_dstring) || (NULL == p_dst_dstring->pt_string))
    {
        return i_op_status;
    }

    if ((NULL == p_src_dstring) || (NULL == p_src_dstring->pt_string))
    {
        return i_op_status;
    }

    i_dst_isdigital = lxz_dstring_digital_isdigital(p_dst_dstring);
    if (i_dst_isdigital == 0)
    {
        return i_op_status;
    }

    i_src_isdigital = lxz_dstring_digital_isdigital(p_src_dstring);
    if (i_src_isdigital == 0)
    {
        return i_op_status;
    }

    if (i_dst_isdigital == i_src_isdigital)
    {
        if (i_dst_isdigital == 1)
        {
        }
        else
        {
        }
    }
    else
    {
        if (i_dst_isdigital == 1)
        {
        }
        else
        {
        }
    }

    return i_op_status;
}