main.cpp

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>

// #include <thread>
// #include <chrono>

#include "Tree.cpp"
using namespace std;

int main()
{
    map<string, time_t> recent_files;
    map<string, int> biggest_trees;

    map<string, Tree *> files;

    while (true)
    {
        string line;
        getline(cin, line); // read the rest of the line (could be empty or with versionID)
        stringstream ss(line);

        string cmd, filename, content, message;
        ss >> cmd;

        if (cmd == "CREATE")
        {
            if (!(ss >> filename))
            {
                cout << "Please provide a filename. \n";
                continue;
            }

            if (files.count(filename))
            {
                cout << "Error: File already exists.\n";
                continue;
            }

            Tree *new_file = new Tree();
            files[filename] = new_file;

            recent_files[filename] = time(nullptr);

            cout << "Created file: " << filename << " with version 0 (snapshot)\n";
            biggest_trees[filename] = 1;
        }
        else if (cmd == "READ")
        {
            if (!(ss >> filename))
            {
                cout << "Please provide a filename. \n";
                continue;
            }

            if (!files.count(filename))
            {
                cout << "Error: File does not exist.\n";
                continue;
            }

            Tree *curr_file = files[filename];
            TreeNode *active_version = curr_file->active_version;

            cout << "ID: " << active_version->version_id << " " << active_version->content << "\n";
        }
        else if (cmd == "INSERT")
        {
            if (!(ss >> filename))
            {
                cout << "Please provide a filename.\n";
                continue;
            }

            if (!files.count(filename))
            {
                cout << "Error: File does not exist.\n";
                continue;
            }

            getline(ss >> ws, content);
            // cin >> content;

            if (content.empty())
            {
                cout << "Error: No content provided.\n";
                continue;
            }

            Tree *curr_file = files[filename];
            TreeNode *active_version = curr_file->active_version;
            if (active_version->snapshot_timestamp != 0)
            {
                // Block handling if active version is a snapshot
                TreeNode *new_version = new TreeNode(curr_file->total_versions);
                new_version->parent = active_version; // Assigning parent as the snapshot

                new_version->content = active_version->content + content;
                active_version->children.push_back(new_version);

                curr_file->active_version = new_version;

                // Update version map of current file
                curr_file->version_map[new_version->version_id] = curr_file->active_version;
                // Update total number of versions now
                curr_file->total_versions += 1;

                cout << "[" << filename << "]" << " INSERTED to new version: [" << new_version->version_id << "]\n";
            }
            else
            {
                active_version->content += content;
                cout << "[" << filename << "]" << " INSERTED to recent version: [" << active_version->version_id << "]\n";
            }

            recent_files[filename] = time(nullptr);
            biggest_trees[filename] = curr_file->total_versions;
        }
        else if (cmd == "UPDATE")
        {
            if (!(ss >> filename))
            {
                cout << "Please provide a filename. \n";
                continue;
            }

            if (!files.count(filename))
            {
                cout << "Error: File does not exist.\n";
                continue;
            }

            getline(ss >> ws, content);

            if (content.empty())
            {
                cout << "Error: No content provided.\n";
                continue;
            }

            Tree *curr_file = files[filename];
            TreeNode *active_version = curr_file->active_version;
            if (active_version->snapshot_timestamp != 0)
            {
                // Block handling if active version is a snapshot
                TreeNode *new_version = new TreeNode(curr_file->total_versions);
                new_version->parent = active_version; // Assigning parent as the snapshot

                new_version->content = content;
                active_version->children.push_back(new_version);

                curr_file->active_version = new_version;

                // Update version map of current file
                curr_file->version_map[new_version->version_id] = curr_file->active_version;
                // Update total number of versions now
                curr_file->total_versions += 1;

                cout << "[" << filename << "]" << " UPDATED to new version: [" << new_version->version_id << "]\n";
            }
            else
            {
                active_version->content = content;
                cout << "[" << filename << "]" << " UPDATED recent version: [" << active_version->version_id << "]\n";
            }

            recent_files[filename] = time(nullptr);
            biggest_trees[filename] = curr_file->total_versions;
        }
        else if (cmd == "SNAPSHOT")
        {
            ss >> filename;

            getline(ss >> ws, message);

            if (!files.count(filename))
            {
                cout << "Error: File does not exist.\n";
                continue;
            }

            if (message.empty())
            {
                cout << "Provide a message to commit a snapshot.\n";
                continue;
            }

            Tree *curr_file = files[filename];
            if (curr_file->active_version->snapshot_timestamp != 0)
            {
                cout << "[" << filename << "]" << ": Version [" << curr_file->active_version->version_id << "] is already a Snapshot.\n";
                continue;
            }

            curr_file->active_version->message = message;
            curr_file->active_version->snapshot_timestamp = time(nullptr);
            cout << "[" << filename << "]" << ": Snapshotted version: [" << curr_file->active_version->version_id << "].\n";
        }
        else if (cmd == "ROLLBACK")
        {
            bool rollback_to_parent = false;

            ss >> filename; // first token is always filename

            if (!files.count(filename))
            {
                cout << "Error: File does not exist.\n";
                continue;
            }

            int versionID;
            if (ss >> versionID) // if versionID is provided
            {
                Tree *curr_file = files[filename];
                if (curr_file->version_map.count(versionID) == 0)
                {
                    cout << "[" << filename << "]" << " Version [" << versionID << "] does not exist\n";
                    continue;
                }
                curr_file->active_version = curr_file->version_map[versionID];
                cout << "[" << filename << "]" << " Rollback to [" << versionID << "] successful\n";
            }
            else // no versionID → rollback to parent
            {
                Tree *curr_file = files[filename];
                if (curr_file->active_version->parent == nullptr)
                {
                    cout << "[" << filename << "]" << " Already at root version. Cannot rollback further.\n";
                    rollback_to_parent = true;
                }
                else
                {
                    curr_file->active_version = curr_file->active_version->parent;
                    cout << "[" << filename << "]" << " Rollback to parent [" << curr_file->active_version->version_id << "] successful\n";
                }
            }

            if (!rollback_to_parent)
                recent_files[filename] = time(nullptr);
        }
        else if (cmd == "HISTORY")
        {
            ss >> filename;
            if (!files.count(filename))
            {
                cout << "Error: File does not exist.\n";
                continue;
            }

            Tree *curr_file = files[filename];
            auto cmp = [&](TreeNode a, TreeNode b)
            {
                return a.snapshot_timestamp < b.snapshot_timestamp;
            };
            Heap<TreeNode, decltype(cmp)> history(cmp);
            TreeNode path = *curr_file->active_version;

            while (true)
            {
                if (path.snapshot_timestamp != 0)
                {
                    history.push(path);
                }

                if (path.parent == nullptr)
                    break;
                path = *path.parent;
            }

            cout << "\nHistory of file [" << filename << "]:\n";
            while (!history.empty())
            {
                TreeNode x = history.top();
                history.pop();

                cout << "Version: " << x.version_id << ", Timestamp: " << ctime(&x.snapshot_timestamp) << "Message: " << x.message << "\n";
            }
        }
        else if (cmd == "RECENT_FILES")
        {
            int k;
            if (ss >> k)
            {
                vector<pair<string, time_t>> files = recent_files.items();

                auto cmp = [&](const pair<string, time_t> a, const pair<string, time_t> b)
                {
                    return a.second > b.second;
                };

                Heap<pair<string, time_t>, decltype(cmp)> most_recent(cmp);
                for (auto file : files)
                {
                    most_recent.push(file);
                }

                cout << "\nThe [" << k << "] recent files: \n";
                for (int i = 0; i < k; i++)
                {
                    if (most_recent.empty())
                    {
                        cout << "Terminating early because you specified more number than number of files.\n";
                        break;
                    }
                    auto f = most_recent.top();
                    most_recent.pop();
                    cout << f.first << " -> " << ctime(&f.second);
                }
            }
            else
            {
                cout << "Please specify the number of files.\n";
            }
        }
        else if (cmd == "BIGGEST_TREES")
        {
            int k;
            if (ss >> k)
            {
                vector<pair<string, int>> trees = biggest_trees.items();

                auto cmp = [&](const pair<string, int> a, const pair<string, int> b)
                {
                    if (a.second == b.second)
                    {
                        return recent_files[a.first] < recent_files[b.first];
                    }
                    return a.second > b.second;
                };

                Heap<pair<string, int>, decltype(cmp)> biggest_files(cmp);
                for (auto tree : trees)
                {
                    biggest_files.push(tree);
                }

                cout << "\nThe [" << k << "] biggest trees:\n";
                for (int i = 0; i < k; i++)
                {
                    if (biggest_files.empty())
                    {
                        cout << "Terminating early because you specified more number than number of files.\n";
                        break;
                    }
                    auto t = biggest_files.top();
                    biggest_files.pop();
                    cout << t.first << " -> " << t.second << " versions\n";
                }
            }
            else
            {
                cout << "Please specify the number of files.\n";
            }
        }
        else if (cmd == "EXIT" || cmd == "exit")
        {
            break;
        }
        else
        {
            cout << "Unknown command: " << cmd << "\n";
        }

        // this_thread::sleep_for(chrono::milliseconds(400));
    }

    return 0;
}