#pragma once

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

#include <vector>

namespace usql {

    class ColumnValue {


    private:
	ColumnType m_type;
	union {
	    int int_value;
	    double float_value;

	};
    };


    struct ColValue {

	virtual bool isNull() { return false; };

	virtual bool isInteger() { return false; };

	virtual bool isFloat() { return false; };

	virtual bool isString() { return false; };

	virtual int integerValue() { throw Exception("Not supported"); };

	virtual double floatValue() { throw Exception("Not supported"); };

	virtual std::string stringValue() { throw Exception("Not supported"); };
    };


    struct ColNullValue : ColValue {

	virtual bool isNull() { return true; };

	virtual std::string stringValue() { return "null"; };
    };


    struct ColIntegerValue : ColValue {

	ColIntegerValue(int value) : m_integer(value) {};

	ColIntegerValue(const ColIntegerValue &other) : m_integer(other.m_integer) {}

	virtual bool isInteger() { return true; };

	virtual int integerValue() { return m_integer; };

	virtual double floatValue() { return (double) m_integer; };

	virtual std::string stringValue() { return std::to_string(m_integer); };

	int m_integer;
    };


    struct ColFloatValue : ColValue {

	ColFloatValue(double value) : m_float(value) {};

	ColFloatValue(const ColFloatValue &other) : m_float(other.m_float) {}

	virtual bool isFloat() { return true; }

	virtual int integerValue() { return (int) m_float; };

	virtual double floatValue() { return m_float; };

	virtual std::string stringValue() { return std::to_string(m_float); };

	double m_float;
    };


    struct ColStringValue : ColValue {

	ColStringValue(const std::string value) : m_string(value) {};

	ColStringValue(const ColStringValue &other) : m_string(other.m_string) {};

	virtual bool isString() { return true; }

	virtual int integerValue() { return std::stoi(m_string); };

	virtual double floatValue() { return std::stod(m_string); };

	virtual std::string stringValue() { return m_string; };

	std::string m_string;
    };


    class Row {

    public:
	Row(int cols_count);

	Row(const Row &other);

	Row &operator=(Row other);

	void setColumnValue(int col_index, int value);

	void setColumnValue(int col_index, double value);

	void setColumnValue(int col_index, std::string value);

	ColValue &operator[](int i) {
		return *m_columns[i];
	}

	ColValue *ithColumn(int i) {
		return m_columns[i].get();
	}

	void print();

    private:
	std::vector<std::unique_ptr<ColValue>> m_columns;
    };

}