#include "firmware_info.h"

static const char months[12][4] = {
    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};

static int is_digit(char value) { return (value >= '0') && (value <= '9'); }

static int two_digits(const char *text, uint8_t *result)
{
    char high = text[0];
    char low = text[1];
    if (high == ' ') high = '0';
    if (!is_digit(high) || !is_digit(low)) return 0;
    *result = (uint8_t)(((uint8_t)(high - '0') * 10U) + (uint8_t)(low - '0'));
    return 1;
}

static int four_digits(const char *text, uint16_t *result)
{
    uint16_t value = 0U;
    uint8_t i;
    for (i = 0U; i < 4U; ++i) {
        if (!is_digit(text[i])) return 0;
        value = (uint16_t)(value * 10U + (uint16_t)(text[i] - '0'));
    }
    *result = value;
    return 1;
}

firmware_info_status_t firmware_info_validate(const firmware_info_t *info)
{
    uint8_t i;
    if (info == NULL) return FIRMWARE_INFO_INVALID_ARGUMENT;
    if ((info->major > 255U) || (info->minor > 255U) || (info->patch > 999U)
        || (info->year < 2000U) || (info->year > 2199U)
        || (info->month < 1U) || (info->month > 12U)
        || (info->day < 1U) || (info->day > 31U)
        || (info->hour > 23U) || (info->minute > 59U) || (info->second > 59U)) {
        return FIRMWARE_INFO_OUT_OF_RANGE;
    }
    for (i = 0U; i < FIRMWARE_INFO_BUILD_ID_SIZE; ++i) {
        if ((info->build_id[i] < 0x20) || (info->build_id[i] > 0x7e))
            return FIRMWARE_INFO_OUT_OF_RANGE;
    }
    return FIRMWARE_INFO_OK;
}

firmware_info_status_t firmware_info_set_build_id(firmware_info_t *info,
                                                   const char *build_id)
{
    uint8_t i;
    if ((info == NULL) || (build_id == NULL)) return FIRMWARE_INFO_INVALID_ARGUMENT;
    for (i = 0U; i < FIRMWARE_INFO_BUILD_ID_SIZE && build_id[i] != '\0'; ++i) {
        if ((build_id[i] < 0x20) || (build_id[i] > 0x7e))
            return FIRMWARE_INFO_OUT_OF_RANGE;
        info->build_id[i] = build_id[i];
    }
    for (; i < FIRMWARE_INFO_BUILD_ID_SIZE; ++i) info->build_id[i] = '0';
    info->build_id[FIRMWARE_INFO_BUILD_ID_SIZE] = '\0';
    return FIRMWARE_INFO_OK;
}

firmware_info_status_t firmware_info_parse_build_stamp(
    const char *date_text, const char *time_text, firmware_info_t *info)
{
    uint8_t month;
    uint8_t found = 0U;
    if ((date_text == NULL) || (time_text == NULL) || (info == NULL))
        return FIRMWARE_INFO_INVALID_ARGUMENT;
    for (month = 0U; month < 12U; ++month) {
        if ((date_text[0] == months[month][0]) && (date_text[1] == months[month][1])
            && (date_text[2] == months[month][2])) { found = 1U; break; }
    }
    if (!found || !two_digits(&date_text[4], &info->day)
        || !four_digits(&date_text[7], &info->year)
        || !two_digits(&time_text[0], &info->hour)
        || !two_digits(&time_text[3], &info->minute)
        || !two_digits(&time_text[6], &info->second)) return FIRMWARE_INFO_OUT_OF_RANGE;
    info->month = (uint8_t)(month + 1U);
    return FIRMWARE_INFO_OK;
}

firmware_info_status_t firmware_info_to_registers(
    const firmware_info_t *info, uint16_t *registers, size_t count)
{
    uint8_t i;
    firmware_info_status_t status;
    if ((registers == NULL) || (count < FIRMWARE_INFO_REGISTER_COUNT))
        return FIRMWARE_INFO_INVALID_ARGUMENT;
    status = firmware_info_validate(info);
    if (status != FIRMWARE_INFO_OK) return status;
    registers[0] = FIRMWARE_INFO_CONTRACT_VERSION;
    registers[1] = info->major; registers[2] = info->minor; registers[3] = info->patch;
    registers[4] = info->year;
    registers[5] = (uint16_t)(((uint16_t)info->month << 8U) | info->day);
    registers[6] = (uint16_t)(((uint16_t)info->hour << 8U) | info->minute);
    registers[7] = info->second;
    for (i = 0U; i < 4U; ++i)
        registers[8U + i] = (uint16_t)(((uint16_t)(uint8_t)info->build_id[i * 2U] << 8U)
                                      | (uint8_t)info->build_id[i * 2U + 1U]);
    return FIRMWARE_INFO_OK;
}

firmware_info_status_t firmware_info_to_le_bytes(
    const firmware_info_t *info, uint8_t *payload, size_t size)
{
    uint16_t words[FIRMWARE_INFO_REGISTER_COUNT];
    uint8_t i;
    firmware_info_status_t status;
    if ((payload == NULL) || (size < FIRMWARE_INFO_PAYLOAD_SIZE))
        return FIRMWARE_INFO_INVALID_ARGUMENT;
    status = firmware_info_to_registers(info, words, FIRMWARE_INFO_REGISTER_COUNT);
    if (status != FIRMWARE_INFO_OK) return status;
    for (i = 0U; i < FIRMWARE_INFO_REGISTER_COUNT; ++i) {
        payload[i * 2U] = (uint8_t)words[i];
        payload[i * 2U + 1U] = (uint8_t)(words[i] >> 8U);
    }
    return FIRMWARE_INFO_OK;
}