#define EXPORT

#include "Student.hpp"


Student::Student() : rollNumber(0) {}

Student::Student(int rollNo) : rollNumber(rollNo) {}

int Student::getRollNumber() {
    return rollNumber;
}

DLL_EXPORT void readStudents(const std::stack<Student>& students) {
}

DLL_EXPORT std::stack<Student> getStudents(int size) {
    std::stack<Student> students;
    for (int i = 0; i < size; i++) {
        students.push(Student(i+1));
    }
    return students;
}

//Wrapper header to access/pass std::stack objects from MATLAB
#ifndef stack_header
#define stack_header

#include <stack>
#include <stdexcept>

template<typename T>
class CStack {
    std::stack<T> data;
public:
    CStack() {}
    
    // This parameterized constructor is required for the wrapper functions
    // and is not included in the MATLAB interface
    CStack(const std::stack<T>& d):data(d) {} 

    // Function to access the topmost element in stack
    T* get() {
        if (data.empty())
            throw std::runtime_error("Retrieving element from Empty Stack");
        return &data.top();
    }
    
    // Function to remove elements from stack
    void remove() { 
        if (data.empty())
            throw std::runtime_error("Stack is empty");
        data.pop();
    }
    
    // Function to add elements to stack
    void add(const T* element) { 
        data.push(*element);
    }
    
    // This method is required for the wrapper functions, and
    // is not included in the MATLAB interface
    const std::stack<T>& getData() const{ 
        return data;
    }
};
#endif

//Header to call readStudents and getStudents functions from MATLAB
#include "Student.hpp"
#include "CStack.hpp"

//wrapper function to access the function that accepts std::stack input
void readStudentsWrapper(const CStack<Student>& students) { 
    readStudents(students.getData());
}

//wrapper function to access the function that returns the std::stack
CStack<Student> getStudentsWrapper(int size) { 
    auto students = getStudents(size);
    CStack<Student> cstackStudents(students);
    return cstackStudents;
}

//Wrapper to instantiate template class Pairs
#include "Templates.hpp"

/* Data types that will be used for Pairs class. */
template class Pairs<int>;
template class Pairs<double>;

#define EXPORT

#include "Area.hpp"

DLL_EXPORT double getArea(int radius, double piVal) {
    return piVal*radius*radius;
}

//Wrapper to access the preprocessor directive value
#include "Area.hpp"

double getPI(){ //Wrapper function retrieves the value of PI
    return PI;
}

#define EXPORT

#include "StringVector.hpp"

DLL_EXPORT void readStringVector(const std::vector<std::string>& stringVector) {
}

DLL_EXPORT std::vector<std::string> getStringVector(int size) {
    std::vector<std::string> stringVector;
    for (int i = 0; i < size; i++) {
       stringVector.push_back(("string"+ std::to_string(i+1)));
    }
    return stringVector;
}

//Wrapper header to access/pass std::vector from MATLAB
#ifndef cvector_header
#define cvector_header

#include <vector>

template<typename T>
class CVector {
    std::vector<T> data;
public:
    CVector() {}
    CVector(const std::vector<T>& d): data(d) {}
    CVector(std::vector<T>&& d) : data(std::move(d)) {}
    T get(int index) { 
        return data.at(index-1);
    }
    void add(const T& element) { 
        data.push_back(element);
    }
    const std::vector<T>& getData() const {
        return data;
    }
};

#endif

// Header that allows the readStringVector and getStringVector functions 
// to be accessed from MATLAB interface
#include "StringVector.hpp"
#include "CVector.hpp"
#include <string>

void wrapperReadStringVector(const CVector<std::string>& stringVec) { 
    readStringVector(stringVec.getData());
}

CVector<std::string> wrapperGetStringVector(int size) { 
    auto strVec = getStringVector(size);
    CVector<std::string> cvecString(strVec);
    return cvecString;
}