file.hpp

#ifndef CUSTOM_FILE_HPP
#define CUSTOM_FILE_HPP

#include <string>
#include <vector>
#include <ctime>
#include <iostream>
#include "tree.hpp"
#include "hashmap.hpp"

// File object..holds version tree..and a map from id->node
// simple methods .. create, read, insert, update, snapshot, rollback, history

struct File {
    TreeNode* root;
    TreeNode* active_version;
    HashMap<int, TreeNode*> version_map; // custom hash map
    int total_versions;
    std::time_t last_modified; // for analytics ..

    File() : root(nullptr), active_version(nullptr), version_map(), total_versions(0), last_modified(0) {}

    static std::time_t now() {
        return std::time(nullptr);
    }

    void init_empty() {
        std::time_t t = now();
        root = new TreeNode(0, "", "Initial root", t);
        root->snapshot_timestamp = t;
        active_version = root;
        version_map.put(0, root);
        total_versions = 1;
        last_modified = t;
    }

    void touch() {
        last_modified = now();
    }
    void read() const {
        if (!active_version) {
            std::cout << "ERROR: No active version\n";
            return;
        }
        std::cout << active_version->content << "\n";
    }
    TreeNode* fork_from_active(const std::string& new_content) {
        int new_id = total_versions;
        TreeNode* child = new TreeNode(new_id, new_content, "", now());
        child->parent = active_version;
        active_version->children.push_back(child);
        version_map.put(new_id, child);
        total_versions++;
        active_version = child;
        touch();
        return child;
    }
    void insert(const std::string& extra) {
        if (!active_version) { std::cout << "ERROR: File not initialized\n"; return; }
        if (active_version->snapshot_timestamp != 0) {
            std::string combined = active_version->content + extra;
            fork_from_active(combined);
        } else {
            active_version->content += extra;
            active_version->created_timestamp = now();
            touch();
        }
    }
    void update(const std::string& new_content) {
        if (!active_version) { std::cout << "ERROR: File not initialized\n"; return; }
        if (active_version->snapshot_timestamp != 0) {
            fork_from_active(new_content);
        } else {
            active_version->content = new_content;
            active_version->created_timestamp = now();
            touch();
        }
    }
    void snapshot(const std::string& msg) {
        if (!active_version) { std::cout << "ERROR: File not initialized\n"; return; }
        if (active_version->snapshot_timestamp != 0) {
            std::cout << "WARN: Active version is already a snapshot\n";
            return;
        }
        active_version->message = msg;
        active_version->snapshot_timestamp = now();
        touch();
    }
    void rollback_to(int version_id, bool has_id) {
        if (!active_version) { std::cout << "ERROR: File not initialized\n"; return; }
        if (has_id) {
            TreeNode** p = version_map.getPtr(version_id);
            if (!p || !(*p)) {
                std::cout << "ERROR: Version " << version_id << " not found\n";
                return;
            }
            active_version = *p;
            touch();
        } else {
            if (!active_version->parent) {
                std::cout << "ERROR: Already at root; cannot rollback further\n";
                return;
            }
            active_version = active_version->parent;
            touch();
        }
    }
    void history() const {
        std::vector<int> ids;
        version_map.keys(ids);
        struct Pair { int id; std::time_t ts; };
        std::vector<Pair> snaps;
        for (int id : ids) {
            const TreeNode* const* p = version_map.getPtr(id);
            if (!p || !(*p)) continue;
            const TreeNode* node = *p;
            if (node->snapshot_timestamp != 0) {
                snaps.push_back({id, node->snapshot_timestamp});
            }
        }
        for (size_t i = 1; i < snaps.size(); ++i) {
            Pair key = snaps[i];
            size_t j = i;
            while (j > 0 && snaps[j-1].ts > key.ts) {
                snaps[j] = snaps[j-1];
                --j;
            }
            snaps[j] = key;
        }
        for (const auto& p : snaps) {
            const TreeNode* const* nodePtr = version_map.getPtr(p.id);
            const TreeNode* node = nodePtr ? *nodePtr : nullptr;
            if (!node) continue;
            std::cout << node->version_id << " " << (long long)node->snapshot_timestamp << " " << node->message << "\n";
        }
    }
    ~File() {
        if (!root) return;
        std::vector<TreeNode*> stack;
        stack.push_back(root);
        while (!stack.empty()) {
            TreeNode* cur = stack.back(); stack.pop_back();
            for (TreeNode* ch : cur->children) {
                if (ch) stack.push_back(ch);
            }
            delete cur;
        }
    }
};

#endif