#include "watchdog.h"

namespace fs = std::filesystem; //makes it easier to read
void WatchDog::start()
{
    //checks if file exist
    if(!fs::exists(path))
    {
        //returns and sets parameters to false if file doesnt exist
        watching = false;
        hasInitialTime = false;
        std::cout << "WatchDog: File does not exists: " << path << std::endl;
        return;
    }
    //grabs intial write time
    lastWriteTime = fs::last_write_time(path);
    watching = true;
    hasInitialTime = true;
    std::cout << "WatchDog: Started" << std::endl;
}
void WatchDog::stop(){
    watching = false;
}
bool WatchDog::checkFile(){
    //If not watching returns false
    if (!watching) return false;

    //Checking if file was deleted
    if(!fs::exists(path))
    {
        if (hasInitialTime) {
            std::cout << "WatchDog: File was delete: " << path << std::endl;
            hasInitialTime = false;
            return true;
        }
        return false;
    }
    
    //Built in function with file system to check last write tim
    fs::file_time_type currentWriteTime = fs::last_write_time(path);

    //File was just created
    if(!hasInitialTime)
    {
        lastWriteTime = currentWriteTime;
        hasInitialTime = true;
        std::cout << "WatchDog: File created: " << path << std::endl;
        return true;
    }

    //File modified
    if (currentWriteTime != lastWriteTime)
    {
        lastWriteTime = currentWriteTime;
        std::cout << "WatchDog: File modifed at " 
                  << timePointToString(lastWriteTime) << std::endl;
        return true;      
    }

    } catch (const fs::filesystem_error& e) {
        // File deleted, inaccessible, or path invalid
        if (hasInitialTime) {
            std::cout << "WatchDog: File deleted or inaccessible: " << path << std::endl;
            hasInitialTime = false;
            return true;
        }
        return false;

    } catch (const std::exception& e) {
        std::cerr << "WatchDog: Unexpected error checking file: " << e.what() << std::endl;
        return false;
    }

    // No change
    return false;
}

std::string Watchdog::TimePointToString(const fs::file_time_type& timePoint){
    /** 
     * Step 1: timePoint
     *   - This is the last write time of the file, returned by std::filesystem.
     *   - Its clock is platform-dependent (filesystem clock).
     *
     * Step 2: fs::file_time_type::clock::now()
     *   - Current time according to the filesystem clock.
     *
     * Step 3: std::chrono::system_clock::now()
     *   - Current time according to the system clock (standard C++ clock).
     *
     * Conversion formula:
     *   timePoint - fs::file_time_type::clock::now() + std::chrono::system_clock::now()
     *
     * Explanation:
     *   a) timePoint - fs::file_time_type::clock::now()
     *      - Calculates the duration between the file's last write time and "now"
     *        according to the filesystem clock.
     *   b) + std::chrono::system_clock::now()
     *      - Shifts that duration to align with the system clock timeline.
     *   c) std::chrono::time_point_cast<std::chrono::system_clock::duration>(...)
     *      - Ensures the resulting time_point uses the correct duration type
     *        for std::chrono::system_clock.
     *
     * Result:
     *   - systemTime is a std::chrono::system_clock::time_point representing
     *     the same instant as timePoint, but compatible with system_clock.
     */
    std::chrono::system_clock::time_point systemTimePoint =
        std::chrono::time_point_cast<std::chrono::system_clock::duration>(
            timePoint - fs::file_time_type::clock::now() + std::chrono::system_clock::now()
        );
    
    //Converts to seconds
    std::time_t timeInSeconds = std::chrono::system_clock::to_time_t(systemTimePoint);

    //Converts to local time, built in function
    std::tm localTime = *std::localtime(&timeInSeconds);

    // Format the time into a string using strftime
    char buffer[20]; 
    std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &localTime);

    return std::string(buffer);
}