codekeeper.cpp

#include <iostream>
#include <fstream>
#include <filesystem>
#include <string>
#include <vector>
#include <ctime>
#include <sstream>
#include <iterator>
#include <algorithm>
#include <openssl/sha.h>
#include <iomanip>
#include <cstring>
#include <regex>
#include <openssl/evp.h>
#include <set>
#include <unistd.h>
#include <sys/wait.h>

#include <sys/stat.h>
namespace fs = std::filesystem;

// Structure to hold metadata for commits
struct Commit {
    std::string message;
    std::string timestamp;
    std::vector<std::string> filePaths;
    std::vector<std::string> versionPaths;
};

std::string repositoryPath;

// Function to generate a timestamp
std::string getTimestamp() {
    std::time_t now = std::time(nullptr);
    char buf[80];
    std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", std::localtime(&now));
    return buf;
}

// utility function
std::vector<std::string> split(const std::string &str, char delimiter)
{
    std::vector<std::string> tokens;
    std::stringstream ss(str);
    std::string token;
    while (std::getline(ss, token, delimiter))
    {
        tokens.push_back(token);
    }
    return tokens;
}

// Ensure a file path is within the repository (prevents path traversal)
bool isPathSafe(const std::string& filePath) {
    try {
        fs::path resolved = fs::weakly_canonical(fs::absolute(filePath));
        fs::path repo = fs::weakly_canonical(fs::absolute(repositoryPath));
        auto rel = fs::relative(resolved, repo);
        return !rel.empty() && rel.string().find("..") == std::string::npos;
    } catch (...) {
        return false;
    }
}

bool filesAreEqual(const std::string &filePath1, const std::string &filePath2)
{
    std::ifstream file1(filePath1, std::ios::binary);
    std::ifstream file2(filePath2, std::ios::binary);
    return std::equal(std::istreambuf_iterator<char>(file1), std::istreambuf_iterator<char>(),
                      std::istreambuf_iterator<char>(file2));
}

// Escape special characters for log safety
std::string escape(const std::string& input) {
    std::string output;
    for (char c : input) {
        if (c == '|') output += "\\|";
        else output += c;
    }
    return output;
}
// Helper function to compute SHA-256 hash of a string
std::string computeStringHash(const std::string& input) {
    EVP_MD_CTX* ctx = EVP_MD_CTX_new();
    if (!ctx) return "";

    unsigned char hash[EVP_MAX_MD_SIZE];
    unsigned int length = 0;

    if (EVP_DigestInit_ex(ctx, EVP_sha256(), nullptr) != 1 ||
        EVP_DigestUpdate(ctx, input.c_str(), input.size()) != 1 ||
        EVP_DigestFinal_ex(ctx, hash, &length) != 1) {
        EVP_MD_CTX_free(ctx);
        return "";
    }

    EVP_MD_CTX_free(ctx);

    std::ostringstream result;
    for (unsigned int i = 0; i < length; ++i) {
        result << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(hash[i]);
    }

    return result.str();
}
/// Function to compute SHA-256 hash of a file (simple implementation)
std::string computeFileHash(const fs::path& filePath) 
{
        std::ifstream file(filePath, std::ios::binary);
    if (!file) return "";

    EVP_MD_CTX* mdctx = EVP_MD_CTX_new();
    if (!mdctx) return "";

    const EVP_MD* md = EVP_sha256();
    if (1 != EVP_DigestInit_ex(mdctx, md, nullptr)) { EVP_MD_CTX_free(mdctx); return ""; }

    char buffer[8192];
    while (file.good()) {
        file.read(buffer, sizeof(buffer));
        if (1 != EVP_DigestUpdate(mdctx, buffer, file.gcount())) { EVP_MD_CTX_free(mdctx); return ""; }
    }

    unsigned char hash[EVP_MAX_MD_SIZE];
    unsigned int hashLen = 0;
    if (1 != EVP_DigestFinal_ex(mdctx, hash, &hashLen)) { EVP_MD_CTX_free(mdctx); return ""; }

    EVP_MD_CTX_free(mdctx);

    std::ostringstream result;
    for (unsigned int i = 0; i < hashLen; ++i) {
        result << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
    }

    return result.str();
}

//function to get current repo path
std::string getCentralRepositoryPath()
{
    std::ifstream configFile(".repo_path");
    std::string repositoryPath;
    if (configFile.is_open())
    {
        std::getline(configFile, repositoryPath);
    }
    return repositoryPath;
}


// Function to load the repository path
void loadRepositoryPath() {
    std::ifstream repoFile(".repo_path");
    if (repoFile.is_open()) {
        std::getline(repoFile, repositoryPath);
        repoFile.close();
    } else {
        std::cerr << "Error: Repository not initialized. Run 'codekeeper init'.\n";
        repositoryPath.clear();
    }
}

// Initialize the repository
void initRepository(const std::string& projectName, bool local = false) 
{
    std::regex safeName("^[a-zA-Z0-9_-]+$");
    if (!std::regex_match(projectName, safeName)) {
        throw std::runtime_error("Invalid project name: only letters, digits, _ and - are allowed.");
    }

    fs::path repoPath;
    if (local) {
        // Create repo right in the current directory
        repoPath = fs::weakly_canonical(fs::current_path());
        // Check if already initialized here
        if (fs::exists(repoPath / ".repo_path")) {
            std::cout << "Repository already initialized in " << repoPath << std::endl;
            repositoryPath = repoPath.string();
            return;
        }
    } else {
        fs::path baseDir = "/var/lib/CodeKeeper";
        if (!fs::exists(baseDir)) {
            fs::create_directories(baseDir);
        }
        std::string repoName = projectName.empty() ? baseDir.filename().string() : projectName;
        repoPath = fs::weakly_canonical(baseDir / fs::path(repoName).filename());
        if (!fs::exists(repoPath)) {
            fs::create_directory(repoPath);
        }
    }


    if (!fs::exists(repoPath)) {
        fs::create_directory(repoPath);
    }

    repositoryPath = repoPath.string();

    std::ofstream repoFile(".repo_path");
    repoFile << repositoryPath;
    repoFile.close();

    fs::create_directory(repoPath / "versions");

    std::ofstream bypassFile(repoPath / ".bypass");
    bypassFile << "# Add files or patterns to ignore\n";
    bypassFile.close();

    std::ofstream logFile(repoPath / "commit_log.txt");
    logFile.close();

    // Create .users file with secure permissions
    std::ofstream usersFile(repoPath / ".users");
    usersFile.close();
    chmod((repoPath / ".users").c_str(), 0600);

    std::cout << "Repository '" << repositoryPath << "' initialized successfully.\n";
    if (!local) {
        std::cout << "Change your terminal to the project folder: cd " << repositoryPath << "\n";
    }
}
// Run a hook script if it exists; return true if success, false if failed
bool runHook(const std::string& hookName) {
    fs::path hookPath = fs::path(repositoryPath) / hookName;
    if (fs::exists(hookPath) && fs::is_regular_file(hookPath)) {
        pid_t pid = fork();
        if (pid == 0) {
            execlp("/bin/bash", "bash", hookPath.c_str(), nullptr);
            _exit(127);
        } else if (pid > 0) {
            int status;
            waitpid(pid, &status, 0);
            if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
                return true;
            }
            std::cerr << hookName << " hook failed (exit code " << WEXITSTATUS(status) << ").\n";
            return false;
        }
    }
    return true;
}

// Recursively collect regular files from a path (skips hidden, repo, and binary files)
std::vector<std::string> collectFiles(const std::string& path) {
    std::vector<std::string> files;
    fs::path p = fs::absolute(path);
    if (!fs::exists(p)) return files;
    if (fs::is_regular_file(p)) {
        files.push_back(p.string());
    } else if (fs::is_directory(p)) {
        for (const auto& entry : fs::recursive_directory_iterator(p)) {
            if (fs::is_regular_file(entry)) {
                std::string fname = entry.path().filename().string();
                // Skip hidden files, repo internals, and the binary
                if (fname[0] == '.' || fname == "commit_log.txt" || fname == "codekeeper" || fname == "codekeeper.exe") continue;
                // Skip files inside repo-internal directories (.staging, versions, branches)
                auto rel = fs::relative(entry.path(), p);
                bool inInternal = false;
                for (const auto& part : rel) {
                    std::string s = part.string();
                    if (s == ".staging" || s == "versions" || s == "branches" || s[0] == '.') { inInternal = true; break; }
                }
                if (!inInternal) files.push_back(fs::absolute(entry.path()).string());
            }
        }
    }
    return files;
}

// Function to add files to staging area
void addToStaging(const std::vector<std::string>& filePaths) {
    loadRepositoryPath();
    if (repositoryPath.empty()) {
        std::cerr << "Error: Repository not initialized. Run 'codekeeper init'.\n";
        return;
    }
    fs::path stagingDir = fs::path(repositoryPath) / ".staging";
    if (!fs::exists(stagingDir)) {
        fs::create_directory(stagingDir);
    }
    for (const auto& filePath : filePaths) {
        auto expanded = collectFiles(filePath);
        for (const auto& src : expanded) {
            if (!isPathSafe(src)) {
                std::cerr << "Error: File " << src << " is outside the repository.\n";
                continue;
            }
            fs::path dest = stagingDir / fs::path(src).filename();
            fs::copy(src, dest, fs::copy_options::overwrite_existing);
            std::cout << "Staged: " << src << "\n";
        }
    }
}

// Function to reset (unstage) files from staging area
void resetStaging(const std::vector<std::string>& filePaths) {
    loadRepositoryPath();
    if (repositoryPath.empty()) {
        std::cerr << "Error: Repository not initialized. Run 'codekeeper init'.\n";
        return;
    }
    fs::path stagingDir = fs::path(repositoryPath) / ".staging";
    for (const auto& filePath : filePaths) {
        fs::path stagedFile = stagingDir / fs::path(filePath).filename();
        if (fs::exists(stagedFile)) {
            fs::remove(stagedFile);
            std::cout << "Unstaged: " << filePath << "\n";
        } else {
            std::cout << "File not staged: " << filePath << "\n";
        }
    }
}

// Helper to get all staged files
std::vector<std::string> getStagedFiles() {
    loadRepositoryPath();
    std::vector<std::string> stagedFiles;
    fs::path stagingDir = fs::path(repositoryPath) / ".staging";
    if (fs::exists(stagingDir)) {
        for (const auto& entry : fs::directory_iterator(stagingDir)) {
            if (fs::is_regular_file(entry)) {
                stagedFiles.push_back(entry.path().string());
            }
        }
    }
    return stagedFiles;
}

// Function to commit multiple files
void commitFiles(const std::vector<std::string>& filePaths, const std::string& commitMessage) 
{
    loadRepositoryPath();
    fs::path repoPath = fs::weakly_canonical(repositoryPath);
    fs::path versionDir = repoPath / "versions";

    if (repositoryPath.empty() || !fs::exists(versionDir)) {
        std::cerr << "Error: Repository not initialized. Run 'codekeeper init'.\n";
        return;
    }

    // Run pre-commit hook
    if (!runHook(".pre-commit")) {
        std::cerr << "Commit aborted by pre-commit hook.\n";
        return;
    }

    // If no files specified but staging exists and has files, use staged files
    std::vector<std::string> filesToCommit = filePaths;
    fs::path stagingDir = repoPath / ".staging";
    if (fs::exists(stagingDir)) {
        std::vector<std::string> staged = getStagedFiles();
        if (!staged.empty() && filesToCommit.empty()) {
            filesToCommit = staged;
        }
    }

    if (filesToCommit.empty()) {
        std::cerr << "Error: No files specified and no files in staging.\n";
        std::cerr << "Usage: codekeeper commit <message> <file1> [file2 ...] or stage files first.\n";
        return;
    }

    std::ifstream bypassFile(repoPath / ".bypass");
    std::vector<std::string> ignoredFiles;
    std::string line;
    while (std::getline(bypassFile, line)) {
        if (!line.empty() && line[0] != '#') {
            ignoredFiles.push_back(line);
        }
    }

    std::vector<std::string> versionPaths;
    std::vector<std::string> fileHashes;
    // Expand directories to individual files
    std::vector<std::string> expandedFiles;
    for (const auto& fp : filesToCommit) {
        auto collected = collectFiles(fp);
        expandedFiles.insert(expandedFiles.end(), collected.begin(), collected.end());
    }
    for (const auto& filePath : expandedFiles) {
        if (!isPathSafe(filePath)) {
            std::cerr << "Error: File " << filePath << " is outside the repository.\n";
            continue;
        }
        fs::path file = fs::absolute(filePath);

        if (!fs::exists(file)) {
            std::cerr << "Error: File " << file << " does not exist.\n";
            continue;
        }

        if (std::find(ignoredFiles.begin(), ignoredFiles.end(), filePath) != ignoredFiles.end()) {
            std::cout << "Skipping ignored file: " << filePath << "\n";
            continue;
        }

        std::string versionFile = "version_" + std::to_string(std::time(nullptr)) + "_" + file.filename().string();
        fs::path versionFilePath = versionDir / versionFile;

        fs::copy(file, versionFilePath, fs::copy_options::overwrite_existing);
        versionPaths.push_back(versionFilePath.string());
        fileHashes.push_back(computeFileHash(file));
    }

    std::string timestamp = getTimestamp();

    // Use expanded file list for commit, not original paths
    filesToCommit = expandedFiles;

    if (filesToCommit.empty()) {
        std::cerr << "Error: No valid files to commit (all rejected or not found).\n";
        return;
    }

    // Prepare commit content for hashing (includes parent hash for chain integrity)
    std::string parentHash;
    {
        std::ifstream logFile(repoPath / "commit_log.txt");
        std::string lastLine;
        while (std::getline(logFile, lastLine)) {}
        if (!lastLine.empty()) {
            parentHash = split(lastLine, '|')[0];
        }
    }
    std::ostringstream commitContent;
    commitContent << commitMessage << "|" << timestamp;
    if (!parentHash.empty()) commitContent << "|parent=" << parentHash;
    for (size_t i = 0; i < filesToCommit.size(); ++i) {
        commitContent << "|" << fs::absolute(filesToCommit[i]).string() << "|" << fileHashes[i];
    }
    commitContent << "|";
    for (const auto& versionPath : versionPaths) {
        commitContent << versionPath << "|";
    }
    std::string commitID = computeStringHash(commitContent.str());

    std::ofstream logFile(repoPath / "commit_log.txt", std::ios::app);
    logFile << commitID << "|" << escape(commitMessage) << "|" << timestamp;
    for (size_t i = 0; i < filesToCommit.size(); ++i) {
        logFile << "|" << escape(fs::absolute(filesToCommit[i]).string())
                << "|" << fileHashes[i];
    }
    logFile << "|";
    for (const auto& versionPath : versionPaths) {
        logFile << versionPath << "|";
    }
    logFile << "\n";
    logFile.close();
    std::cout << "Files committed successfully with message: " << commitMessage << "\n";

    // Run post-commit hook
    runHook(".post-commit");

    // Clear staging area after commit
    if (fs::exists(stagingDir)) {
        for (const auto& entry : fs::directory_iterator(stagingDir)) {
            fs::remove(entry);
        }
    }
}

// Function to retrieve files by commit message
void retrieveFiles(const std::string& commitMessage) {
    loadRepositoryPath();
    fs::path repoPath = fs::weakly_canonical(repositoryPath);
    fs::path logPath = repoPath / "commit_log.txt";

    if (repositoryPath.empty() || !fs::exists(logPath)) {
        std::cerr << "Error: Repository not initialized or log file missing.\n";
        return;
    }

    std::ifstream logFile(logPath);
    std::string line;

    while (std::getline(logFile, line)) {
        size_t pos1 = line.find('|');
        size_t pos2 = line.find('|', pos1 + 1);
        std::string message = line.substr(pos1 + 1, pos2 - pos1 - 1);

        if (message == escape(commitMessage)) {
            size_t pos3 = line.find('|', pos2 + 1);
            size_t pos4 = line.find_last_of('|');
            std::string fileData = line.substr(pos3 + 1, pos4 - pos3 - 1);
            std::vector<std::string> tokens = split(fileData, '|');
            std::vector<std::string> originalPaths, hashes;

            for (size_t i = 0; i + 1 < tokens.size(); i += 2) {
                originalPaths.push_back(tokens[i]);
                hashes.push_back(tokens[i + 1]);
            }

            size_t half = tokens.size() / 2;
            for (size_t i = 0; i < originalPaths.size(); ++i) {
                fs::path dest = fs::current_path() / fs::path(originalPaths[i]).filename();
                fs::copy(tokens[half + i * 2], dest, fs::copy_options::overwrite_existing);
            }

            std::cout << "Files retrieved successfully.\n";
            return;
        }
    }

    std::cerr << "Error: Commit message not found.\n";
}

// Function for Rollback
void rollback(const std::string &target, const std::string &commitGUID = "")
{
    std::string repopath = getCentralRepositoryPath();
    if (repopath.empty())
    {
        std::cerr << "Error: Repository not initialized. Run 'codekeeper init'.\n";
        return;
    }

    if (!isPathSafe(target)) {
        std::cerr << "Error: Target " << target << " is outside the repository.\n";
        return;
    }

    std::ifstream logFile(repopath + "/commit_log.txt");
    if (!logFile.is_open())
    {
        std::cerr << "Error: Commit log file not found.\n";
        return;
    }

    std::string line, foundVersionPath;
    while (std::getline(logFile, line))
    {
        std::vector<std::string> tokens = split(line, '|');
        if (tokens.size() < 5)
            continue;

        if ((!commitGUID.empty() && tokens[0] == commitGUID) ||
            (commitGUID.empty() && std::find(tokens.begin() + 4, tokens.end(), target) != tokens.end()))
        {
            // Found matching commit or file
            size_t versionIndex = 4 + (tokens.size() - 4) / 2;
            for (size_t i = versionIndex; i < tokens.size(); ++i)
            {
                if (fs::path(tokens[i]).filename() == fs::path(target).filename())
                {
                    foundVersionPath = tokens[i];
                    break;
                }
            }
        }
    }

    if (foundVersionPath.empty())
    {
        std::cerr << "Error: No matching commit or version found for " << target << ".\n";
        return;
    }

    fs::copy(foundVersionPath, target, fs::copy_options::overwrite_existing);
    std::cout << "Rolled back " << target << " to version: " << foundVersionPath << "\n";
}

// Function to check if the repository has been initialized
bool isRepositoryInitialized(const std::string &projectName)
{
    std::string centralOriginPath = "/usr/bin/codekeeper";    // You can change this path if needed
    std::string keepDirectory = centralOriginPath + "/.keep"; // Path to the .keep directory
    std::string repoName = "." + projectName;
    std::string repositoryPath = keepDirectory + "/" + repoName; // Path to the project folder under .keep

    // Check if the .keep directory exists and the project folder is there
    if (fs::exists(keepDirectory) && fs::exists(repositoryPath))
    {
        std::string projectDetailsFile = repositoryPath + "/projectdetails";
        if (fs::exists(projectDetailsFile))
        {
            return true; // Repository is initialized
        }
    }

    return false; // Repository not initialized
}

// Function to create a new branch
void createBranch(const std::string &branchName)
{
    if (repositoryPath.empty())
    {
       loadRepositoryPath();
        if (repositoryPath.empty())
        {
            return;
        }
    }

    std::string branchesPath = repositoryPath + "/branches";
    if (!fs::exists(branchesPath))
    {
        fs::create_directory(branchesPath);
    }

    std::string branchPath = branchesPath + "/" + branchName;
    if (fs::exists(branchPath))
    {
        std::cerr << "Error: Branch '" << branchName << "' already exists.\n";
        return;
    }

    fs::create_directory(branchPath);
    std::cout << "Branch '" << branchName << "' created successfully.\n";
}

// Function to switch branches
void switchBranch(const std::string& branchName)
{
    loadRepositoryPath();
    if (repositoryPath.empty()) {
        std::cerr << "Error: Repository not initialized. Run 'codekeeper init'.\n";
        return;
    }
    std::string branchesPath = repositoryPath + "/branches";
    std::string branchPath = branchesPath + "/" + branchName;
    if (!fs::exists(branchPath) || !fs::is_directory(branchPath)) {
        std::cerr << "Error: Branch '" << branchName << "' does not exist.\n";
        return;
    }
    // Save current branch
    std::ofstream currentBranchFile(repositoryPath + "/.current_branch");
    currentBranchFile << branchName;
    currentBranchFile.close();
    // Copy all files from branch directory to working directory
    for (const auto& entry : fs::directory_iterator(branchPath)) {
        if (fs::is_regular_file(entry)) {
            fs::path dest = fs::current_path() / entry.path().filename();
            fs::copy(entry.path(), dest, fs::copy_options::overwrite_existing);
        }
    }
    std::cout << "Switched to branch '" << branchName << "'.\n";
}

// function to View History
void viewHistory()
{
    loadRepositoryPath();

    if (repositoryPath.empty())
    {
        std::cerr << "Error: Repository not initialized. Run 'codekeeper init'.\n";
        return;
    }

    std::ifstream logFile(repositoryPath + "/commit_log.txt");
    if (!logFile.is_open())
    {
        std::cerr << "Error: Commit log file not found.\n";
        return;
    }

    std::string line;
    while (std::getline(logFile, line))
    {

        // Commit format: GUID|Message|Timestamp|File1|File2|...|VersionPath1|VersionPath2|...
        std::vector<std::string> tokens = split(line, '|');
        if (tokens.size() < 5)
            continue; // Skip malformed entries

        std::cout << "Commit ID: " << tokens[0] << "\n";
        std::cout << "Message: " << tokens[1] << "\n";
        std::cout << "Timestamp: " << tokens[2] << "\n";
        std::cout << "Files:\n";
        for (size_t i = 3; i < tokens.size() - (tokens.size() - 4) / 2; ++i)
        {
            std::cout << "  - " << tokens[i] << "\n";
        }
        std::cout << "------------------------\n";
    }

    logFile.close();
}

// function for Conflict resolution
bool checkConflicts(const std::string &filePath)
{
     loadRepositoryPath();

    if (repositoryPath.empty())
    {
        std::cerr << "Error: Repository not initialized. Run 'codekeeper init'.\n";
        return false;
    }

    std::ifstream logFile(repositoryPath + "/commit_log.txt");
    if (!logFile.is_open())
    {
        std::cerr << "Error: Commit log file not found.\n";
        return false;
    }

    std::string latestVersion;
    std::string line;
    while (std::getline(logFile, line))
    {
        std::vector<std::string> tokens = split(line, '|');
        if (std::find(tokens.begin() + 4, tokens.end(), filePath) != tokens.end())
        {
            size_t versionIndex = 4 + (tokens.size() - 4) / 2;
            for (size_t i = versionIndex; i < tokens.size(); ++i)
            {
                if (fs::path(tokens[i]).filename() == fs::path(filePath).filename())
                {
                    latestVersion = tokens[i];
                    break;
                }
            }
        }
    }

    if (!latestVersion.empty() && fs::exists(filePath))
    {
        // Compare latest version with the current file
        if (!filesAreEqual(filePath, latestVersion))
        {
            std::cerr << "Conflict detected in file: " << filePath << "\n";
            return true;
        }
    }

    return false;
}

void resolveConflict(const std::string &filePath, const std::string &resolutionPath)
{
    fs::copy(resolutionPath, filePath, fs::copy_options::overwrite_existing);
    std::cout << "Conflict resolved for " << filePath << " using " << resolutionPath << "\n";
}

void archiveVersions()
{
    loadRepositoryPath();

    if (repositoryPath.empty())
    {
        std::cerr << "Error: Repository not initialized. Run 'codekeeper init'.\n";
        return;
    }

    std::string versionsPath = fs::path(repositoryPath).string() + "/versions";
    if (!fs::exists(versionsPath))
    {
        std::cerr << "Error: No versions folder found.\n";
        return;
    }

    std::string archiveName = fs::path(repositoryPath).filename().string() + "_archive_" + getTimestamp() + ".zip";
    fs::path archivePath = fs::path(repositoryPath) / archiveName;

    // Use fork+exec instead of system() for safety
    pid_t pid = fork();
    if (pid == 0) {
        execlp("zip", "zip", "-r", archivePath.c_str(), versionsPath.c_str(), nullptr);
        _exit(127);
    } else if (pid > 0) {
        int status;
        waitpid(pid, &status, 0);
        if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
            std::cout << "Archived versions to " << archivePath << "\n";
        } else {
            std::cerr << "Error: Failed to archive versions folder (is 'zip' installed?).\n";
        }
    }
}

// merging files
void mergeFiles(const std::string &file1, const std::string &file2, const std::string &outputPath)
{
    std::ifstream input1(file1);
    std::ifstream input2(file2);
    std::ofstream output(outputPath);

    if (!input1.is_open() || !input2.is_open() || !output.is_open())
    {
        std::cerr << "Error: Unable to open one or more files for merging.\n";
        return;
    }

    std::string line1, line2;
    while (std::getline(input1, line1) || std::getline(input2, line2))
    {
        if (!line1.empty() && !line2.empty() && line1 != line2)
        {
            // Conflict: Append both lines with markers
            output << "<<<<<<< " << file1 << "\n"
                   << line1 << "\n=======\n"
                   << line2 << "\n>>>>>>>\n";
        }
        else
        {
            // No conflict: Append whichever line is available
            output << (!line1.empty() ? line1 : line2) << "\n";
        }
        line1.clear();
        line2.clear();
    }

    input1.close();
    input2.close();
    output.close();
    std::cout << "Merge complete. Output written to: " << outputPath << "\n";
}

// Interactive/manual merge for two files
void interactiveMerge(const std::string& file1, const std::string& file2, const std::string& outputPath) {
    std::ifstream input1(file1);
    std::ifstream input2(file2);
    std::ofstream output(outputPath);
    if (!input1.is_open() || !input2.is_open() || !output.is_open()) {
        std::cerr << "Error: Unable to open one or more files for merging.\n";
        return;
    }
    std::string line1, line2;
    while (true) {
        bool has1 = static_cast<bool>(std::getline(input1, line1));
        bool has2 = static_cast<bool>(std::getline(input2, line2));
        if (!has1 && !has2) break;
        if (has1 && has2 && line1 != line2) {
            std::cout << "Conflict:\n1: " << line1 << "\n2: " << line2 << "\nChoose (1/2/e=edit): ";
            std::string choice;
            std::getline(std::cin, choice);
            if (choice == "1") output << line1 << "\n";
            else if (choice == "2") output << line2 << "\n";
            else {
                std::cout << "Edit> ";
                std::string editLine;
                std::getline(std::cin, editLine);
                output << editLine << "\n";
            }
        } else if (has1) {
            output << line1 << "\n";
        } else if (has2) {
            output << line2 << "\n";
        }
    }
    input1.close();
    input2.close();
    output.close();
    std::cout << "Interactive merge complete. Output written to: " << outputPath << "\n";
}

// merging branches
void mergeBranches(const std::string &branch1, const std::string &branch2)
{
    repositoryPath = getCentralRepositoryPath();

    if (repositoryPath.empty())
    {
        std::cerr << "Error: Central repository not configured.\n";
        return;
    }

    std::string branch1Path = repositoryPath + "/branches/" + branch1;
    std::string branch2Path = repositoryPath + "/branches/" + branch2;

    if (!fs::exists(branch1Path) || !fs::exists(branch2Path))
    {
        std::cerr << "Error: One or both branches do not exist.\n";
        return;
    }

    for (const auto &entry : fs::directory_iterator(branch1Path))
    {
        std::string file1 = entry.path();
        std::string file2 = branch2Path + "/" + fs::path(file1).filename().string();
        if (fs::exists(file2))
        {
            std::string outputFile = branch1Path + "/merged_" + fs::path(file1).filename().string();
            mergeFiles(file1, file2, outputFile);
        }
    }
    std::cout << "Branch merge complete. Resolve conflicts in the merged files if necessary.\n";
}


// User authentication state
std::string currentUser;
bool isAuthenticated = false;

// Hash a password (SHA-256 with salt)
std::string hashPassword(const std::string& username, const std::string& password) {
    return computeStringHash(username + ":" + password);
}

// Register a new user
bool registerUser(const std::string& username, const std::string& password) {
    loadRepositoryPath();
    if (repositoryPath.empty()) return false;
    std::ofstream usersFile(fs::path(repositoryPath) / ".users", std::ios::app);
    if (!usersFile.is_open()) return false;
    usersFile << username << ":" << hashPassword(username, password) << "\n";
    usersFile.close();
    return true;
}

// Load session from .session file
void loadSession() {
    loadRepositoryPath();
    if (repositoryPath.empty()) return;
    std::ifstream sessionFile(fs::path(repositoryPath) / ".session");
    if (sessionFile.is_open()) {
        std::getline(sessionFile, currentUser);
        isAuthenticated = !currentUser.empty();
        sessionFile.close();
    } else {
        currentUser.clear();
        isAuthenticated = false;
    }
}

// Save session to .session file
void saveSession() {
    loadRepositoryPath();
    if (repositoryPath.empty()) return;
    std::ofstream sessionFile(fs::path(repositoryPath) / ".session");
    if (sessionFile.is_open()) {
        sessionFile << currentUser;
        sessionFile.close();
    }
}

// Remove session file
void clearSession() {
    loadRepositoryPath();
    if (repositoryPath.empty()) return;
    fs::remove(fs::path(repositoryPath) / ".session");
}

// Authenticate user
bool authenticateUser(const std::string& username, const std::string& password) {
    loadRepositoryPath();
    if (repositoryPath.empty()) return false;
    std::ifstream usersFile(fs::path(repositoryPath) / ".users");
    if (!usersFile.is_open()) return false;
    std::string line, hash = hashPassword(username, password);
    while (std::getline(usersFile, line)) {
        size_t sep = line.find(":");
        if (sep != std::string::npos) {
            std::string user = line.substr(0, sep);
            std::string pass = line.substr(sep + 1);
            if (user == username && pass == hash) {
                currentUser = username;
                isAuthenticated = true;
                saveSession();
                return true;
            }
        }
    }
    return false;
}

// Logout
void logoutUser() {
    currentUser.clear();
    isAuthenticated = false;
    clearSession();
}

// Require authentication for protected actions
bool requireAuth() {
    loadSession();
    if (!isAuthenticated) {
        std::cerr << "Error: You must authenticate first (run 'codekeeper auth').\n";
        return false;
    }
    return true;
}



// Function to display help message
void displayHelp()
{
    std::cout << "CodeKeeper Help:\n";
    std::cout << "Available Commands:\n";
    std::cout << "  init <name> [--local]     Initialize a new repository (--local creates in current dir).\n";
    std::cout << "  add [files]               Add files to staging area.\n";
    std::cout << "  reset [files]             Remove files from staging area.\n";
    std::cout << "  status                    Show status of working directory and staging area.\n";
    std::cout << "  commit [message] [files]  Commit specified files or directories (if staging is empty).\n";
    std::cout << "                            Use '*.*' or '.' to commit all files.\n";
    std::cout << "  rollback [target] [file|guid] Revert a file or repository to a specific version.\n";
    std::cout << "  history                   View commit history.\n";
    std::cout << "  conflicts [file]          Check for conflicts in a file.\n";
    std::cout << "  resolve [file] [res]      Resolve a conflict with the specified resolution file.\n";
    std::cout << "  archive                   Archive the .versions folder.\n";
    std::cout << "  auth                      Authenticate a user.\n";
    std::cout << "  branch [name]             Create a new branch.\n";
    std::cout << "  merge [branch1 branch2]   Merge changes from two branches.\n";
    std::cout << "  switch [branch]           Switch to a different branch.\n";
    std::cout << "  set-remote <path>          Set the remote repository path.\n";
    std::cout << "  push                       Push commits and versions to remote.\n";
    std::cout << "  pull                       Pull commits and versions from remote.\n";
    std::cout << "  list-conflicts              List all files with conflicts.\n";
    std::cout << "  whoami                      Show current authenticated user.\n";
    std::cout << "  list-users                  List all registered users.\n";
    std::cout << "  merge-files <f1> <f2> <out> [--interactive]  Merge two files, optionally interactively.\n";
    std::cout << "  serve [port] [--dir <path>]  Start web interface.\n";
    std::cout << "\nAuthentication:\n";
    std::cout << "  Users must authenticate using a valid username and password.\n";
    std::cout << "  Only authenticated users can commit, rollback, or resolve conflicts.\n";
    std::cout << "\nFor more details, consult the documentation.\n";
}

// Function to show status of files (staged, modified, untracked)
void status() {
    loadRepositoryPath();
    if (repositoryPath.empty()) {
        std::cerr << "Error: Repository not initialized. Run 'codekeeper init'.\n";
        return;
    }
    fs::path stagingDir = fs::path(repositoryPath) / ".staging";
    std::vector<std::string> stagedFiles = getStagedFiles();
    std::set<std::string> stagedSet;
    for (const auto& f : stagedFiles) stagedSet.insert(fs::path(f).filename().string());

    // Get all files in working directory (excluding hidden and repo files)
    std::vector<std::string> workingFiles;
    for (const auto& entry : fs::directory_iterator(fs::current_path())) {
        if (fs::is_regular_file(entry)) {
            std::string fname = entry.path().filename().string();
            if (fname[0] == '.' || fname == "commit_log.txt" || fname == "codekeeper.cpp" || fname == "codekeeper.exe") continue;
            workingFiles.push_back(fname);
        }
    }

    // Get last committed files
    std::vector<std::string> lastCommitted;
    fs::path logPath = fs::path(repositoryPath) / "commit_log.txt";
    if (fs::exists(logPath)) {
        std::ifstream logFile(logPath);
        std::string line;
        while (std::getline(logFile, line)) {
            // Only use last line
        }
        if (!line.empty()) {
            std::vector<std::string> tokens = split(line, '|');
            // Files start at index 3, every other token is a file path
            for (size_t i = 3; i < tokens.size() - (tokens.size() - 4) / 2; i += 2) {
                lastCommitted.push_back(fs::path(tokens[i]).filename().string());
            }
        }
    }
    std::set<std::string> committedSet(lastCommitted.begin(), lastCommitted.end());

    // Print status
    std::cout << "Staged files:\n";
    for (const auto& f : stagedSet) std::cout << "  " << f << "\n";
    std::cout << "\nModified files:\n";
    for (const auto& f : workingFiles) {
        if (committedSet.count(f) && !stagedSet.count(f)) {
            // Compare with last committed version
            // Find version path from log
            std::ifstream logFile(logPath);
            std::string line, versionPath;
            while (std::getline(logFile, line)) {}
            if (!line.empty()) {
                std::vector<std::string> tokens = split(line, '|');
                for (size_t i = 3; i < tokens.size() - (tokens.size() - 4) / 2; i += 2) {
                    if (fs::path(tokens[i]).filename().string() == f) {
                        size_t half = 3 + (tokens.size() - 4) / 2;
                        versionPath = tokens[half + (i - 3)];
                        break;
                    }
                }
            }
            if (!versionPath.empty() && !filesAreEqual(f, versionPath)) {
                std::cout << "  " << f << "\n";
            }
        }
    }
    std::cout << "\nUntracked files:\n";
    for (const auto& f : workingFiles) {
        if (!committedSet.count(f) && !stagedSet.count(f)) {
            std::cout << "  " << f << "\n";
        }
    }
}

// Remote repository path management
std::string getRemotePath() {
    std::ifstream f(fs::path(repositoryPath) / ".remote");
    std::string remote;
    if (f.is_open()) std::getline(f, remote);
    return remote;
}
void setRemotePath(const std::string& remotePath) {
    std::ofstream f(fs::path(repositoryPath) / ".remote");
    f << remotePath;
}

// Push local commits and versions to remote
void pushToRemote() {
    loadRepositoryPath();
    if (repositoryPath.empty()) {
        std::cerr << "Error: Repository not initialized.\n";
        return;
    }
    std::string remote = getRemotePath();
    if (remote.empty()) {
        std::cerr << "Error: No remote set. Use 'set-remote <path>'.\n";
        return;
    }
    // Copy commit_log.txt
    fs::copy(fs::path(repositoryPath) / "commit_log.txt", fs::path(remote) / "commit_log.txt", fs::copy_options::overwrite_existing);
    // Copy versions directory
    fs::path localVersions = fs::path(repositoryPath) / "versions";
    fs::path remoteVersions = fs::path(remote) / "versions";
    if (!fs::exists(remoteVersions)) fs::create_directories(remoteVersions);
    for (const auto& entry : fs::directory_iterator(localVersions)) {
        if (fs::is_regular_file(entry)) {
            fs::copy(entry, remoteVersions / entry.path().filename(), fs::copy_options::overwrite_existing);
        }
    }
    std::cout << "Push to remote complete.\n";
}

// Pull commits and versions from remote
void pullFromRemote() {
    loadRepositoryPath();
    if (repositoryPath.empty()) {
        std::cerr << "Error: Repository not initialized.\n";
        return;
    }
    std::string remote = getRemotePath();
    if (remote.empty()) {
        std::cerr << "Error: No remote set. Use 'set-remote <path>'.\n";
        return;
    }
    // Copy commit_log.txt
    fs::copy(fs::path(remote) / "commit_log.txt", fs::path(repositoryPath) / "commit_log.txt", fs::copy_options::overwrite_existing);
    // Copy versions directory
    fs::path localVersions = fs::path(repositoryPath) / "versions";
    fs::path remoteVersions = fs::path(remote) / "versions";
    if (!fs::exists(localVersions)) fs::create_directories(localVersions);
    for (const auto& entry : fs::directory_iterator(remoteVersions)) {
        if (fs::is_regular_file(entry)) {
            fs::copy(entry, localVersions / entry.path().filename(), fs::copy_options::overwrite_existing);
        }
    }
    std::cout << "Pull from remote complete.\n";
}

// List all files with conflicts (differs from last committed version)
void listConflicts() {
    loadRepositoryPath();
    if (repositoryPath.empty()) {
        std::cerr << "Error: Repository not initialized.\n";
        return;
    }
    fs::path logPath = fs::path(repositoryPath) / "commit_log.txt";
    if (!fs::exists(logPath)) {
        std::cerr << "Error: No commit log found.\n";
        return;
    }
    std::vector<std::string> lastCommitted;
    std::ifstream logFile(logPath);
    std::string line;
    while (std::getline(logFile, line)) {}
    if (!line.empty()) {
        std::vector<std::string> tokens = split(line, '|');
        for (size_t i = 3; i < tokens.size() - (tokens.size() - 4) / 2; i += 2) {
            lastCommitted.push_back(fs::path(tokens[i]).filename().string());
        }
    }
    std::set<std::string> conflicts;
    for (const auto& f : lastCommitted) {
        std::ifstream logFile2(logPath);
        std::string line2, versionPath;
        while (std::getline(logFile2, line2)) {}
        if (!line2.empty()) {
            std::vector<std::string> tokens = split(line2, '|');
            for (size_t i = 3; i < tokens.size() - (tokens.size() - 4) / 2; i += 2) {
                if (fs::path(tokens[i]).filename().string() == f) {
                    size_t half = 3 + (tokens.size() - 4) / 2;
                    versionPath = tokens[half + (i - 3)];
                    break;
                }
            }
        }
        if (!versionPath.empty() && fs::exists(f) && !filesAreEqual(f, versionPath)) {
            conflicts.insert(f);
        }
    }
    if (conflicts.empty()) {
        std::cout << "No conflicts detected.\n";
    } else {
        std::cout << "Conflicting files:\n";
        for (const auto& f : conflicts) std::cout << "  " << f << "\n";
    }
}

// Entry point for CodeKeeper CLI
int main(int argc, char* argv[]) {
    if (argc < 2) {
        displayHelp();
        return 1;
    }
    std::string cmd = argv[1];
    if (cmd == "init") {
        if (argc < 3) {
            std::cerr << "Usage: codekeeper init <projectName> [--local]\n";
            return 1;
        }
        bool local = (argc > 3 && std::string(argv[3]) == "--local");
        initRepository(argv[2], local);
    } else if (cmd == "auth") {
        if (argc < 3) {
            std::cerr << "Usage: codekeeper auth <register|login|logout> [username] [password]\n";
            return 1;
        }
        std::string subcmd = argv[2];
        if (subcmd == "register") {
            if (argc < 5) {
                std::cerr << "Usage: codekeeper auth register <username> <password>\n";
                return 1;
            }
            if (registerUser(argv[3], argv[4])) {
                std::cout << "User registered: " << argv[3] << "\n";
            } else {
                std::cerr << "Error: Could not register user.\n";
            }
        } else if (subcmd == "login") {
            if (argc < 5) {
                std::cerr << "Usage: codekeeper auth login <username> <password>\n";
                return 1;
            }
            if (authenticateUser(argv[3], argv[4])) {
                std::cout << "Authenticated as " << argv[3] << "\n";
            } else {
                std::cerr << "Error: Authentication failed.\n";
            }
        } else if (subcmd == "logout") {
            logoutUser();
            std::cout << "Logged out.\n";
        } else {
            std::cerr << "Unknown auth subcommand.\n";
        }
    } else if (cmd == "commit") {
        if (!requireAuth()) return 1;
        if (argc < 3) {
            std::cerr << "Usage: codekeeper commit <message> [file1 file2 ...]" << std::endl;
            return 1;
        }
        std::string message = argv[2];
        std::vector<std::string> files;
        for (int i = 3; i < argc; ++i) files.push_back(argv[i]);
        commitFiles(files, message);
    } else if (cmd == "add") {
        if (argc < 3) {
            std::cerr << "Usage: codekeeper add <file1> [file2 ...]" << std::endl;
            return 1;
        }
        std::vector<std::string> files;
        for (int i = 2; i < argc; ++i) files.push_back(argv[i]);
        addToStaging(files);
    } else if (cmd == "reset") {
        if (argc < 3) {
            std::cerr << "Usage: codekeeper reset <file1> [file2 ...]" << std::endl;
            return 1;
        }
        std::vector<std::string> files;
        for (int i = 2; i < argc; ++i) files.push_back(argv[i]);
        resetStaging(files);
    } else if (cmd == "status") {
        status();
    } else if (cmd == "history") {
        viewHistory();
    } else if (cmd == "rollback") {
        if (!requireAuth()) return 1;
        if (argc < 3) {
            std::cerr << "Usage: codekeeper rollback <file|guid> [commitGUID]" << std::endl;
            return 1;
        }
        std::string target = argv[2];
        std::string guid = (argc > 3) ? argv[3] : "";
        rollback(target, guid);
    } else if (cmd == "conflicts") {
        if (argc < 3) {
            std::cerr << "Usage: codekeeper conflicts <file>" << std::endl;
            return 1;
        }
        checkConflicts(argv[2]);
    } else if (cmd == "resolve") {
        if (!requireAuth()) return 1;
        if (argc < 4) {
            std::cerr << "Usage: codekeeper resolve <file> <resolutionFile>" << std::endl;
            return 1;
        }
        resolveConflict(argv[2], argv[3]);
    } else if (cmd == "archive") {
        archiveVersions();
    } else if (cmd == "branch") {
        if (argc < 3) {
            std::cerr << "Usage: codekeeper branch <name>" << std::endl;
            return 1;
        }
        createBranch(argv[2]);
    } else if (cmd == "merge") {
        if (argc < 4) {
            std::cerr << "Usage: codekeeper merge <branch1> <branch2>" << std::endl;
            return 1;
        }
        mergeBranches(argv[2], argv[3]);
    } else if (cmd == "switch") {
        if (argc < 3) {
            std::cerr << "Usage: codekeeper switch <branch>" << std::endl;
            return 1;
        }
        switchBranch(argv[2]);
    } else if (cmd == "set-remote") {
        if (argc < 3) {
            std::cerr << "Usage: codekeeper set-remote <path>" << std::endl;
            return 1;
        }
        setRemotePath(argv[2]);
        std::cout << "Remote set to: " << argv[2] << std::endl;
    } else if (cmd == "push") {
        pushToRemote();
    } else if (cmd == "pull") {
        pullFromRemote();
    } else if (cmd == "list-conflicts") {
        listConflicts();
    } else if (cmd == "whoami") {
        loadSession();
        if (isAuthenticated) std::cout << currentUser << std::endl;
        else std::cout << "Not authenticated." << std::endl;
    } else if (cmd == "list-users") {
        loadRepositoryPath();
        if (repositoryPath.empty()) {
            std::cerr << "Error: Repository not initialized.\n";
            return 1;
        }
        std::ifstream usersFile(fs::path(repositoryPath) / ".users");
        std::string line;
        while (std::getline(usersFile, line)) {
            size_t sep = line.find(":");
            if (sep != std::string::npos) std::cout << line.substr(0, sep) << std::endl;
        }
    } else if (cmd == "merge-files") {
        if (argc < 5) {
            std::cerr << "Usage: codekeeper merge-files <file1> <file2> <output> [--interactive]" << std::endl;
            return 1;
        }
        if (argc > 5 && std::string(argv[5]) == "--interactive") {
            interactiveMerge(argv[2], argv[3], argv[4]);
        } else {
            mergeFiles(argv[2], argv[3], argv[4]);
        }
    } else if (cmd == "serve") {
        // Launch web server binary
        fs::path exePath = fs::absolute(argv[0]);
        fs::path webExe = exePath.parent_path() / "codekeeper-web";
        if (!fs::exists(webExe)) {
            webExe = exePath.parent_path() / "build/codekeeper-web";
        }
        if (!fs::exists(webExe)) {
            std::cerr << "Error: codekeeper-web not found. Build it with: g++ -std=c++17 -Iinclude -o build/codekeeper-web codekeeper-web.cpp -lssl -lcrypto -lpthread" << std::endl;
            return 1;
        }
        std::string port = (argc > 2) ? argv[2] : "8080";
        if (port == "--help" || port == "-h") {
            std::cout << "Usage: codekeeper serve [port]" << std::endl;
            std::cout << "  port   HTTP port (default: 8080)" << std::endl;
            return 0;
        }
        // Ensure web directory is accessible
        fs::path webDir = exePath.parent_path() / "web";
        if (!fs::exists(webDir / "index.html")) {
            webDir = exePath.parent_path().parent_path() / "web";
        }
        if (!fs::exists(webDir / "index.html")) {
            // Try CWD/web
            webDir = fs::current_path() / "web";
        }
        if (fs::exists(webDir / "index.html")) {
            std::cout << "Starting CodeKeeper Web Server..." << std::endl;
            std::cout << "Open http://localhost:" << port << " in your browser." << std::endl;
            std::cout << "Press Ctrl+C to stop." << std::endl << std::endl;
            // Use exec to replace process, passing --web and --dir
            execlp(webExe.c_str(), webExe.c_str(),
                port.c_str(),
                "--dir", fs::current_path().c_str(),
                "--web", webDir.c_str(),
                nullptr);
            // If exec fails, fall back to system()
            std::cerr << "Error: Failed to launch web server." << std::endl;
            return 1;
        } else {
            std::cerr << "Error: web/index.html not found. Run from the CodeKeeper project directory." << std::endl;
            std::cerr << "Alternatively, run: codekeeper-web <port> --web <path-to-web-dir>" << std::endl;
            return 1;
        }
    } else {
        displayHelp();
    }
    return 0;
}