#include <iostream>

class Matrix
{
    protected:
        int** matrix = nullptr; int rows = 0x0, columns = 0x0;

    public:
        Matrix(const int _row_size, const int _column_size) : rows(_row_size), columns(_column_size) { Matrix::resize(_row_size, _column_size); }

        virtual void set_value(int _row, int _column, int _value) = 0;
        virtual int get_value(int _row, int _column) = 0;

        auto resize(const int row, const int column) -> void
        {
            matrix = new int*[row];
            for(int i(0x0); i != row; ++i)
                matrix[i] = new int[column];

            Matrix::reset();
        }

        auto reset() -> void
        {
            for (int i(0x0); i != rows; ++i)
                for (int j(0x0); j != columns; ++j)
                    matrix[i][j] = 0x0;
        }

        auto print() const -> void
        {
            for (int i(0x0); i != rows; ++i)
            {
                std::cout << "Row: " << i << ": ";

                for (int j(0x0); j != columns; ++j)
                    std::cout << matrix[i][j] << " ";
                std::cout << std::endl;
            }
            std::cout << std::endl;
        }
};

class Sparse : public Matrix
{
    public:
        Sparse(const int _row_size, const int _column_size) : Matrix(_row_size, _column_size) {}

        auto set_value(int _row, int _column, int _value) -> void override
        {
            matrix[_row][_column] = _value;
        }

        auto get_value(int _row, int _column) -> int override
        {
            /* Find how many elements are not zero. */
            uint16_t counter = 0x0;
            for (int i(0x0); i != rows; ++i)
                for (int j(0x0); j != columns; ++j)
                    if (matrix[i][j] != 0x0)
                        ++counter;

            /* Create new matrix on heap. */
            int** data = new int*[0x3];
            for(int i(0x0); i != 0x3; ++i)
                data[i] = new int[counter];

            /* Copy values from base class matrix to data matrix. */
            int row_insert = 0x0;
            for (int i(0x0); i != rows; ++i)
            {
                for (int j(0x0); j != columns; ++j)
                {
                    if (matrix[i][j] != 0x0)
                    {
                        data[row_insert][0x0] = i;
                        data[row_insert][0x1] = j;
                        data[row_insert][0x2] = matrix[i][j];
                        row_insert++;
                    }
                }
            }

            /* Now update base class members. */
            matrix = data;
            rows = counter;
            columns = 3;

            return 0; //logic here...
        }
};

class Dense : public Matrix
{
    public:
        Dense(const int _row_size, const int _column_size) : Matrix(_row_size, _column_size) {}

        auto set_value(int _row, int _column, int _value) -> void override
        {
            matrix[_row][_column] = _value + 1;
        }

        auto get_value(int _row, int _column) -> int override
        {
            return matrix[_row][_column];
        }
};



int main()
{
    Sparse s1(3, 5);
    s1.set_value(0, 0, 1337);
    s1.set_value(0, 1, 225);
    s1.get_value(0,0);
    s1.print();

    Dense d1(2,2);
    d1.set_value(0, 0, 1337);
    d1.print();

    return 0;
}