Training-Team2-Zenvy-Jan26/Trenser.Zenvy/Trenser.Zenvy/utilities/Timestamp.cpp

/*
 * File: Timestamp.cpp
 * Description: Provides a utility class for representing and manipulating time values.
 *              Supports conversion between string and time formats, duration calculations
 *              (hours, minutes, seconds), date extraction, and comparison operators.
 * Author: Trenser
 * Created: 01-Apr-2026
 */
#include <sstream>
#include <iomanip>
#include <stdexcept>
#include "Timestamp.h"

 /*
 * Function: Timestamp
 * Description: Default constructor that initializes the timestamp to the current system time.
 * Parameters:
 *    None
 * Returns:
 *    Timestamp object
 */
util::Timestamp::Timestamp()
{
    m_time = std::time(nullptr);
}

/*
* Function: Timestamp (overloaded)
* Description: Constructor that initializes the timestamp with a given time value.
* Parameters:
*    timeValue - time_t value representing a specific time
* Returns:
*    Timestamp object
*/
util::Timestamp::Timestamp(std::time_t timeValue)
{
    m_time = timeValue;
}

/*
* Function: fromString
* Description: Creates a Timestamp object from a formatted string.
* Parameters:
*    timeString - string in the format "YYYY-MM-DD HH:MM:SS"
* Returns:
*    Timestamp object representing the parsed time
* Throws:
*    runtime_error if the string format is invalid
*/
util::Timestamp util::Timestamp::fromString(const std::string& timeString)
{
    std::tm timeStruct = {};
    std::istringstream inputStream(timeString);
    inputStream >> std::get_time(&timeStruct, "%Y-%m-%d %H:%M:%S");
    if (inputStream.fail())
    {
        throw std::runtime_error("Invalid time format");
    }
    std::time_t parsedTimestamp = std::mktime(&timeStruct);
    return Timestamp(parsedTimestamp);
}

/*
* Function: toString
* Description: Converts the Timestamp object into a formatted string.
* Parameters:
*    None
* Returns:
*    string - formatted as "YYYY-MM-DD HH:MM:SS"
*/
std::string util::Timestamp::toString() const
{
    std::tm timeStruct = {};
    localtime_s(&timeStruct, &m_time);
    std::ostringstream outputStream;
    outputStream << std::put_time(&timeStruct, "%Y-%m-%d %H:%M:%S");
    return outputStream.str();
}

/*
* Function: getDurationInSeconds
* Description: Calculates the duration between two timestamps in seconds.
* Parameters:
*    startTimestamp - starting time
*    endTimestamp - ending time
* Returns:
*    double - duration in seconds
*/
double util::Timestamp::getDurationInSeconds(const Timestamp& startTimestamp, const Timestamp& endTimestamp)
{
    return std::difftime(endTimestamp.m_time, startTimestamp.m_time);
}

/*
* Function: getDateAsInt
* Description: Returns the date portion of the timestamp as an integer in YYYYMMDD format.
* Parameters:
*    None
* Returns:
*    int - date as YYYYMMDD
*/
int util::Timestamp::getDateAsInt() const
{
    std::tm timeStruct{};
    localtime_s(&timeStruct, &m_time);
    int year = timeStruct.tm_year + 1900;
    int month = timeStruct.tm_mon + 1;
    int day = timeStruct.tm_mday;
    return year * 10000 + month * 100 + day;
}

/*
* Function: getMonth
* Description: Extracts the month value from the timestamp.
* Parameters:
*    None
* Returns:
*    int - month value (1 to 12)
*/
int util::Timestamp::getMonth() const
{
    std::tm timeStruct{};
    localtime_s(&timeStruct, &m_time);
    return timeStruct.tm_mon + 1;
}

/*
* Function: getYear
* Description: Extracts the year value from the timestamp.
* Parameters:
*    None
* Returns:
*    int - year value
*/
int util::Timestamp::getYear() const
{
    std::tm timeStruct{};
    localtime_s(&timeStruct, &m_time);
    return timeStruct.tm_year + 1900;
}

/*
* Function: getDay
* Description: Extracts the day value from the timestamp.
* Parameters:
*    None
* Returns:
*    int - day of the month
*/
int util::Timestamp::getDay() const
{
    std::tm timeStruct{};
    localtime_s(&timeStruct, &m_time);
    return timeStruct.tm_mday;
}

/*
* Function: getDurationInMinutes
* Description: Calculates the duration between two timestamps in minutes.
* Parameters:
*    startTimestamp - starting time
*    endTimestamp - ending time
* Returns:
*    double - duration in minutes
*/
double util::Timestamp::getDurationInMinutes(const Timestamp& startTimestamp, const Timestamp& endTimestamp)
{
    return getDurationInSeconds(startTimestamp, endTimestamp) / 60.0;
}

/*
* Function: getDurationInHours
* Description: Calculates the duration between two timestamps in hours.
* Parameters:
*    startTimestamp - starting time
*    endTimestamp - ending time
* Returns:
*    double - duration in hours
*/
double util::Timestamp::getDurationInHours(const Timestamp& startTimestamp, const Timestamp& endTimestamp)
{
    return getDurationInSeconds(startTimestamp, endTimestamp) / 3600.0;
}

/*
* Function: operator<
* Description: Compares two timestamps to check if one is earlier than the other.
* Parameters:
*    other - Timestamp to compare against
* Returns:
*    bool - true if current timestamp is earlier
*/
bool util::Timestamp::operator<(const Timestamp& other) const
{
    return m_time < other.m_time;
}

/*
* Function: operator>
* Description: Compares two timestamps to check if one is later than the other.
* Parameters:
*    other - Timestamp to compare against
* Returns:
*    bool - true if current timestamp is later
*/
bool util::Timestamp::operator>(const Timestamp& other) const
{
    return m_time > other.m_time;
}

/*
* Function: operator<=
* Description: Compares two timestamps to check if one is earlier or equal.
* Parameters:
*    other - Timestamp to compare against
* Returns:
*    bool - true if current timestamp is earlier or equal
*/
bool util::Timestamp::operator<=(const Timestamp& other) const
{
    return m_time <= other.m_time;
}

/*
* Function: operator>=
* Description: Compares two timestamps to check if one is later or equal.
* Parameters:
*    other - Timestamp to compare against
* Returns:
*    bool - true if current timestamp is later or equal
*/
bool util::Timestamp::operator>=(const Timestamp& other) const
{
    return m_time >= other.m_time;
}

/*
* Function: operator==
* Description: Compares two timestamps for equality.
* Parameters:
*    other - Timestamp to compare against
* Returns:
*    bool - true if both timestamps are equal
*/
bool util::Timestamp::operator==(const Timestamp& other) const
{
    return m_time == other.m_time;
}