#pragma once

#include "exception.h"
#include "parser.h"

#include <iostream>
#include <utility>
#include <vector>
#include <map>


namespace usql {

using rowid_t = size_t;   // int is now enough but size_t is correct

static const int k_default_rowids_size = 16;

template<typename K>
class Index {
public:
	Index(std::string index_name, std::string col_name, ColumnType type) :
			m_index_name(std::move(index_name)), m_column_name(std::move(col_name)),
			m_data_type(type), m_uniq(false) {
		if (type != ColumnType::integer_type && type != ColumnType::varchar_type)
			throw Exception("creating index on unsupported type");
	}

	void insert(K key, rowid_t rowid) {
		auto search = m_index.find(key);
		if (search != m_index.end()) {
			if (m_uniq)
				throw Exception("Inserting duplicate value into unique index");

			search->second.push_back(rowid);
		} else {
			std::vector<rowid_t> rowids{rowid};
			if (!m_uniq)
				rowids.reserve(k_default_rowids_size);
			m_index[key] = rowids;
		}
	}

	void remove(K key, rowid_t rowid) {
		auto search = m_index.find(key);
		if (search != m_index.end()) {
			search->second.erase(find(search->second.begin(), search->second.end(), rowid));
			if (search->second.empty())
				m_index.erase(search);
		}
	}

	std::vector<rowid_t> search(K key) {
		auto search = m_index.find(key);
		if (search != m_index.end()) {
			return search->second;
		} else {
			return std::vector<rowid_t>{};
		}
	}

	std::vector<rowid_t> search(ValueNode * key) {
		if (m_data_type == ColumnType::integer_type)
			return search(key->getIntegerValue());
		else if (m_data_type == ColumnType::varchar_type)
			return search(key->getStringValue());
		else
			throw Exception("using index on unsupported type");
	}


	void truncate() {
		m_index.clear();
	}

//	void dump() {
//		std::for_each(m_index.begin(), m_index.end(),
//			      [](std::pair<K, std::vector<rowid_t>> element){
//			K key = element.first;
//			std::vector<rowid_t> rowids = element.second;
//			std::cout << "key: " << key << ",  rowids count:" << rowids.size() << std::endl;
//		});
//	}

	[[nodiscard]] const std::string &get_column_name() const {
		return m_column_name;
	}

	[[nodiscard]] const std::string &get_index_name() const {
		return m_index_name;
	}

	[[nodiscard]] ColumnType get_data_type() const {
		return m_data_type;
	}

private:
	bool			m_uniq;
	std::string		m_index_name;
	std::string		m_column_name;
	ColumnType		m_data_type;

	std::map<K, std::vector<rowid_t> > m_index;
};

}	// namespace