//
//  TypeConv.h
//  GoldRich
//
//  Created by WindShan on 2017/3/8.
//  Copyright © 2017年 WindShan. All rights reserved.
//

#ifndef TypeConv_h
#define TypeConv_h

#include <sys/socket.h>
#include <fcntl.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>

class TypeConv
{
public:
    TypeConv(int mod = 0):write_pos(0),read_pos(0),cur_size(0),data_len(0),p_buffer(nullptr)// 0 -> host ,1 -> net
    {
        use_mod = mod;
    }
    
    TypeConv::~TypeConv(void)
    {
        if (p_buffer != nullptr)
        {
            delete[] p_buffer;
            p_buffer = nullptr;
        }
    }
public:
    unsigned int toBinary(const void* data,unsigned int size)
    {
        if (size > 0)
        {
            //超过当前缓冲大小则重新分配内存
            if (write_pos + size > cur_size)
            {
                unsigned int nPageNum = (write_pos + size)/1024;
                unsigned int nbyte = (write_pos + size)%1024;
                
                if (nbyte > 0)
                {
                    nPageNum += 1;
                }
                
                cur_size = nPageNum*1024;
                unsigned char *p_new_buffer = new unsigned char[cur_size];
                memset(p_new_buffer,0,cur_size);
                
                if (write_pos > 0)
                {
                    //将原来的内存拷贝到新分配的内存
                    memcpy(p_new_buffer,p_buffer,write_pos);
                }
                if (p_buffer != nullptr)
                {
                    delete[] p_buffer;
                }
                p_buffer = p_new_buffer;
            }
            
            //将要写入到缓冲的数据写入缓冲
            memcpy(p_buffer + write_pos,data,size);
            write_pos += size;
            data_len = write_pos;
            
            return size;
        }
        return 0;
    }
    
    unsigned int toType(void* data,unsigned int size)
    {
        {
            if ( (p_buffer != nullptr) && (data_len >= read_pos + size))
            {
                memcpy(data,p_buffer + read_pos,size);
                read_pos += size;
                
                return size;
            }
            return 0;
        }
    }
    unsigned int strToBinary(const string& str)
    {
        unsigned int ret = 0;
        unsigned int str_size = str.length();
        unsigned int re_str_size = str_size;
        if(use_mod == 1){ str_size = htonl(str_size);}//convert net bit
        ret += toBinary(&str_size,sizeof(str_size));
        ret += toBinary(str.data(),re_str_size);
        
        return ret;
    }
    unsigned int toString(string& str)
    {
        unsigned int ret = 0;
        unsigned int str_len = 0;
        ret += toType(&str_len,sizeof(str_len));
        
        if(use_mod == 1){ str_len = ntohl(str_len);} //convert host bit
        
        if (str_len == 0)
        {
            str = "";
            return ret;
        }
        
        unsigned char *str_data = new unsigned char[str_len + 1];
        
        memset(str_data,0,str_len + 1);
        ret += toType(str_data,str_len);
        
        str.assign((char*)str_data);
        
        delete[] str_data;
        str_data = nullptr;
        
        return ret;
    }
    unsigned int resetData(unsigned int reLen)
    {
        if (reLen > cur_size)
        {
            unsigned char *p_new_buffer = new unsigned char[reLen];
            memset(p_new_buffer,0,reLen);
            if (p_buffer != nullptr)
            {
                delete[] p_buffer;
                p_buffer = nullptr;
            }
            p_buffer = p_new_buffer;
            
            cur_size = reLen;
            data_len = 0;
            write_pos = 0;
            read_pos = 0;
            
            return reLen;
        }
        else
        {
            memset(p_buffer,0,cur_size);
            data_len = 0;
            write_pos = 0;
            read_pos = 0;
            
            return cur_size;
        }
        return 0;
    }
    
    void attach(void* data,int size,int data_size = 0) //call this function will reset all data
    {
        clear();
        p_buffer = (unsigned char *)data;
        cur_size = size;
        data_len = data_size;
    }
    unsigned char* detach()//detach inner buffer,
    {
        write_pos = 0;
        read_pos = 0;
        cur_size = 0;
        data_len = 0;
        
        unsigned char* buf = p_buffer;
        p_buffer = nullptr;
        
        return buf;
    }
    
    void clear()
    {
        write_pos = 0;
        read_pos = 0;
        cur_size = 0;
        data_len = 0;
        if (p_buffer != nullptr)
        {
            delete[] p_buffer;
            p_buffer = nullptr;
        }
    }
    
    unsigned int getDataSize() const
    {
        return data_len;
    }
    unsigned char* getBuffer() const
    {
        return p_buffer;
    }
    unsigned int getWritePos() const
    {
        return write_pos;
    }
    unsigned int getReadPos() const
    {
        return read_pos;
    }
    unsigned int getBufferSize() const
    {
        return cur_size;
    }
    
private:
    unsigned char *p_buffer;	//cash pointer
    unsigned int cur_size;		//curent buffer size
    unsigned int write_pos;		//write position
    unsigned int read_pos;		//read position
    unsigned int data_len;      //data length
    
    
    int use_mod;
};

#endif /* TypeConv_h */