#include "utils/hash.hpp"

#define XXH_INLINE_ALL
#include "contrib/xxhash.hpp"

#include <fstream>
#include <filesystem>
#include <iostream>

namespace dropshell {

uint64_t hash_file(const std::string &path) {
    // Create hash state
    XXH64_state_t* const state = XXH64_createState();
    if (state == nullptr) {
        std::cerr << "Failed to create hash state" << std::endl;
        return 0;
    }

    // Initialize state with seed 0
    XXH64_hash_t const seed = 0;   /* or any other value */
    if (XXH64_reset(state, seed) == XXH_ERROR) return 0;

    // Open file
    std::ifstream file(path, std::ios::binary);
    if (!file.is_open()) {
        std::cerr << "Failed to open file: " << path << std::endl;
        XXH64_freeState(state);
        return 0;
    }

    // Read file in chunks and update hash
    const size_t buffer_size = 4096;
    char buffer[buffer_size];
    while (file.read(buffer, buffer_size)) {
        if (XXH64_update(state, buffer, file.gcount()) == XXH_ERROR) {
            std::cerr << "Failed to update hash" << std::endl;
            XXH64_freeState(state);
            return 0;
        }
    }

    // Handle any remaining bytes
    if (file.gcount() > 0) {
        if (XXH64_update(state, buffer, file.gcount()) == XXH_ERROR) {
            std::cerr << "Failed to update hash" << std::endl;
            XXH64_freeState(state);
            return 0;
        }
    }

    // Get final hash
    XXH64_hash_t hash = XXH64_digest(state);
    XXH64_freeState(state);
    return hash;
}

uint64_t hash_directory_recursive(const std::string &path) {
    // Create hash state
    XXH64_state_t* const state = XXH64_createState();
    if (state == nullptr) {
        std::cerr << "Failed to create hash state" << std::endl;
        return 0;
    }

    // Initialize state with seed 0
    XXH64_hash_t const seed = 0;   /* or any other value */
    if (XXH64_reset(state, seed) == XXH_ERROR) {
        std::cerr << "Failed to reset hash state" << std::endl;
        XXH64_freeState(state);
        return 0;
    }

    try {
        // Iterate through all files in directory recursively
        for (const auto& entry : std::filesystem::recursive_directory_iterator(path)) {
            if (entry.is_regular_file()) {
                // Get file hash
                XXH64_hash_t file_hash = hash_file(entry.path().string());
                XXH64_update(state, &file_hash, sizeof(file_hash));
            }
        }
    } catch (const std::filesystem::filesystem_error& e) {
        std::cerr << "Filesystem error: " << e.what() << std::endl;
        XXH64_freeState(state);
        return 0;
    }

    // Get final hash
    XXH64_hash_t hash = XXH64_digest(state);
    XXH64_freeState(state);
    return hash;
}

uint64_t hash_path(const std::string &path) {
    if (!std::filesystem::exists(path)) {
        std::cerr << "Path does not exist: " << path << std::endl;
        return 0;
    }

    if (std::filesystem::is_directory(path)) {
        return hash_directory_recursive(path);
    } else if (std::filesystem::is_regular_file(path)) {
        return hash_file(path);
    } else {
        std::cerr << "Path is neither a file nor a directory: " << path << std::endl;
        return 0;
    }
}

void hash_demo(const std::string & path)
{
    std::cout << "Hashing path: " << path << std::endl;
    auto start = std::chrono::high_resolution_clock::now();
    XXH64_hash_t hash = hash_path(path);
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "Hash: " << hash << " (took " << duration.count() << "ms)" << std::endl;
}

int hash_demo_raw(const std::string & path)
{
    if (!std::filesystem::exists(path)) {
        std::cout << 0 <<std::endl; return 1;
    }
    XXH64_hash_t hash = hash_path(path);
    std::cout << hash << std::endl;
    return 0;
}

} // namespace dropshell