// CSVWriter.cpp created by Sloan Phillippi @ 2:03pm 3/22/2019 || s:SocketTesting, p:SocketTesting

#include "pch.h"
#include "CSVWriter.h"
#include <exception>
#include <iostream>
#include <string>
#include <sstream>

struct DataFileAlreadyOpenException : std::exception { const char* what() const noexcept override { return "File already open."; } };

#pragma region Writer
struct NoDataForWritingException : std::exception { const char* what() const noexcept override { return "No data to write!"; } };

CsvWriter::CsvWriter(const std::string& _fileName)
{
    try
    {
        if (m_dataFile.is_open())
        {
            throw DataFileAlreadyOpenException();
        }
    }
    catch (std::exception& e)
    {
        std::cerr << e.what() << std::endl;
    }
    m_dataFile.open(_fileName, std::ofstream::out | std::ofstream::trunc);
}
CsvWriter::~CsvWriter()
{
    m_dataFile.close();
}

void CsvWriter::EmplaceData(std::vector<float> _entry)
{
    m_data.emplace_back(_entry);
}
void CsvWriter::WriteToFile()
{
    try
    {
        if (m_data.empty())
        {
            throw NoDataForWritingException();
        }
    }
    catch (std::exception& e)
    {
        std::cerr << e.what() << std::endl;
    }

    for (auto& row : m_data)
    {
        for (auto column : row)
        {
            m_dataFile << column << ",";
        }
        m_dataFile << std::endl;
    }
}
#pragma endregion

#pragma region Reader
struct NoDataForReadingException : std::exception { const char* what() const noexcept override { return "Data entry empty!"; } };
CsvReader::CsvReader(const std::string& _fileName)
{
    try
    {
        if (m_dataFile.is_open())
        {
            throw DataFileAlreadyOpenException();
        }
    }
    catch (std::exception& e)
    {
        std::cerr << e.what() << std::endl;
    }
    m_dataFile.open(_fileName);
}
CsvReader::~CsvReader()
{
    m_dataFile.close();
}
void CsvReader::ReadFromFile()
{
    std::string line;
    std::vector<std::vector<std::string>> parsedCsv;
    while (std::getline(m_dataFile, line))
    {
        std::stringstream lineStream(line);
        std::string cell;
        std::vector<std::string> parsedRow;
        while (std::getline(lineStream, cell, ','))
        {
            parsedRow.push_back(cell);
        }
        parsedCsv.push_back(parsedRow);
    }

    m_data.clear();

    for (auto row : parsedCsv)
    {
        std::vector<float> converted;
        for (const auto& column : row)
        {
            converted.emplace_back(std::stof(column));
        }
        m_data.emplace_back(converted);
    }
}
void CsvReader::GetData(std::vector<std::vector<float>>* _data)
{
    *_data = m_data;
}
std::vector<std::vector<float>> CsvReader::GetData()
{
    CheckData();

    return m_data;
}
void CsvReader::CheckData()
{
    try
    {
        if (m_data.empty())
        {
            throw NoDataForReadingException();
        }
    }
    catch (std::exception& e)
    {
        std::cerr << e.what() << std::endl;
    }
}
#pragma endregion