/*
  Copyright 2021 Grégory Soutadé

  This file is part of libgourou.

  libgourou is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  libgourou is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with libgourou. If not, see <http://www.gnu.org/licenses/>.
*/
#include <string.h>
#include <stdexcept>

#include <Base64.h>

#include <bytearray.h>

namespace gourou
{
    std::map<unsigned char*, int> ByteArray::refCounter;

    ByteArray::ByteArray(bool useMalloc):_useMalloc(useMalloc), _data(0), _length(0)
    {}

    ByteArray::ByteArray(unsigned int length, bool useMalloc):
        _useMalloc(useMalloc)
    {
        initData(0, length);
    }

    ByteArray::ByteArray(const unsigned char* data, unsigned int length):
        _useMalloc(false)
    {
        initData(data, length);
    }

    ByteArray::ByteArray(const char* data, int length):
        _useMalloc(false)
    {
        if (length == -1)
            length = strlen(data);

        initData((unsigned char*)data, (unsigned int) length);
    }

    ByteArray::ByteArray(const std::string& str):
        _useMalloc(false)
    {
        initData((unsigned char*)str.c_str(), (unsigned int)str.length());
    }

    void ByteArray::initData(const unsigned char* data, unsigned int length)
    {
        if (_useMalloc)
            _data = (unsigned char*)malloc(length);
        else
            _data = new unsigned char[length];

        if (data)
            memcpy((void*)_data, data, length);

        _length = length;

        addRef();
    }

    ByteArray::ByteArray(const ByteArray& other)
    {
        this->_useMalloc = other._useMalloc;
        this->_data = other._data;
        this->_length = other._length;

        addRef();
    }

    ByteArray& ByteArray::operator=(const ByteArray& other)
    {
        delRef();

        this->_useMalloc = other._useMalloc;
        this->_data = other._data;
        this->_length = other._length;

        addRef();

        return *this;
    }

    ByteArray::~ByteArray()
    {
        delRef();
    }

    void ByteArray::addRef()
    {
        if (!_data) return;

        if (refCounter.count(_data) == 0)
            refCounter[_data] = 1;
        else
            refCounter[_data]++;
    }

    void ByteArray::delRef()
    {
        if (!_data) return;

        if (refCounter[_data] == 1)
        {
            if (_useMalloc)
                free(_data);
            else
                delete[] _data;
            refCounter.erase(_data);
        }
        else
            refCounter[_data]--;
    }

    ByteArray ByteArray::fromBase64(const ByteArray& other)
    {
        std::string b64;

        macaron::Base64::Decode(std::string((char*)other._data, other._length), b64);

        return ByteArray(b64);
    }

    ByteArray ByteArray::fromBase64(const char* data, int length)
    {
        std::string b64;

        if (length == -1)
            length = strlen(data);

        macaron::Base64::Decode(std::string(data, length), b64);

        return ByteArray(b64);
    }

    ByteArray ByteArray::fromBase64(const std::string& str)
    {
        return ByteArray::fromBase64(str.c_str(), str.length());
    }

    std::string ByteArray::toBase64()
    {
        return macaron::Base64::Encode(std::string((char*)_data, _length));
    }

    ByteArray ByteArray::fromHex(const std::string& str)
    {
        if (str.size() % 2)
            throw std::invalid_argument("Size of hex string not multiple of 2");

        ByteArray res((unsigned int)(str.size()/2));
        unsigned int i;

        unsigned char* data = res.data();
        unsigned char cur, tmp;

        for (i=0; i<str.size(); i+=2)
        {
            cur = 0;

            tmp = str[i];
            if (tmp >= 'a' && tmp <= 'f')
                cur = (tmp - 'a' + 10) << 4;
            else if (tmp >= 'A' && tmp <= 'F')
                cur = (tmp - 'A' + 10) << 4;
            else if (tmp >= '0' && tmp <= '9')
                cur = (tmp - '0') << 4;
            else
                throw std::invalid_argument("Invalid character in hex string");

            tmp = str[i+1];
            if (tmp >= 'a' && tmp <= 'f')
                cur += tmp - 'a' + 10;
            else if (tmp >= 'A' && tmp <= 'F')
                cur += tmp - 'A' + 10;
            else if (tmp >= '0' && tmp <= '9')
                cur += tmp - '0';
            else
                throw std::invalid_argument("Invalid character in hex string");

            data[i/2] = cur;
        }

        return res;
    }

    std::string ByteArray::toHex()
    {
        char* tmp = new char[_length*2+1];

        for(int i=0; i<(int)_length; i++)
            snprintf(&tmp[i*2], (_length-i)*2+1, "%02x", _data[i]);

        tmp[_length*2] = 0;

        std::string res = tmp;
        delete[] tmp;

        return res;
    }

    void ByteArray::append(const unsigned char* data, unsigned int length)
    {
        if (!length)
            return;

        unsigned int oldLength = _length;

        resize(_length+length, true);

        memcpy(&_data[oldLength], data, length);
    }

    void ByteArray::append(unsigned char c) { append(&c, 1);}
    void ByteArray::append(const char* str) { append((const unsigned char*)str, strlen(str));}
    void ByteArray::append(const std::string& str) { append((const unsigned char*)str.c_str(), str.length()); }

    void ByteArray::resize(unsigned length, bool keepData)
    {
        if (length == _length)
            return;
        else if (length < _length)
            _length = length ; // Don't touch data
        else // New size >
        {
            unsigned char* newData;

            if (_useMalloc)
                newData = (unsigned char*)malloc(_length+length);
            else
                newData = new unsigned char[_length+length];

            if (keepData)
                memcpy(newData, _data, _length);

            delRef();

            _length = length;
            _data = newData;

            addRef();
        }
    }
}
