/*
 * dcf77.c  –  DCF77-Empfaenger fuer ATmega32A, 16 MHz Quarz
 *
 * Signal   : Port A, Bit 0 (PA0), interner Pull-Up aktiv
 * Timer    : Timer1, CTC-Mode, 10 ms Takt  (Prescaler 8, OCR1A = 19999)
 * UART     : 9600 Baud (UBRR = 103)
 * Compiler : avr-gcc, -mmcu=atmega32 -DF_CPU=16000000UL
 *
 * Programmstruktur (identisch zur MicroPython-Vorlage):
 *   ISR(TIMER1_COMPA_vect) – nur Signal lesen + Flag setzen, kein GC-Risiko
 *   dcf_update()           – Flankenauswertung + Autodetect, aus main() aufgerufen
 *   dcf_decode()           – DCF77-BCD-Dekodierung + Paritaetspruefung
 *   main()                 – Hauptschleife, Bit-Puffer, Ausgabe
 *
 * DCF77-Bitstruktur (Bit 0 zuerst, 59 Bits pro Minute):
 *   Bit  0     Startbit, immer 0
 *   Bits 1-14  Wetterdaten / reserviert
 *   Bit  15    Rufbit
 *   Bit  16    Reserviert
 *   Bit  17    MESZ aktiv (1 = Sommerzeit)
 *   Bit  18    MEZ  aktiv (1 = Winterzeit)
 *   Bit  19    Schaltsekunde angekuendigt
 *   Bit  20    Startbit Zeitinfo, immer 1
 *   Bits 21-27 Minute  (BCD, LSB zuerst)
 *   Bit  28    Paritaet Minute  (gerade Paritaet ueber Bits 21-28)
 *   Bits 29-34 Stunde  (BCD, LSB zuerst)
 *   Bit  35    Paritaet Stunde  (gerade Paritaet ueber Bits 29-35)
 *   Bits 36-41 Tag      (BCD, LSB zuerst)
 *   Bits 42-44 Wochentag (1=Mo .. 7=So)
 *   Bits 45-49 Monat    (BCD, LSB zuerst)
 *   Bits 50-57 Jahr     (BCD, LSB zuerst, zweistellig)
 *   Bit  58    Paritaet Datum   (gerade Paritaet ueber Bits 36-58)
 */

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>

/* -------------------------------------------------------------------------
 * Hardwarekonstanten
 * F_CPU wird ausschliesslich per -DF_CPU=16000000UL auf der Kommandozeile
 * gesetzt, um Redefinitions-Konflikte mit avr-libc-Headern zu vermeiden.
 * ---------------------------------------------------------------------- */
#define DCF_PORT        PINA          /* Einlesen ueber PIN-Register        */
#define DCF_DDR         DDRA
#define DCF_PORTOUT     PORTA
#define DCF_PIN_BIT     PA0           /* Signal an PA0                      */

/* Timer1 CTC: 10 ms bei 16 MHz, Prescaler 8
 * OCR1A = (F_CPU / Prescaler / Taktrate) - 1 = (16e6 / 8 / 100) - 1 = 19999 */
#define TIMER1_PRESCALER_BITS  (1<<CS11)   /* Prescaler 8                  */
#define TIMER1_OCR1A           19999U

/* UART 9600 Baud: UBRR = F_CPU / (16 * Baud) - 1 = 103 */
#define UART_UBRR       103U

/* -------------------------------------------------------------------------
 * DCF77-Zeitfenster in ms
 * ---------------------------------------------------------------------- */
#define FALSE_TIME_LO   50
#define FALSE_TIME_HI   130
#define TRUE_TIME_LO    150
#define TRUE_TIME_HI    230
#define PAUSE_TIME_LO   1700
#define PAUSE_TIME_HI   2500

/* Anzahl Flankenpaare fuer Autodetect (je Flankentyp) */
#define AUTODETECT_SAMPLES  10

/* -------------------------------------------------------------------------
 * Pulskonstanten
 * ---------------------------------------------------------------------- */
typedef enum {
    PULSE_NONE      = 0,
    PULSE_FALSE     = 1,
    PULSE_TRUE      = 2,
    PULSE_ERROR     = 3,
    PULSE_MIN_BEGIN = 4
} pulse_t;

static const char * const PULSE_NAMES[] = {
    "PULSE_NONE     ",
    "PULSE_FALSE    ",
    "PULSE_TRUE     ",
    "PULSE_ERROR    ",
    "PULSE_MIN_BEGIN"
};

static const char * const WEEKDAY_NAMES[] =
    { "", "Mo", "Di", "Mi", "Do", "Fr", "Sa", "So" };

/* -------------------------------------------------------------------------
 * Dekodiertes Ergebnis
 * ---------------------------------------------------------------------- */
typedef struct {
    uint8_t  hour;
    uint8_t  minute;
    uint8_t  day;
    uint8_t  weekday;
    uint8_t  month;
    uint8_t  year;      /* zweistellig, z.B. 25 fuer 2025 */
    bool     mesz;
} dcf_time_t;

/* -------------------------------------------------------------------------
 * Globaler DCF77-Zustand
 * ---------------------------------------------------------------------- */
static struct {
    /* --- ISR-Uebergabe (nur ISR schreibt, nur dcf_update() liest) --- */
    volatile uint16_t isr_time;     /* ms-Zaehler zum Zeitpunkt des Ticks  */
    volatile uint8_t  isr_signal;   /* Rohwert PA0 zum Zeitpunkt des Ticks */
    volatile bool     isr_flag;     /* true = neuer ISR-Wert verfuegbar    */

    /* --- ms-Zaehler (wird in ISR hochgezaehlt) ---------------------- */
    volatile uint16_t ms_ticks;

    /* --- Flankenauswertung (nur in dcf_update() verwendet) ---------- */
    pulse_t  pulse;
    bool     old_signal;
    uint16_t last_edge_time;
    uint16_t delta_time;
    bool     initialized;

    /* --- Autodetect ------------------------------------------------- */
    bool     autodetect;
    bool     inverted;
    uint8_t  rising_cnt;
    uint8_t  falling_cnt;
    uint8_t  rising_score;
    uint8_t  falling_score;
} dcf;

/* -------------------------------------------------------------------------
 * UART-Initialisierung und printf-Stub
 * ---------------------------------------------------------------------- */
static void uart_init(void)
{
    UBRRH = (uint8_t)(UART_UBRR >> 8);
    UBRRL = (uint8_t)(UART_UBRR);
    UCSRB = (1<<TXEN);                    /* nur Senden                    */
    UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); /* 8N1                      */
}

static int uart_putchar(char c, FILE *stream)
{
    (void)stream;
    if (c == '\n')
        uart_putchar('\r', stream);
    while (!(UCSRA & (1<<UDRE)));
    UDR = (uint8_t)c;
    return 0;
}

static FILE uart_stdout = FDEV_SETUP_STREAM(uart_putchar, NULL, _FDEV_SETUP_WRITE);

/* -------------------------------------------------------------------------
 * Timer1-Initialisierung: CTC-Mode, 10 ms Periode
 * ---------------------------------------------------------------------- */
static void timer1_init(void)
{
    TCCR1A = 0;
    TCCR1B = (1<<WGM12) | TIMER1_PRESCALER_BITS;  /* CTC, Prescaler 8     */
    OCR1A  = TIMER1_OCR1A;
    TIMSK  |= (1<<OCIE1A);                         /* Compare-Match-IRQ an */
}

/* -------------------------------------------------------------------------
 * ISR: Timer1 Compare Match A  –  so minimal wie moeglich
 * Nur ms-Zaehler erhoehen, Rohsignal lesen, Flag setzen.
 * ---------------------------------------------------------------------- */
ISR(TIMER1_COMPA_vect)
{
    dcf.ms_ticks++;
    dcf.isr_time   = dcf.ms_ticks;
    dcf.isr_signal = (DCF_PORT >> DCF_PIN_BIT) & 0x01;
    dcf.isr_flag   = true;
}

/* -------------------------------------------------------------------------
 * Hilfsfunktion: Prueft ob Breite im DCF77-Pulsfenster liegt
 * ---------------------------------------------------------------------- */
static bool is_valid_pulse(uint16_t width)
{
    return (width >= FALSE_TIME_LO && width <= TRUE_TIME_HI);
}

/* -------------------------------------------------------------------------
 * Autodetect: Flankenbreite sammeln, nach AUTODETECT_SAMPLES auswerten
 * ---------------------------------------------------------------------- */
static void autodetect_update(uint16_t delta, bool rising)
{
    if (rising) {
        dcf.rising_cnt++;
        if (is_valid_pulse(delta))
            dcf.rising_score++;
    } else {
        dcf.falling_cnt++;
        if (is_valid_pulse(delta))
            dcf.falling_score++;
    }

    if ((dcf.rising_cnt + dcf.falling_cnt) < AUTODETECT_SAMPLES * 2)
        return;  /* noch nicht genug Daten */

    dcf.inverted   = (dcf.rising_score > dcf.falling_score);
    dcf.autodetect = false;

    printf("Autodetect: rising=%u falling=%u -> inverted=%u\n",
           dcf.rising_score, dcf.falling_score, (uint8_t)dcf.inverted);
}

/* -------------------------------------------------------------------------
 * dcf_update()  –  Flankenauswertung, regelmaessig aus main() aufrufen.
 * Gibt true zurueck wenn ein neuer Puls in dcf.pulse bereitsteht.
 * ---------------------------------------------------------------------- */
bool dcf_update(void)
{
    /* ISR-Flag und Uebergabewerte atomar lesen und Flag loeschen */
    cli();
    bool     flag = dcf.isr_flag;
    uint16_t now  = dcf.isr_time;
    uint8_t  raw  = dcf.isr_signal;
    dcf.isr_flag  = false;
    sei();

    if (!flag)
        return false;

    bool dcf_signal = dcf.autodetect ? (bool)raw : ((bool)raw ^ dcf.inverted);

    if (!dcf.initialized) {
        dcf.last_edge_time = now;
        dcf.old_signal     = dcf_signal;
        dcf.initialized    = true;
        return false;
    }

    /* Nur bei Flanke auswerten */
    if (dcf.old_signal == dcf_signal)
        return false;

    uint16_t delta   = now - dcf.last_edge_time;
    dcf.delta_time   = delta;

    /* Fallende Flanke (logisch: High -> Low) */
    if (dcf.old_signal && !dcf_signal) {
        if (dcf.autodetect) {
            autodetect_update(delta, false);
        } else {
            if (delta >= TRUE_TIME_LO && delta <= TRUE_TIME_HI)
                dcf.pulse = PULSE_TRUE;
            else if (delta >= FALSE_TIME_LO && delta <= FALSE_TIME_HI)
                dcf.pulse = PULSE_FALSE;
            else
                dcf.pulse = PULSE_ERROR;
        }
    }
    /* Steigende Flanke (logisch: Low -> High) */
    else if (!dcf.old_signal && dcf_signal) {
        if (dcf.autodetect) {
            autodetect_update(delta, true);
        } else {
            if (delta >= PAUSE_TIME_LO && delta <= PAUSE_TIME_HI)
                dcf.pulse = PULSE_MIN_BEGIN;
            else if (delta >= TRUE_TIME_HI)
                ;    /* normale Sekunden-Pause (~800 ms): kein Fehler */
            else
                dcf.pulse = PULSE_ERROR;
        }
    }

    dcf.old_signal     = dcf_signal;
    dcf.last_edge_time = now;

    return (dcf.pulse != PULSE_NONE);
}

/* -------------------------------------------------------------------------
 * BCD-Dekodierung (LSB zuerst)
 * ---------------------------------------------------------------------- */
static uint8_t bcd_decode(const int8_t *bits, uint8_t start, uint8_t length)
{
    static const uint8_t weights[] = { 1, 2, 4, 8, 10, 20, 40, 80 };
    uint8_t val = 0;
    for (uint8_t i = 0; i < length; i++)
        if (bits[start + i] == 1)
            val += weights[i];
    return val;
}

/* -------------------------------------------------------------------------
 * Gerade Paritaetspruefung ueber bits[start..end] (end inklusive)
 * ---------------------------------------------------------------------- */
static bool parity_even(const int8_t *bits, uint8_t start, uint8_t end)
{
    uint8_t ones = 0;
    for (uint8_t i = start; i <= end; i++)
        if (bits[i] == 1)
            ones++;
    return (ones % 2 == 0);
}

/* -------------------------------------------------------------------------
 * dcf_decode()  –  DCF77-Bitpuffer auswerten.
 * Gibt true bei Erfolg zurueck, Ergebnis in *result.
 * ---------------------------------------------------------------------- */
bool dcf_decode(const int8_t *bits, uint8_t count, dcf_time_t *result)
{
    if (count < 59) {
        printf("DECODE ERROR: nur %u Bits empfangen (59 erwartet)\n", count);
        return false;
    }

    /* Empfangsfehler (-1) im relevanten Bereich pruefen */
    for (uint8_t i = 20; i < 59; i++) {
        if (bits[i] == -1) {
            printf("DECODE ERROR: fehlerhafte Bits im Zeitbereich\n");
            return false;
        }
    }

    /* Startbits pruefen */
    if (bits[0] != 0) {
        printf("DECODE ERROR: Bit 0 ist nicht 0 (Startbit)\n");
        return false;
    }
    if (bits[20] != 1) {
        printf("DECODE ERROR: Bit 20 ist nicht 1 (Zeitstartbit)\n");
        return false;
    }

    /* Paritaeten pruefen */
    if (!parity_even(bits, 21, 28)) {
        printf("DECODE ERROR: Paritaetsfehler Minute (Bits 21-28)\n");
        return false;
    }
    if (!parity_even(bits, 29, 35)) {
        printf("DECODE ERROR: Paritaetsfehler Stunde (Bits 29-35)\n");
        return false;
    }
    if (!parity_even(bits, 36, 58)) {
        printf("DECODE ERROR: Paritaetsfehler Datum (Bits 36-58)\n");
        return false;
    }

    /* Zeitwerte dekodieren */
    result->minute  = bcd_decode(bits, 21, 7);
    result->hour    = bcd_decode(bits, 29, 6);
    result->day     = bcd_decode(bits, 36, 6);
    result->weekday = bcd_decode(bits, 42, 3);
    result->month   = bcd_decode(bits, 45, 5);
    result->year    = bcd_decode(bits, 50, 8);
    result->mesz    = (bits[17] == 1);

    const char *tz_str = result->mesz ? "MESZ" : "MEZ ";
    const char *wd_str = (result->weekday >= 1 && result->weekday <= 7)
                         ? WEEKDAY_NAMES[result->weekday] : "??";

    printf(">>> Zeit : %02u:%02u %s\n", result->hour, result->minute, tz_str);
    printf(">>> Datum : %s %02u.%02u.20%02u\n",
           wd_str, result->day, result->month, result->year);

    return true;
}

/* -------------------------------------------------------------------------
 * Initialisierung des DCF77-Zustands
 * ---------------------------------------------------------------------- */
static void dcf_init(void)
{
    memset(&dcf, 0, sizeof(dcf));
    dcf.autodetect = true;   /* Automatische Erkennung aktiv               */
    /* dcf.inverted = false; bereits durch memset                          */
    /* dcf.inverted = true;  fuer bekannt invertierte Module               */
}

/* -------------------------------------------------------------------------
 * Hardwareinitialisierung
 * ---------------------------------------------------------------------- */
static void hw_init(void)
{
    /* PA0 als Eingang, Pull-Up aktivieren */
    DCF_DDR    &= ~(1<<DCF_PIN_BIT);
    DCF_PORTOUT |= (1<<DCF_PIN_BIT);

    uart_init();
    stdout = &uart_stdout;

    timer1_init();
    sei();
}

/* -------------------------------------------------------------------------
 * main()
 * ---------------------------------------------------------------------- */
int main(void)
{
    hw_init();
    dcf_init();

    /* Bit-Puffer fuer eine DCF77-Minute (59 Bits)
     * Werte: 0, 1 = gueltiges Bit; -1 = Empfangsfehler */
    int8_t  bits[59];
    uint8_t bit_count = 0;   /* Anzahl empfangener Bits                    */
    uint8_t bitcnt    = 0;   /* Bitzaehler, beginnt bei 0 nach Minutenstart */

    printf("DCF77-Empfaenger gestartet (Autodetect aktiv)\n");

    while (1) {
        if (dcf_update()) {
            pulse_t p  = dcf.pulse;
            dcf.pulse  = PULSE_NONE;

            if (p == PULSE_MIN_BEGIN) {
                /* Minutenpause: abgeschlossene Minute auswerten */
                printf("--- Minutenbeginn: %u Bits empfangen ---\n", bit_count);

                /* Bitstring ausgeben */
                printf("Bits: ");
                for (uint8_t i = 0; i < bit_count; i++) {
                    if (bits[i] == -1) printf("?");
                    else               printf("%d", bits[i]);
                }
                printf("\n");

                /* Dekodieren */
                dcf_time_t result;
                dcf_decode(bits, bit_count, &result);

                /* Puffer und Zaehler zuruecksetzen */
                bit_count = 0;
                bitcnt    = 0;

            } else if (p == PULSE_TRUE) {
                if (bit_count < 59) {
                    bits[bit_count++] = 1;
                    printf("%s deltaTime:%5u  Bit#%02u: 1\n",
                           PULSE_NAMES[p], dcf.delta_time, bitcnt++);
                }

            } else if (p == PULSE_FALSE) {
                if (bit_count < 59) {
                    bits[bit_count++] = 0;
                    printf("%s deltaTime:%5u  Bit#%02u: 0\n",
                           PULSE_NAMES[p], dcf.delta_time, bitcnt++);
                }

            } else {
                /* PULSE_ERROR: Platzhalter eintragen */
                if (bit_count < 59) {
                    bits[bit_count++] = -1;
                    printf("%s deltaTime:%5u  Bit#%02u: ?\n",
                           PULSE_NAMES[p], dcf.delta_time, bitcnt++);
                }
            }
        }
    }

    return 0;
}