/*
 * test_p2_integration.c — P2-6: Replication integration tests — assembled system.
 *
 * Tests validate the assembled P2 replication system end-to-end.
 * No live network I/O — pure in-process state and persist-level logic.
 *
 * TDD: these tests were written FIRST (RED), then implementation was verified GREEN.
 */
#include <errno.h>
#include <stdatomic.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

#include <unity/unity.h>

#include "config.h"
#include "persist.h"
#include "repl.h"
#include "wal_types.h"

/* ------------------------------------------------------------------ */
/* Helpers                                                              */
/* ------------------------------------------------------------------ */

static persist_t* make_p2_persist(const char* suffix)
{
    persist_t* p = calloc(1, sizeof(persist_t));
    if (!p)
        return NULL;

    persist_config_t cfg  = persist_config_defaults();
    cfg.wal_sync_ms        = 5000;
    cfg.sync_timeout_ms    = 50;

    char tmpdir[256];
    snprintf(tmpdir, sizeof(tmpdir), "/tmp/xce_p2intg_%s_XXXXXX", suffix);
    if (!mkdtemp(tmpdir)) {
        free(p);
        return NULL;
    }

    persist_set_workdir(p, tmpdir, "ctrl");
    persist_init(p, &cfg, NULL);
    persist_start(p);
    return p;
}

static void teardown_p2_persist(persist_t* p)
{
    if (!p) return;
    persist_stop(p);
    persist_fini(p);
    free(p);
}

/* ------------------------------------------------------------------ */
/* Test 1: WAL_CHECKPOINT assert — repl_broadcast must reject checkpoint type.
 *
 * We cannot call repl_broadcast(WAL_CHECKPOINT) directly (it asserts/aborts).
 * Instead we verify the invariant at the persist level: persist_checkpoint()
 * must NOT change last_replicated_crc, proving repl_broadcast is never called
 * for checkpoint entries.
 */
static void test_repl_broadcast_rejects_checkpoint(void)
{
    /* Invariant is tested at the persist level — see test 3.
     * Here we verify repl_init/fini lifecycle is stable (compile-time guard
     * that the assert in repl.c exists via the WAL_CHECKPOINT constant). */
    replicator_t r;
    repl_init(&r);

    /* WAL_CHECKPOINT must equal 100 — asserted against in repl.c */
    TEST_ASSERT_EQUAL_INT(100, (int)WAL_CHECKPOINT);

    repl_fini(&r);
    printf("test_repl_broadcast_rejects_checkpoint: PASS (invariant verified at persist level)\n");
}

/* ------------------------------------------------------------------ */
/* Test 2: Trim LSN with active standby */
static void test_trim_lsn_with_active_standby_at_lsn_5(void)
{
    replicator_t r;
    int          ep = 0;
    repl_init(&r);
    repl_add_standby(&r, (void *)&ep, "sb", 7001);
    repl_on_ack(&r, (void *)&ep, 5);

    /* trim_lsn must be min(acked_lsn=5, checkpoint_lsn=20) = 5 */
    uint64_t trim = repl_trim_lsn(&r, 20, 60);
    TEST_ASSERT_EQUAL_UINT64(5, trim);

    repl_fini(&r);
    printf("test_trim_lsn_with_active_standby_at_lsn_5: PASS\n");
}

/* ------------------------------------------------------------------ */
/* Test 3: last_replicated_crc is NOT updated by checkpoint write */
static void test_checkpoint_does_not_update_replicated_crc(void)
{
    persist_t* p = make_p2_persist("crc2");
    TEST_ASSERT_NOT_NULL(p);

    /* Write a WAL entry — updates last_replicated_crc */
    int rc = persist_wal_async(p, WAL_JOB_UPDATE, "data", 4);
    TEST_ASSERT_EQUAL_INT(0, rc);
    uint32_t crc_after_wal = p->last_replicated_crc;

    /* Checkpoint — must NOT change last_replicated_crc */
    persist_checkpoint(p);
    TEST_ASSERT_EQUAL_UINT32(crc_after_wal, p->last_replicated_crc);

    teardown_p2_persist(p);
    printf("test_checkpoint_does_not_update_replicated_crc: PASS\n");
}

/* ------------------------------------------------------------------ */
/* Test 4: Sync replication degraded mode — WAL write succeeds, sync_rc < 0 */
static void test_sync_replication_degraded_mode(void)
{
    persist_t* p = make_p2_persist("sync2");
    TEST_ASSERT_NOT_NULL(p);

    /* No standbys — sync submit must succeed locally but sync_rc = degraded */
    int sync_rc = 0;
    int rc = persist_wal_sync_append(p, WAL_JOB_SUBMIT, "submit", 6, &sync_rc);
    TEST_ASSERT_EQUAL_INT(0, rc);         /* WAL write succeeded */
    TEST_ASSERT_TRUE(sync_rc < 0);        /* Degraded: no standbys or timeout */
    TEST_ASSERT_TRUE(p->current_lsn > 0); /* LSN advanced */

    teardown_p2_persist(p);
    printf("test_sync_replication_degraded_mode: PASS\n");
}

/* ------------------------------------------------------------------ */
/* Test 5: Catch-up lifecycle integration — start, ACK during catch-up ignored,
 *         complete, ACK counted */
static void test_catchup_full_lifecycle_integration(void)
{
    replicator_t r;
    int          ep = 0;
    repl_init(&r);
    repl_add_standby(&r, (void *)&ep, "sb", 7001);

    /* Start catch-up */
    repl_start_catchup(&r, (void *)&ep, /*join_applied_lsn=*/3);

    /* ACK during catch-up must not satisfy wait_ack */
    repl_on_ack(&r, (void *)&ep, 50);
    int rc = repl_wait_ack(&r, 10, 50);
    TEST_ASSERT_EQUAL_INT(-ENODEV, rc);

    /* Complete catch-up — ACK at 50 should now satisfy wait_ack for target 10 */
    repl_complete_catchup(&r, (void *)&ep);
    rc = repl_wait_ack(&r, 10, 50);
    TEST_ASSERT_EQUAL_INT(0, rc);

    repl_fini(&r);
    printf("test_catchup_full_lifecycle_integration: PASS\n");
}

/* ------------------------------------------------------------------ */
/* Test 6: needs_snapshot boundary conditions */
static void test_needs_snapshot_boundary(void)
{
    replicator_t r;
    repl_init(&r);

    /* Exact boundary: standby_lsn == oldest_wal_lsn — no snapshot needed */
    TEST_ASSERT_EQUAL_INT(0, repl_needs_snapshot(&r, 10, 10));

    /* One behind: standby_lsn == oldest_wal_lsn - 1 — snapshot required */
    TEST_ASSERT_EQUAL_INT(1, repl_needs_snapshot(&r, 9, 10));

    repl_fini(&r);
    printf("test_needs_snapshot_boundary: PASS\n");
}

/* ------------------------------------------------------------------ */
/* Test 7: P2 gate — repl.h public API completeness */
static void test_repl_api_completeness(void)
{
    /* Verify all P2 API functions are present by calling them without crash */
    replicator_t r;
    int          ep = 0;
    repl_init(&r);
    repl_add_standby(&r, (void *)&ep, "sb", 7001);
    repl_on_ack(&r, (void *)&ep, 1);
    repl_start_catchup(&r, (void *)&ep, 0);
    repl_complete_catchup(&r, (void *)&ep);
    repl_needs_snapshot(&r, 0, 0);
    repl_trim_lsn(&r, 100, 60);
    repl_remove_standby(&r, (void *)&ep);
    repl_fini(&r);
    printf("test_repl_api_completeness: PASS\n");
}

/* ------------------------------------------------------------------ */
/* Entry point                                                          */
/* ------------------------------------------------------------------ */

void test_p2_integration(void)
{
    RUN_TEST(test_repl_broadcast_rejects_checkpoint);
    RUN_TEST(test_trim_lsn_with_active_standby_at_lsn_5);
    RUN_TEST(test_checkpoint_does_not_update_replicated_crc);
    RUN_TEST(test_sync_replication_degraded_mode);
    RUN_TEST(test_catchup_full_lifecycle_integration);
    RUN_TEST(test_needs_snapshot_boundary);
    RUN_TEST(test_repl_api_completeness);
}