#ifndef CSTRING_VECTOR_H
#define CSTRING_VECTOR_H

#include <cassert>
#define _CRT_SECURE_NO_WARNINGS
#include <vector>
#include <iostream>
#include <cstring>
#include <string>

#include "cstring_utils.h"

//#define _SCL_SECURE_NO_WARNINGS



char const * DELIM { ", " };

/* динамический массив С-строк */
class cstring_vector {

    /* массив С-строк */
    char ** data; 
    /* логический размер (заполненность) */
    size_t  size;
    /* физический размер (ёмкость) */
	size_t  capacity;
    
public:
    
	cstring_vector()
	{
		data = new char*[MIN_CAPACITY];
		size = 0;
		capacity = MIN_CAPACITY;
	}
    
    
	cstring_vector(char ** cstr_array, size_t size)
	{
		init_from_cstr_array(cstr_array, size);
	}
    
	cstring_vector(char const ** cstr_array, size_t size)
	{
		init_from_cstr_array(const_cast<char**>(cstr_array), size);
	}

    cstring_vector(std::vector<std::string>cpp_strs)
	{
		this->size = cpp_strs.size();
		this->capacity = size*CAPACITY_FACTOR;
		data = new char*[capacity];
		for (auto const & s : cpp_strs)
			
		for (auto i = 0; i<cpp_strs.size(); i++)
		{
			data[i] = new char[cpp_strs[i].size()+1];
			strcpy(data[i],cpp_strs[i].c_str());
		}
	}
	cstring_vector(const cstring_vector & v1): size(v1.size), capacity(v1.capacity)
	{
		std::cout << "cstring_vector copy constr invoked"<< std::endl;
		init_from_cstr_array(v1.data, size);
	}
	cstring_vector(cstring_vector && v1)
	{
		std::cout << "cstring_vector move constr invoked"<< std::endl;
		swap(v1);
	}
	~cstring_vector()
	{
		if (data)
		{
			for (auto i = 0; i < size; i++)
				delete[] data[i];
			delete[] data;
		}
	}
	cstring_vector& operator=(const cstring_vector& other)
	{
		std::cout << "cstring_vector operator= invoked"<< std::endl;
		if (&other != this)
		{
			cstring_vector tmp{ other };
			swap(tmp);
		}
		return *this;
	}
	cstring_vector& operator=(cstring_vector&& other)
	{
		std::cout << "cstring_vector move operator= invoked"<< std::endl;
		swap(other);
		return *this;
	}
	char * operator [](int i)				//Можно менять всё: адреса строк, их длину, отдельные символы
	{
		if (i < 0 || i >= size)
			throw std::out_of_range("idx is out of range");
		return data[i];
	}

	const char * operator [](int i) const	//Менять можно только адреса и длину строк. Сами строки менять нельзя.
	{
		if (i < 0 || i >= size)
			throw std::out_of_range("idx is out of range");
		const char * tmp = data[i];

		return tmp;
	}
    
    /* размер массива */
	size_t sz()
	{
		return size;
	}
    
    /* печать содержимого массива */
    void print() const
    {
        assert(data);
        //assert(size <= capacity);
        std::cout << "{";
		if (size)
		{
			for (size_t i = 0; i < size - 1; ++i)
			{
				print_cstring(data[i]);
				std::cout << DELIM;
			}        
            print_cstring(data[size - 1]);
		}
        std::cout << "}";
    }
    
    /* печать содержимого массива */
    void println() const
    {
        print();
        std::cout << std::endl;
    }

	void push_back(char * str)
	{
		if (size == capacity)
			reallocate();
		data[size] = new char[strlen(str) + 1];
		strcpy(data[size++], str);
	}
	//Добавляет копию С-строки в вектор
	/*void push_back(char * str)
	{
		if (size = capacity)
			reallocate();
		data[size] = new char[strlen(str) + 1];
		strcpy_s(data[size], strlen(str) + 1,str);
		++size;
	}*/
	operator std::vector<std::string> ()
	{
		std::vector<std::string> t;
		for (auto i=0; i<size;i++)
			t.emplace_back(std::string(data[i]));
		return t;
	}

private:

	int MIN_CAPACITY = 5;
	int CAPACITY_FACTOR = 2;

    /* инициализация текущего массива
       копией массива строк cstr_array из size элементов */
	void init_from_cstr_array(char ** cstr_array, size_t size)
	{
		this->size = size;
		this->capacity = size*CAPACITY_FACTOR;
		data = new char* [capacity];
		for (auto i = 0; i<size; i++)
		{
			data[i] = new char[strlen(cstr_array[i]) + 1];
			strcpy(data[i], cstr_array[i]);
		}
			
	}
	void swap(cstring_vector other)
	{
		std::swap(size, other.size);
		std::swap(capacity, other.capacity);
		std::swap(data, other.data);
	}
	void reallocate()
	{
		auto  new_data = new char * [size * CAPACITY_FACTOR];
		std::copy(data, data + size, new_data);
		/*for (int i = 0; i < size; ++i)
		{
			new_data[i] = new char[strlen(data[i]) + 1];
			strcpy(new_data[i], data[i]);
		}*/
		delete[] data;
		data = new_data;
		capacity = size * CAPACITY_FACTOR;
	}
  
};


/* CSTRING_VECTOR_H */
#endif