#pragma once

#include "DateObject.h"
#include "TimeObject.h"
#include "ByteArrayProvider.h"

namespace Incart::Common
{

struct DateTimeObject
{
    DateObject date;
    TimeObject time;

    DateTimeObject()
    {
    }

    DateTimeObject(const DateObject& date, const TimeObject& time) : date(date), time(time)
    {
    }

    DateTimeObject(uint32_t year_, uint8_t month_, uint8_t day_, uint8_t hours_, uint8_t minutes_, uint8_t seconds_)
      : date(day_, month_, year_)
      , time(hours_, minutes_, seconds_)
    {
    }

public:
    bool isDefault() const
    {
        return date.isDefault() && time.isDefault();
    }

    // format: yyyy.MM.dd hh:mm:ss
    static DateTimeObject fromString(const std::string& dateTimeText_)
    {
        if (dateTimeText_.size() != 19)
        {
          return DateTimeObject{};
        }
        std::string dateText = dateTimeText_.substr(0, 10);
        std::string timeText = dateTimeText_.substr(11, 8);
        return DateTimeObject{ DateObject::fromString(dateText), TimeObject::fromString(timeText) };
    }

    static std::vector<uint8_t> packToDevice(DateTimeObject dateTime_)
    {
        if (dateTime_.isDefault())
        {
            return { 0, 0, 0, 0 };
        }

        uint32_t year = dateTime_.date.getYear();

        if (year < 2000 || year > 2099)
        {
            throw new std::logic_error("is not correct year");
        }

        uint8_t month = dateTime_.date.getMonth();
        uint8_t day = dateTime_.date.getDay();
        uint32_t startTime = static_cast<uint32_t>((year - 2000) * 12 * 31 * 24 * 60 * 60
          + (month - 1) * 31 * 24 * 60 * 60 + (day - 1) * 24 * 60 * 60
          + dateTime_.time.getHours() * 60 * 60 + dateTime_.time.getMinutes() * 60
          + dateTime_.time.getSeconds());
        std::vector<uint8_t> data;
        Common::ByteArrayProvider::addDWord(startTime, data);
        return data;
    }

    static DateTimeObject unpackFromDevice(std::vector<uint8_t> data_)
    {
        const int daySeconds = 24 * 60 * 60;
        uint32_t startTime = Common::ByteArrayProvider::getDWordFromArray(&data_[0], data_.size(), 0);
        if (startTime == 0)
        {
          return DateTimeObject{};
        }

        uint32_t year = static_cast<uint32_t>(startTime / (12 * 31 * daySeconds) + 2000);
        uint8_t month = static_cast<uint8_t>((startTime % (12 * 31 * daySeconds)) / (31 * daySeconds) + 1);
        uint8_t day = static_cast<uint8_t>((startTime % (31 * daySeconds)) / daySeconds + 1);
        uint32_t seconds = static_cast<uint32_t>(startTime % daySeconds);

        uint8_t hour = seconds / (60 * 60);
        uint8_t minutes = (seconds % (60 * 60)) / 60;
        seconds = seconds % 60;

        return DateTimeObject{year, month, day, hour, minutes, static_cast<uint8_t>(seconds)};
    }
};

} // namespace Incart::Common