Clock

/* Coded By JD(2026) */
#error "Reference listing only — not provided as build-ready source."
#include "clock.h"

#include "esp_random.h"
#include "game_graphics.h"
#include "PET2001_font.h"
#include "global_overlay.h"
#include "time_sync.h"
#include "wifi.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define CLOCK_UPDATE_MS 1000U
#define CLOCK_LAYOUT_CHANGE_MS (10U * 60U * 1000U)
#define CLOCK_VALID_YEAR 2024
#define CLOCK_ZONE_COUNT 3U

typedef enum { CLOCK_SECTION_TIME, CLOCK_SECTION_DATE, CLOCK_SECTION_COUNTDOWNS } clock_section_t;

static bool running;
static bool frame_ready;
static bool full_redraw;
static bool time_available;
static uint32_t last_update;
static uint32_t last_layout_change;
static int last_day_of_year;
static char time_text[16];
static char day_text[16];
static char date_text[32];
static char monday_countdown[20];
static char friday_countdown[20];
static uint8_t section_zone[CLOCK_ZONE_COUNT];
static const int zone_y[CLOCK_ZONE_COUNT] = {4, 58, 112};

static void configure_clock_timezone(void)
{
    static bool configured;
    if (configured) return;
    setenv("TZ", "CET-1CEST,M3.5.0/02,M10.5.0/03", 1);
    tzset();
    configured = true;
}

static void choose_section_layout(void)
{
    uint8_t previous_layout[CLOCK_ZONE_COUNT];
    memcpy(previous_layout, section_zone, sizeof(previous_layout));
    do {
        for (uint8_t index = 0U; index < CLOCK_ZONE_COUNT; ++index) section_zone[index] = index;
        for (uint8_t index = CLOCK_ZONE_COUNT - 1U; index > 0U; --index) {
            const uint8_t swap = (uint8_t)(esp_random() % (index + 1U));
            const uint8_t temporary = section_zone[index];
            section_zone[index] = section_zone[swap];
            section_zone[swap] = temporary;
        }
    } while (memcmp(previous_layout, section_zone, sizeof(section_zone)) == 0);
}

static int section_y(clock_section_t section)
{
    return zone_y[section_zone[section]];
}

static void draw_unsynchronized_status(uint16_t *frame, int y)
{
    const wifi_connection_state_t connection = wifiServiceConnectionState();
    const time_sync_status_t sync_status = timeSyncStatus();
    const char *status_text = "CLOCK NOT SET";
    uint16_t status_colour = COLOR_YELLOW;

    if (connection == WIFI_CONNECTION_CONNECTING) status_text = "WIFI CONNECTING...";
    else if (connection == WIFI_CONNECTION_FAILED) {
        status_text = "WIFI CONNECTION FAILED";
        status_colour = COLOR_RED;
    } else if (sync_status == TIME_SYNC_SYNCING) status_text = "TIME SYNCING...";
    else if (sync_status == TIME_SYNC_FAILED) {
        status_text = "TIME SYNC FAILED";
        status_colour = COLOR_RED;
    }
    drawPet2001TextCentredTransparent(frame, 160, y + 18, status_text, status_colour, 1);
}

static void draw_time_section(uint16_t *frame, int y, const char *text, uint16_t colour)
{
    fill_rect(frame, 0, y, LCD_WIDTH, 38, COLOR_BLACK);
    drawPet2001TextCentredTransparent(frame, 160, y, text, colour, 4);
}

static void draw_date_section(uint16_t *frame, int y)
{
    fill_rect(frame, 0, y, LCD_WIDTH, 42, COLOR_BLACK);
    drawPet2001TextCentredTransparent(frame, 160, y + 2, day_text, COLOR_ORANGE, 2);
    drawPet2001TextCentredTransparent(frame, 160, y + 24, date_text, COLOR_ORANGE, 1);
}

static void draw_countdown_section(uint16_t *frame, int y)
{
    fill_rect(frame, 0, y, LCD_WIDTH, 43, COLOR_BLACK);
    drawPet2001TextTransparent(frame, 8, y + 2, "DOOM", COLOR_CRIMSON, 1);
    drawPet2001TextCentredTransparent(frame, 208, y, monday_countdown, COLOR_CRIMSON, 2);
    drawPet2001TextTransparent(frame, 8, y + 25, "FREEDOM", COLOR_OLIVE, 1);
    drawPet2001TextCentredTransparent(frame, 208, y + 23, friday_countdown, COLOR_OLIVE, 2);
}

static void format_countdown(char *text, size_t text_size, time_t now_time,
                             const struct tm *now, int target_weekday,
                             int target_hour, int target_minute)
{
    struct tm target = *now;
    int days_until_target = (target_weekday - target.tm_wday + 7) % 7;
    target.tm_mday += days_until_target;
    target.tm_hour = target_hour;
    target.tm_min = target_minute;
    target.tm_sec = 0;
    target.tm_isdst = -1;

    time_t target_time = mktime(&target);
    if (difftime(target_time, now_time) <= 0.0) {
        target.tm_mday += 7;
        target.tm_isdst = -1;
        target_time = mktime(&target);
    }

    long remaining = (long)difftime(target_time, now_time);
    const long days = remaining / 86400L;
    remaining %= 86400L;
    const long hours = remaining / 3600L;
    remaining %= 3600L;
    const long minutes = remaining / 60L;
    const long seconds = remaining % 60L;
    snprintf(text, text_size, "%ldd %02ld:%02ld:%02ld", days, hours, minutes, seconds);
}

static void format_doomsday_countdown(char *text, size_t text_size, time_t now_time)
{
    struct tm target = {
        .tm_year = 2027 - 1900,
        .tm_mon = 1,
        .tm_mday = 5,
        .tm_isdst = -1,
    };
    long remaining = (long)difftime(mktime(&target), now_time);
    if (remaining < 0L) remaining = 0L;

    const long days = remaining / 86400L;
    remaining %= 86400L;
    const long hours = remaining / 3600L;
    remaining %= 3600L;
    const long minutes = remaining / 60L;
    const long seconds = remaining % 60L;
    snprintf(text, text_size, "%ldd %02ld:%02ld:%02ld", days, hours, minutes, seconds);
}

static void update_time_strings(void)
{
    const time_t now_time = time(NULL);
    struct tm local_time = {0};
    if (now_time == (time_t)-1 || localtime_r(&now_time, &local_time) == NULL ||
        local_time.tm_year + 1900 < CLOCK_VALID_YEAR) {
        if (time_available) full_redraw = true;
        time_available = false;
        return;
    }

    if (!time_available || last_day_of_year != local_time.tm_yday) full_redraw = true;
    time_available = true;
    strftime(time_text, sizeof(time_text), "%H:%M:%S", &local_time);
    strftime(day_text, sizeof(day_text), "%A", &local_time);
    strftime(date_text, sizeof(date_text), "%d %B %Y", &local_time);
    format_doomsday_countdown(monday_countdown, sizeof(monday_countdown), now_time);
    format_countdown(friday_countdown, sizeof(friday_countdown), now_time,
                     &local_time, 5, 15, 0);
    last_day_of_year = local_time.tm_yday;
}

void startClock(uint32_t now_ms)
{
    configure_clock_timezone();
    running = true;
    frame_ready = true;
    full_redraw = true;
    time_available = false;
    last_day_of_year = -1;
    last_update = now_ms - CLOCK_UPDATE_MS;
    last_layout_change = now_ms;
    choose_section_layout();
}

void stopClock(void)
{
    running = false;
    frame_ready = false;
}

void updateClock(uint32_t now_ms)
{
    if (!running || now_ms - last_update < CLOCK_UPDATE_MS) return;
    last_update = now_ms;
    if (now_ms - last_layout_change >= CLOCK_LAYOUT_CHANGE_MS) {
        choose_section_layout();
        last_layout_change = now_ms;
        full_redraw = true;
    }
    update_time_strings();
    frame_ready = true;
}

bool clockTakeFrame(void)
{
    const bool ready = frame_ready;
    frame_ready = false;
    return ready;
}

void drawClock(uint16_t *frame)
{
    if (!running || frame == NULL) return;

    if (full_redraw) {
        clear(frame, COLOR_BLACK);
    }

    if (!time_available) {
        draw_time_section(frame, section_y(CLOCK_SECTION_TIME), "--:--:--", COLOR_RED);
        fill_rect(frame, 0, section_y(CLOCK_SECTION_DATE), LCD_WIDTH, 42, COLOR_BLACK);
        draw_unsynchronized_status(frame, section_y(CLOCK_SECTION_DATE));
        full_redraw = false;
        return;
    }

    draw_time_section(frame, section_y(CLOCK_SECTION_TIME), time_text, COLOR_RED);
    draw_date_section(frame, section_y(CLOCK_SECTION_DATE));
    draw_countdown_section(frame, section_y(CLOCK_SECTION_COUNTDOWNS));
    full_redraw = false;
}

void updateDoomCountdownOverlay(void)
{
    configure_clock_timezone();

    const time_t now_time = time(NULL);
    struct tm local_time = {0};
    if (now_time == (time_t)-1 || localtime_r(&now_time, &local_time) == NULL ||
        local_time.tm_year + 1900 < CLOCK_VALID_YEAR) {
        globalOverlayClearItem(0U);
        return;
    }

    char countdown[20];
    char overlay_text[32];
    format_doomsday_countdown(countdown, sizeof(countdown), now_time);
    snprintf(overlay_text, sizeof(overlay_text), "DOOM %s", countdown);
    // Pixel coordinates are deliberately independent of individual screens: move this
    // item anywhere on the LCD by changing its x/y values without changing a renderer.
    (void)globalOverlaySetItem(0U, overlay_text, 2, 2, 1, COLOR_ORANGE);
}