#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <type_traits>
#include <suitesparse/umfpack.h>

class Sparse
{
private:
    std::vector<double> Ax;
    std::vector<int> Ai, Ap;
    int size;

    template<typename T>
    void parse(std::ifstream & file, std::vector<T> &vec);
public:
    Sparse(std::string filename);
    std::vector<double> solve(std::vector<double> & right, int sys);
    int get_size() const;
};



int main()
{
    Sparse lel("kek");
    std::vector<double> b = {8, 45, -3, 3, 19};
    auto res = lel.solve(b, UMFPACK_A);
    for(auto i: res)
        std::cout << i << std::endl;
    return 0;
}

template<typename T>
void Sparse::parse(std::ifstream & file, std::vector<T> &vec)
{
    std::string line;
    size_t elem_num;

    if (std::is_same<T, double>::value)
        elem_num = 3;
    else
        elem_num = 7;

    T tmp;
    size_t readed = 0;

    while(1)
    {
        getline(file, line);
        std::istringstream iss(line);

        while((iss >> tmp))
        {
            vec.push_back(tmp);
            readed++;
        }

        if (readed != elem_num)
            break;
        else
            readed = 0;
    }
}

Sparse::Sparse(std::string filename)
{
    std::ifstream file(filename);

    std::string line;
    getline(file, line);
    std::istringstream iss(line);
    iss >> size;

    parse(file, Ap);
    parse(file, Ai);
    parse(file, Ax);

    std::cout << "Sparse matrix created!" << std::endl;
}
std::vector<double> Sparse::solve(std::vector<double> & right, int sys)
{
    void *Symbolic, *Numeric;
    int *Ap = &(this->Ap)[0];
    int *Ai = &(this->Ai)[0];
    double *Ax = &(this->Ax)[0];


    umfpack_di_symbolic(size, size, Ap, Ai, Ax, &Symbolic, NULL, NULL);
    std::cout << "Symbolic done!" << std::endl;


    umfpack_di_numeric(Ap, Ai, Ax, Symbolic, &Numeric, NULL, NULL);
    std::cout << "Numeric done!" << std::endl;
    umfpack_di_free_symbolic(&Symbolic);


    std::vector<double> result(size);
    double *x = &result[0];
    double *b = &right[0];


    umfpack_di_solve(sys, Ap, Ai, Ax, x, b, Numeric, NULL, NULL);
    std::cout << "Solve done!" << std::endl;
    umfpack_di_free_numeric(&Numeric);

    return result;
}

int Sparse::get_size() const
{
    return size;
}