table.cpp

#include "globals.h"
#include <iostream>
#include <fstream>
#include <filesystem>
#include <sstream>
#include <algorithm>
#include "database.h"
#include "table.h"

#include "common.h"
#include "condition_ast.h"
#include "condition_evaluator.h"

extern std::vector<Table> tables;
bool loadTableFromDisk(const std::string& dbName, const std::string& tableName, Table* tableOut) {

tableOut->columns.clear();  
std::string schemaPath = getSchemaFilePath(dbName, tableName); 
    std::string dataPath = getCsvFilePath(dbName, tableName); 

    
    std::ifstream schemaFile(schemaPath);
    if (!schemaFile.is_open()) {
        std::cerr << "Error: Failed to open schema file: " << schemaPath << std::endl;
        return false;
    }

    std::string line;
    while (std::getline(schemaFile, line)) {
        size_t commaPos = line.find(',');
        if (commaPos != std::string::npos) {
            std::string field = line.substr(0, commaPos);
            field.erase(0, field.find_first_not_of(" \t"));
            field.erase(field.find_last_not_of(" \t") + 1);
            tableOut->columns.push_back(field);
           
        }
    }
    schemaFile.close();


    std::ifstream dataFile(dataPath);
    if (!dataFile.is_open()) {
        std::cerr << "Error: Failed to open data file: " << dataPath << std::endl;
        return false;
    }


std::getline(dataFile, line); 

    while (std::getline(dataFile, line)) {
        std::stringstream ss(line);
        std::map<std::string, std::string> row;
        std::string value;
        int i = 0;

        for (const auto& col : tableOut->columns) {
            if (std::getline(ss, value, ',')) {
                value.erase(0, value.find_first_not_of(" \t"));
                value.erase(value.find_last_not_of(" \t") + 1);
                row[col] = value;
            } else {
                break;
            }
            ++i;
        }

        if (i == tableOut->columns.size()) {
            tableOut->rows.push_back(row);
        }
    }

    dataFile.close();
    tableOut->name = tableName;
    return true;
}

std::map<std::string, int> getColumnMap(const std::string& tablePath) {
    std::map<std::string, int> columnMap;
    std::ifstream inFile(tablePath);
    if (!inFile.is_open()) return columnMap;

    std::string header;
    std::getline(inFile, header);
    std::stringstream ss(header);
    std::string field;
    int index = 0;
    while (std::getline(ss, field, ',')) {
        columnMap[field] = index++;
    }

    inFile.close();
    return columnMap;
}

bool createTable(const std::string& tableName, const std::vector<std::pair<std::string, std::string>>& fields) {
 auto& dbTables = databases[currentDatabase];
    if (dbTables.find(tableName) != dbTables.end()) {
        std::cerr << "Error: Table already exists in current database: " << tableName << std::endl;
        return false;
    }

    std::string schemaPath = getSchemaFilePath(currentDatabase, tableName);
    std::string dataPath = getCsvFilePath(currentDatabase, tableName); 

   
    if (fileExists(schemaPath)) std::filesystem::remove(schemaPath);
    if (fileExists(dataPath)) std::filesystem::remove(dataPath);

    
    std::ofstream schemaFile(schemaPath);
    if (!schemaFile.is_open()) {
        std::cerr << "Error: Failed to create schema file." << std::endl;
        return false;
    }
    for (const auto& field : fields) {
        schemaFile << field.first << "," << field.second << "\n";
    }
    schemaFile.close();

    
    std::ofstream csvFile(dataPath);
    if (!csvFile.is_open()) {
        std::cerr << "Error: Failed to create CSV file." << std::endl;
        return false;
    }
    csvFile.close();

  
    Table newTable;
    newTable.name = tableName;
    for (const auto& field : fields) {
        newTable.columns.push_back(field.first);
    }
    dbTables[tableName] = newTable;

    std::cout << "Created table and files: " << tableName << std::endl;
    return true;
}


bool dropTable(const std::string& tableName) {
   auto& dbTables = databases[currentDatabase];
    if (dbTables.find(tableName) == dbTables.end()) {
        std::cerr << "Error: Table does not exist: " << tableName << std::endl;
        return false;
    }

   std::string csvPath = getCsvFilePath(currentDatabase, tableName); 
    std::string schemaPath = getSchemaFilePath(currentDatabase, tableName); 
    
    if (fileExists(csvPath)) std::filesystem::remove(csvPath);
    if (fileExists(schemaPath)) std::filesystem::remove(schemaPath);
   
    dbTables.erase(tableName);

    std::cout << "Dropped table: " << tableName << std::endl;
    return true;
}

std::vector<std::string> showTables() {
    std::vector<std::string> tables;
    auto dbIt = databases.find(currentDatabase);
    if (dbIt != databases.end()) {
        for (const auto& [tableName, table] : dbIt->second) {
            tables.push_back(tableName);
        }
    }
    return tables;
}


bool insertData(const std::string& tableName, const std::map<std::string, std::string>& values) {
   auto& dbTables = databases[currentDatabase];
    auto it = dbTables.find(tableName);
    if (it == dbTables.end()) {
        std::cerr << "Error: Table does not exist: " << tableName << std::endl;
        return false;
    }
    Table* table = &it->second;

    
    for (const auto& col : table->columns) {
        if (values.find(col) == values.end()) {
            std::cerr << "Error: Missing column value: " << col << std::endl;
            return false;
        }
    }

   
    table->rows.push_back(values);

    
return saveTableToDisk(currentDatabase, *table);
}


std::vector<std::vector<std::string>> selectData(const std::string& tableName) {
  auto dbIt = databases.find(currentDatabase);
    if (dbIt == databases.end()) {
        std::cerr << "Error: Current database not set." << std::endl;
        return {};
    }

    auto& dbTables = dbIt->second;
    auto it = dbTables.find(tableName);
    if (it == dbTables.end()) {
        std::cerr << "Error: Table does not exist in memory: " << tableName << std::endl;
        return {};
    }

    const Table& table = it->second;
    std::vector<std::vector<std::string>> result;

    for (const auto& row : table.rows) {
        std::vector<std::string> rowData;
        for (const auto& col : table.columns) {
            rowData.push_back(row.at(col));
        }
        result.push_back(rowData);
    }

    return result;
}


std::vector<std::vector<std::string>> selectDataWithCondition(
    const std::string& tableName, ConditionNode* condition)
{
  
    auto dbIt = databases.find(currentDatabase);
    if (dbIt == databases.end()) {
        std::cerr << "Error: Current database not set." << std::endl;
        return {};
    }

    auto& dbTables = dbIt->second;
    auto tableIt = dbTables.find(tableName);
    if (tableIt == dbTables.end()) {
        std::cerr << "Error: Table does not exist in current database: " << tableName << std::endl;
        return {};
    }

    Table& table = tableIt->second;

    std::vector<std::vector<std::string>> result;

    for (const auto& row : table.rows) {
        if (!condition || evaluateCondition(row, condition)) {
            std::vector<std::string> currentRow;
            for (const auto& col : table.columns) {
                currentRow.push_back(row.at(col));
            }
            result.push_back(currentRow);
        }
    }

    return result;
}

bool updateTuple(const std::string& tableName,
                 const std::vector<std::pair<std::string, std::string>>& updates,
                 ConditionNode* condition) {
   auto& dbTables = databases[currentDatabase];
    auto it = dbTables.find(tableName);
    if (it == dbTables.end()) return false;
    Table* table = &it->second;

    bool updated = false;

    for (auto& row : table->rows) {
        if (!condition || evaluateCondition(row, condition)) {
            for (const auto& [field, value] : updates) {
                row[field] = value;
            }
            updated = true;
        }
    }

   
    if (updated) {
    std::cout << "Updating table and saving to disk: " << table->name << std::endl;
       saveTableToDisk(currentDatabase, *table);
    }

    return updated;
}
bool saveTableToDisk(const std::string& dbName, const Table& table) {
 std::string dataPath = getCsvFilePath(dbName, table.name);
std::cout << "Saving table to" << std::endl;
    std::ofstream out(dataPath);
    if (!out) return false;

    
    for (size_t i = 0; i < table.columns.size(); ++i) {
        out << table.columns[i]; 
        if (i != table.columns.size() - 1) out << ",";
    }
    out << "\n";

   
    for (const auto& row : table.rows) {
        for (size_t i = 0; i < table.columns.size(); ++i) {
            const std::string& colName = table.columns[i];
            out << row.at(colName); 
            if (i != table.columns.size() - 1) out << ",";
        }
        out << "\n";
    }

    out.close();
    return true;
}

bool deleteTuple(const std::string& tableName,
                 ConditionNode* condition) {
   auto& dbTables = databases[currentDatabase];
    auto it = dbTables.find(tableName);
    if (it == dbTables.end()) return false;
    Table* table = &it->second;

    bool deleted = false;
    auto newEnd = std::remove_if(table->rows.begin(), table->rows.end(),
                                 [&](const std::map<std::string, std::string>& row) {
                                     bool shouldDelete = !condition || evaluateCondition(row, condition);
                                     if (shouldDelete) deleted = true;
                                     return shouldDelete;
                                 });

    table->rows.erase(newEnd, table->rows.end());

   
    if (deleted) {
        return saveTableToDisk(currentDatabase, *table);
    }

    return deleted;
}


Table* getTableByName(const std::string& tableName) {
   auto dbIt = databases.find(currentDatabase);
    if (dbIt != databases.end()) {
        auto it = dbIt->second.find(tableName);
        if (it != dbIt->second.end()) {
            return &it->second;
        }
    }
    return nullptr;

}