graph_server.cpp

#include "AdjacencyContainer.h"
#include "httplib.h"
#include "json.hpp"

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <unordered_map>

using json = nlohmann::json;

using namespace std;

struct Node {
    int id;
    json props;
    Node(int id_= 0, const json &p=json{}) : id(id_), props(p) {}
};

AdjacencyContainer graph;
unordered_map<int, Node> nodes;


string addNode(int id, const json &props) {
    if (nodes.count(id)) {
        return "Node already exists\n";
    }
    nodes[id] = Node(id, props);
    return "Added node " + to_string(id) + "\n";
}

string addEdge(int u, int v, double w, const json &props) {
    if (!nodes.count(u) || !nodes.count(v)) {
        return "Node(s) missing\n";
    }
    graph.insert_edge({v, w});
    return "Added edge " + to_string(u) + " -> " + to_string(v) + "\n";
}

string findNodeWhere(const string &key, const string &value) {
    ostringstream oss;
    for (auto &[id, node] : nodes) {
        if (node.props.contains(key) && node.props[key].get<string>() == value) {
            oss << "Node " << id << " matches\n";
        }
    }
    return oss.str().empty() ? "No matching nodes\n" : oss.str();
}

string neighbors(int id) {
    ostringstream oss;
    for (auto &e : graph.neighbors()) {
        oss << id << " -> " << e.to << " weight: " << e.weight << "\n";
    }
    return oss.str().empty() ? "No neighbors\n" : oss.str();
}

string printGraph() {
    ostringstream oss;
    oss << "Nodes:\n";
    for (auto &[id, node] : nodes) {
        oss << "  " << id << " " << node.props.dump() << "\n";
    }
    oss << "Edges:\n";
    for (auto &e : graph.neighbors()) {
        oss << "  " << e.to << " weight: " << e.weight << "\n";
    }
    return oss.str();
}

string saveGraph(const string &filename) {
    json j;
    j["nodes"] = json::array();
    for (auto &[id, node] : nodes) {
        json n;
        n["id"] = node.id;
        n["props"] = node.props;
        j["nodes"].push_back(n);
    }
    j["edges"] = json::array();
    for (auto &e : graph.neighbors()) {
        json edge;
        edge["to"] = e.to;
        edge["weight"] = e.weight;
        j["edges"].push_back(edge);
    }

    ofstream ofs(filename);
    if (!ofs.is_open()) return "Failed to open file\n";
    ofs << j.dump(4);
    return "Graph saved to " + filename + "\n";
}

string loadGraph(const string &filename) {
    ifstream ifs(filename);
    if (!ifs.is_open()) return "Failed to open file\n";
    json j;
    ifs >> j;

    nodes.clear();
    graph.edges_list.clear();
    graph.edges_cache.clear();
    graph.cache_valid = false;

    for (auto &n : j["nodes"]) {
        nodes[n["id"].get<int>()] = Node(n["id"].get<int>(), n["props"]);
    }
    for (auto &e : j["edges"]) {
        graph.insert_edge({e["to"].get<int>(), e["weight"].get<double>()});
    }
    return "Graph loaded from " + filename + "\n";
}

string clearGraph() {
    nodes.clear();
    graph.edges_list.clear();
    graph.edges_cache.clear();
    graph.cache_valid = false;
    return "Graph cleared\n";
}

string deleteNode(int id) {
    // 1. Check if node exists
    if (nodes.find(id) == nodes.end())
        return "Node not found\n";

    // 2. Remove node from nodes map
    nodes.erase(id);

    // 3. Remove all edges pointing to or from this node
    int removed = 0;

    // Remove outgoing edges (from node `id`)
    removed += graph.remove_edge_to(id);

    // Remove incoming edges (edges that lead to `id`)
    for (auto it = graph.edges_list.begin(); it != graph.edges_list.end(); ) {
        if (it->to == id) {
            it = graph.edges_list.erase(it);
            removed++;
        } else {
            ++it;
        }
    }

    graph.cache_valid = false;

    ostringstream oss;
    oss << "Deleted Node " << id << " and " << removed << " edges\n";
    return oss.str();
}

string deleteEdge(int from, int to) {
    // Ensure 'from' node exists
    if (nodes.find(from) == nodes.end())
        return "Source node not found\n";

    // Remove edges from `from` → `to`
    int removed = graph.remove_edge_to(to);

    if (removed == 0)
        return "No edge found from " + to_string(from) + " to " + to_string(to) + "\n";

    ostringstream oss;
    oss << "Deleted " << removed << " edge(s) from " << from << " to " << to << "\n";
    return oss.str();
}


// --- Main query parser ---
string executeQuery(const string &query) {
    istringstream ss(query);
    istringstream iss(query);
    string cmd;
    ostringstream output;
    iss >> cmd;

    while (ss >> cmd) {
        if (cmd == "ADD") {
            string type;
            ss >> type;
            if (type == "NODE") {
                int id;
                ss >> id;
                string rest;
                getline(ss, rest); // PROPS JSON
                json props = json::object();
                auto pos = rest.find("PROPS");
                if (pos != string::npos) {
                    string jsonStr = rest.substr(pos + 5);
                    try { props = json::parse(jsonStr); } catch (...) {}
                }
                output << addNode(id, props);
            } else if (type == "EDGE") {
                int u, v;
                double w;
                ss >> u >> v >> w;
                string rest;
                getline(ss, rest); // PROPS (optional)
                json props = json::object();
                auto pos = rest.find("PROPS");
                if (pos != string::npos) {
                    string jsonStr = rest.substr(pos + 5);
                    try { props = json::parse(jsonStr); } catch (...) {}
                }
                output << addEdge(u, v, w, props);
            }
        } else if (cmd == "FIND") {
            string node, where, condition;
            ss >> node >> where;
            getline(ss, condition);
            auto eqPos = condition.find('=');
            if (eqPos != string::npos) {
                string key = condition.substr(0, eqPos);
                string value = condition.substr(eqPos + 1);
                output << findNodeWhere(key, value);
            }
        } else if (cmd == "NEIGHBORS") {
            int id;
            ss >> id;
            output << neighbors(id);
        } else if (cmd == "PRINT") {
            output << printGraph();
        } else if (cmd == "SAVE") {
            string filename;
            ss >> filename;
            output << saveGraph(filename);
        } else if (cmd == "LOAD") {
            string filename;
            ss >> filename;
            output << loadGraph(filename);
            output << clearGraph();
        } else if (cmd == "CLEAR") {
        }
        else if (cmd == "DELETE") {
            string type;
            iss >> type;
            if (type == "NODE") {
                int id;
                iss >> id;
                return deleteNode(id);
            } else if (type == "EDGE") {
                int from, to;
                iss >> from >> to;
                return deleteEdge(from, to);
            } else {
                return "Unknown DELETE command\n";
            }
        }

        else {
            output << "Unknown command: " << cmd << "\n";
        }
    }

    return output.str();
}

int main() {
    httplib::Server svr;

    svr.Post("/query", [](const httplib::Request &req, httplib::Response &res){
        string result = executeQuery(req.body);
        res.set_content(result, "text/plain");
    });

    cout << "Server running at http://localhost:8080\n";


    // Handle CORS preflight requests
    svr.Options("/query", [](const httplib::Request& req, httplib::Response& res) {
        res.set_header("Access-Control-Allow-Origin", "*");
        res.set_header("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
        res.set_header("Access-Control-Allow-Headers", "Content-Type");
        res.status = 200;
    });

    // Automatically add CORS headers to all responses
    svr.set_default_headers({
        {"Access-Control-Allow-Origin", "*"},
        {"Access-Control-Allow-Methods", "POST, GET, OPTIONS"},
        {"Access-Control-Allow-Headers", "Content-Type"}
    });


    svr.listen("0.0.0.0", 8080);
}