// MAX31329 RTC driver, plus the over-the-radio time sync that seeds it.

#include "max31329.h"

RTC_RFM69_STATUS set_time_from_rfm69(identifier_results id_data)
{
    rfm69_init();
    _delay_ms(1);

    reset_txrx_struct(&TX_DATA);
    memcpy(TX_DATA.msg, id_data.name_str, MIN(10, id_data.name_len));
    memcpy(TX_DATA.msg + 10, id_data.diameter_str, MIN(10, id_data.diameter_len));
    TX_DATA.len = 20;
    TX_DATA.flags = MSG_REQ_CTIME;
    TX_DATA.dtype = MSG_TYPE_STRING;

    rfm69_write_msg(TX_DATA);

    if (wait_rx_payload_ready_timeout(100)) {
        RX_DATA = rfm69_read_msg();
        if (RX_DATA.flags == MSG_RESP_CTIME) {

            // Seed the seconds from the name hash instead of the reply so
            // nodes don't all wake and transmit in the same instant.
            TIME.Second = id_data.hashed;

            TIME.Minute = RX_DATA.msg[1];
            TIME.Hour = RX_DATA.msg[2];
            TIME.Day = RX_DATA.msg[3];
            TIME.Month = RX_DATA.msg[4];
            TIME.Year = RX_DATA.msg[5];
            TIME.Wday = RX_DATA.msg[6];

            // Only claim success once the time actually landed in the RTC,
            // so a failed write is retried next cycle.
            if (rtc_write_time(TIME) == 0) {
                return RTC_RFM69_SET_TIME_SUCCESS;
            }
            LOG("RTC write failed\n");
        }
    }
    return RTC_RFM69_SET_TIME_FAILED;
}

// Masking out minutes, hours, and day makes alarm 2 match once every minute
uint8_t rtc_set_per_minute_alarm(void)
{
    DATA_BUFFER_7[0] = RTC_ALM_MASK_BIT;
    DATA_BUFFER_7[1] = RTC_ALM_MASK_BIT;
    DATA_BUFFER_7[2] = RTC_ALM_MASK_BIT;

    return write_n_bytes(I2C_ADDR, RTC_REG_ALM2_MIN, DATA_BUFFER_7, 3);
}

void uart_print_rtc_time(time_struct td)
{
    char str_rtc[26];
    snprintf(
        str_rtc, sizeof(str_rtc), "%u/%02u/%02u %u:%02u:%02u", 2000 + td.Year, td.Month, td.Day,
        td.Hour, td.Minute, td.Second);
    uart_sendString(str_rtc);
    uart_sendString("\n");
}

uint8_t rtc_read_register(uint8_t addr) { return read_one_byte_no_err_register(I2C_ADDR, addr); }

uint8_t rtc_read_status_register(void) { return rtc_read_register(RTC_REG_STATUS); }

uint8_t rtc_read_interrupt_register(void) { return rtc_read_register(RTC_REG_INT_EN); }

uint8_t rtc_set_alarm_config(void) { return write_one_byte(I2C_ADDR, RTC_REG_CONFIG2, 0b00001010); }

uint8_t rtc_enable_interrupts(void)
{
    return write_one_byte(I2C_ADDR, RTC_REG_INT_EN, RTC_INT_EN_A2IE);
}

uint8_t rtc_read_time_array(uint8_t* data)
{
    return read_n_bytes(I2C_ADDR, RTC_REG_SECONDS, data, 7);
}

time_struct rtc_read_time(void)
{
    if (rtc_read_time_array(DATA_BUFFER_7)) {
        // RTC unreachable: mark every field with an unmistakably invalid value
        // rather than transmitting whatever was read last. The base station
        // sees month 0xFF and knows the timestamp is unusable.
        LOG("RTC read failed\n");
        TIME.Second = TIME.Minute = TIME.Hour = 0xFF;
        TIME.Wday = TIME.Day = TIME.Month = TIME.Year = 0xFF;
        return TIME;
    }

    TIME.Second = BCD2DEC(DATA_BUFFER_7[0]);
    TIME.Minute = BCD2DEC(DATA_BUFFER_7[1]);
    TIME.Hour = BCD2DEC((DATA_BUFFER_7[2] & ~(1 << 6)));
    TIME.Wday = DATA_BUFFER_7[3];
    TIME.Day = BCD2DEC(DATA_BUFFER_7[4]);
    TIME.Month = BCD2DEC((DATA_BUFFER_7[5] & ~(1 << 7)));
    TIME.Year = tmYearToY2k(BCD2DEC(DATA_BUFFER_7[6]));
#if DO_UART
    uart_print_rtc_time(TIME);
#endif
    return TIME;
};

uint8_t rtc_write_time(time_struct tm)
{

    if (i2c_start((I2C_ADDR << 1) | 0x00))
        return 1;

    uint8_t err = 0;
    err |= i2c_write(RTC_REG_SECONDS);
    err |= i2c_write(DEC2BCD(tm.Second));
    err |= i2c_write(DEC2BCD(tm.Minute));
    err |= i2c_write(DEC2BCD(tm.Hour));
    err |= i2c_write(tm.Wday);
    err |= i2c_write(DEC2BCD(tm.Day));
    err |= i2c_write(DEC2BCD(tm.Month));
    err |= i2c_write(DEC2BCD(y2kYearToTm(tm.Year)));

    i2c_stop();
    return err ? 1 : 0;
}