#pragma once

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

#include <vector>

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"); };

    virtual void print() {std::cout << "ColValue:" << std::endl; };
};


struct ColNullValue : ColValue {

    virtual bool isNull() { return true; };

    virtual void print() {std::cout << "ColNullValue:" << std::endl; };
};


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); };

    virtual void print() {std::cout << "ColIntegerValue: " << m_integer <<std::endl; };

    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); };

    virtual void print() {std::cout << "ColFloatValue: " << m_float <<std::endl; };

    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; };

    virtual void print() {std::cout << "ColStringValue: " << m_string <<std::endl; };

    std::string m_string;
};



class Row {

public:
    Row(int cols_count);
    Row(const 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* ithColum(int i) {
        return m_columns[i].get();
    }

    void print();

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