Plan: SNAP Enrollment and EBT Issuance

CREATE TABLE snap_enrollments (
    id UUID PRIMARY KEY,
    household_id UUID NOT NULL,
    determination_id UUID NOT NULL,  -- the approved determination that triggered enrollment
    application_id UUID NOT NULL,
    certification_start_date DATE NOT NULL,
    certification_end_date DATE NOT NULL,
    max_monthly_allotment NUMERIC(10,2) NOT NULL,
    ebt_account_id TEXT,             -- EBT host account identifier (set after account provisioned)
    expedited BOOLEAN NOT NULL DEFAULT false,
    initial_issuance_due_date DATE NOT NULL,  -- application_date + 7 if expedited, else + 30
    initial_issuance_date DATE,              -- actual issuance date
    status TEXT NOT NULL DEFAULT 'pending_issuance',
    -- 'pending_issuance', 'active', 'suspended', 'terminated', 'expired'
    suspended_reason TEXT,
    terminated_reason TEXT,
    terminated_date DATE,
    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    active BOOLEAN NOT NULL DEFAULT true
);

CREATE INDEX snap_enrollments_household_idx ON snap_enrollments (household_id);
CREATE INDEX snap_enrollments_status_idx ON snap_enrollments (status, initial_issuance_due_date)
    WHERE status = 'pending_issuance';

CREATE TABLE snap_benefit_issuances (
    id UUID PRIMARY KEY,
    enrollment_id UUID NOT NULL REFERENCES snap_enrollments(id),
    household_id UUID NOT NULL,
    benefit_month DATE NOT NULL,           -- first day of the benefit month
    allotment_amount NUMERIC(10,2) NOT NULL,
    prorated BOOLEAN NOT NULL DEFAULT false,
    proration_days_remaining INTEGER,      -- days remaining in month at application date
    proration_days_total INTEGER,          -- total days in the benefit month
    ebt_transaction_id TEXT,              -- EBT host transaction reference
    issued_at TIMESTAMPTZ,
    issuance_status TEXT NOT NULL DEFAULT 'pending',
    -- 'pending', 'issued', 'failed', 'reversed'
    issuance_error TEXT,
    expiry_date DATE NOT NULL,            -- issued_date + 365 (12-month stale benefit rule)
    expungement_notice_sent_at TIMESTAMPTZ,  -- set when 30-day expungement notice generated
    expunged_at TIMESTAMPTZ,
    expunged_amount NUMERIC(10,2),        -- may be less than allotment_amount if partially used
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

CREATE UNIQUE INDEX snap_issuances_enrollment_month ON snap_benefit_issuances (enrollment_id, benefit_month);
CREATE INDEX snap_issuances_expiry_idx ON snap_benefit_issuances (expiry_date)
    WHERE expunged_at IS NULL AND issuance_status = 'issued';

// SPDX-License-Identifier: AGPL-3.0-or-later

use chrono::NaiveDate;
use rust_decimal::Decimal;
use uuid::Uuid;
use anyhow::Result;

pub struct EbtAccountRequest {
    pub household_id: Uuid,
    pub enrollment_id: Uuid,
    pub head_of_household_name: String,  // fetched from canopy-persons
}

pub struct EbtAccountResult {
    pub account_id: String,
    pub provisioned_at: chrono::DateTime<chrono::Utc>,
}

pub struct EbtIssuanceRequest {
    pub account_id: String,
    pub enrollment_id: Uuid,
    pub benefit_month: NaiveDate,
    pub amount: Decimal,
}

pub struct EbtIssuanceResult {
    pub transaction_id: String,
    pub issued_at: chrono::DateTime<chrono::Utc>,
}

pub struct EbtBalanceResult {
    pub available_balance: Decimal,
    pub as_of: chrono::DateTime<chrono::Utc>,
}

pub struct EbtExpungeRequest {
    pub account_id: String,
    pub transaction_id: String,  // the issuance transaction to expunge
    pub amount: Decimal,
}

pub trait EbtAdapter: Send + Sync {
    /// Provision a new EBT account for an enrolled household.
    async fn create_account(&self, req: &EbtAccountRequest) -> Result<EbtAccountResult>;

    /// Issue benefit allotment for a benefit month.
    async fn issue_benefits(&self, req: &EbtIssuanceRequest) -> Result<EbtIssuanceResult>;

    /// Query available balance (used for expungement calculation).
    async fn get_balance(&self, account_id: &str) -> Result<EbtBalanceResult>;

    /// Suspend EBT account (adverse action pending hearing).
    async fn suspend_account(&self, account_id: &str, reason: &str) -> Result<()>;

    /// Expunge stale benefits after 12-month window expires.
    async fn expunge_benefits(&self, req: &EbtExpungeRequest) -> Result<()>;
}

pub struct ConduentEbtAdapter {
    base_url: String,
    api_key: String,
    client: reqwest::Client,
}
// Methods unimplemented!() — real Conduent API endpoints TBD from state contract documentation.
// Do NOT implement real Conduent calls until contract credentials and security review are complete.

/// Calculate prorated allotment for the initial benefit month.
/// Per 7 CFR 273.10(a)(1)(ii): prorate from date of application.
pub fn prorated_allotment(
    max_allotment: Decimal,
    application_date: NaiveDate,
) -> (Decimal, i32, i32) {
    let days_in_month = days_in_month(application_date.year(), application_date.month());
    let days_remaining = days_in_month - application_date.day() as i32 + 1;
    let prorated = (max_allotment * Decimal::from(days_remaining)
        / Decimal::from(days_in_month))
        .round_dp(2);
    (prorated, days_remaining, days_in_month)
}

// enrollment.snap_issued
{ "enrollment_id": "uuid", "household_id": "uuid", "benefit_month": "2026-07-01" }

// enrollment.expungement_pending
{ "enrollment_id": "uuid", "household_id": "uuid",
  "issuance_id": "uuid", "expiry_date": "2026-07-31" }

// enrollment.benefits_expunged
{ "enrollment_id": "uuid", "household_id": "uuid",
  "issuance_id": "uuid", "benefit_month": "2025-07-01" }

// SPDX-License-Identifier: AGPL-3.0-or-later

use canopy_mq::publisher::EventPublisher;
use chrono::{NaiveDate, Utc};
use sqlx::PgPool;
use uuid::Uuid;

pub struct ExpungementJob {
    pool: PgPool,
    ebt: Arc<dyn EbtAdapter>,
    publisher: EventPublisher,
}

impl ExpungementJob {
    pub fn new(pool: PgPool, ebt: Arc<dyn EbtAdapter>, publisher: EventPublisher) -> Self {
        Self { pool, ebt, publisher }
    }

    /// Send 30-day expungement notices for issuances approaching expiry.
    /// Finds issuances where expiry_date = today + 30 AND expungement_notice_sent_at IS NULL.
    pub async fn send_expungement_notices(&self) -> Result<u64> {
        let today = Utc::now().date_naive();
        let target_date = today + chrono::Duration::days(30);
        let issuances = sqlx::query_as::<_, SnapBenefitIssuance>(
            r#"SELECT * FROM snap_benefit_issuances
               WHERE expiry_date = $1
               AND expungement_notice_sent_at IS NULL
               AND expunged_at IS NULL
               AND issuance_status = 'issued'"#,
        )
        .bind(target_date)
        .fetch_all(&self.pool)
        .await?;

        for issuance in &issuances {
            self.publisher.publish(
                "enrollment.expungement_pending",
                &serde_json::json!({
                    "enrollment_id": issuance.enrollment_id,
                    "household_id": issuance.household_id,
                    "issuance_id": issuance.id,
                    "expiry_date": issuance.expiry_date
                }),
            ).await?;
            // Update expungement_notice_sent_at
            sqlx::query("UPDATE snap_benefit_issuances SET expungement_notice_sent_at = now() WHERE id = $1")
                .bind(issuance.id)
                .execute(&self.pool)
                .await?;
        }
        Ok(issuances.len() as u64)
    }

    /// Process today's expired issuances: get remaining balance, expunge via EBT adapter.
    /// Finds issuances where expiry_date = today AND expunged_at IS NULL AND issuance_status = 'issued'.
    pub async fn run_expungements(&self) -> Result<u64> {
        let today = Utc::now().date_naive();
        let issuances = sqlx::query_as::<_, SnapBenefitIssuance>(
            r#"SELECT * FROM snap_benefit_issuances
               WHERE expiry_date = $1
               AND expunged_at IS NULL
               AND issuance_status = 'issued'"#,
        )
        .bind(today)
        .fetch_all(&self.pool)
        .await?;

        for issuance in &issuances {
            // 1. Get remaining balance from EBT host
            // 2. Call ebt.expunge_benefits if balance > 0
            // 3. Update expunged_at and expunged_amount
            // 4. Publish enrollment.benefits_expunged event
        }
        Ok(issuances.len() as u64)
    }
}

// SPDX-License-Identifier: AGPL-3.0-or-later

use chrono::{DateTime, NaiveDate, Utc};
use rust_decimal::Decimal;
use uuid::Uuid;

#[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
pub struct SnapEnrollment {
    pub id: Uuid,
    pub household_id: Uuid,
    pub determination_id: Uuid,
    pub application_id: Uuid,
    pub certification_start_date: NaiveDate,
    pub certification_end_date: NaiveDate,
    pub max_monthly_allotment: Decimal,
    pub ebt_account_id: Option<String>,
    pub expedited: bool,
    pub initial_issuance_due_date: NaiveDate,
    pub initial_issuance_date: Option<NaiveDate>,
    pub status: String,
    pub suspended_reason: Option<String>,
    pub terminated_reason: Option<String>,
    pub terminated_date: Option<NaiveDate>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub active: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
pub struct SnapBenefitIssuance { /* all columns from snap_benefit_issuances table */ }

// SPDX-License-Identifier: AGPL-3.0-or-later

use axum::{Router, routing::{get, post, put}, extract::{Path, Query, State}, Json};
use canopy_api::AppState;

pub fn routes() -> Router<AppState> {
    Router::new()
        .route("/v1/enrollments/snap", get(get_snap_enrollment))         // Query: household_id
        .route("/v1/enrollments/snap/:id/issuances", get(list_issuances))
        .route("/v1/enrollments/snap/:id/issue", post(worker_issue))     // canopy-snap-supervisor
        .route("/v1/enrollments/snap/:id/suspend", put(suspend_enrollment)) // canopy-snap-supervisor
        .route("/v1/enrollments/snap/:id/terminate", put(terminate_enrollment)) // canopy-snap-supervisor
        .route("/v1/enrollments/snap/queue", get(pending_issuance_queue)) // canopy-snap-supervisor
}

pub async fn handle_determination_completed(event: DeterminationCompletedEvent, pipeline: &IssuancePipeline) -> Result<()> {
    match event.status.as_str() {
        "approved" => pipeline.handle_determination_approved(event).await,
        "terminated" | "denied" => pipeline.handle_enrollment_termination(event).await,
        _ => Ok(()),
    }
}

pub async fn handle_continued_benefits_granted(event: ContinuedBenefitsEvent, pool: &PgPool) -> Result<()> {
    // Cancel any scheduled termination for the enrollment; set status back to 'active'
}

pub async fn handle_decision_reversed(event: DecisionReversedEvent, pipeline: &IssuancePipeline) -> Result<()> {
    // Re-activate enrollment if terminated; recalculate allotment
}

// SPDX-License-Identifier: AGPL-3.0-or-later

use canopy_test_lib::{setup_test_db, setup_test_mq, mock_event_publisher};
use crate::ebt::NoopEbtAdapter;
use crate::issuance::IssuancePipeline;

#[tokio::test]
async fn test_determination_approved_creates_enrollment() {
    // Publish determination.completed event with status="approved", expedited=false
    // Assert: snap_enrollment record created with status="active"
    // Assert: ebt_account_id set to "NOOP-{enrollment_id}" (NoopEbtAdapter)
    // Assert: initial_issuance_date set
    // Assert: snap_benefit_issuance record created for first benefit month
    // Assert: enrollment.snap_issued event published
}

#[tokio::test]
async fn test_initial_issuance_prorated() {
    // Setup: application_date = 15th of a 30-day month, max_allotment = $300
    // Assert: first month allotment = $300 * (16/30) = $160.00
    // Assert: prorated = true, proration_days_remaining = 16, proration_days_total = 30
}

#[tokio::test]
async fn test_initial_issuance_first_of_month_no_proration() {
    // Setup: application_date = 1st of month
    // Assert: allotment = full max_allotment
    // Assert: prorated = false
}

#[tokio::test]
async fn test_expedited_issuance_within_7_days() {
    // Setup: expedited = true, application_date = today
    // Assert: initial_issuance_due_date = today + 7
    // Assert: issuance created and issued immediately
}

#[tokio::test]
async fn test_continued_benefits_cancels_termination() {
    // Setup: enrollment with status="active", scheduled termination
    // Publish appeal.continued_benefits_granted event
    // Assert: enrollment status remains "active" (termination cancelled)
}

#[tokio::test]
async fn test_decision_reversed_reactivates_enrollment() {
    // Setup: enrollment with status="terminated"
    // Publish appeal.decision_reversed event
    // Assert: enrollment status set back to "active"
}

#[tokio::test]
async fn test_expungement_30_day_notice() {
    // Setup: issuance with expiry_date = today + 30, expungement_notice_sent_at = NULL
    // Run ExpungementJob::send_expungement_notices()
    // Assert: enrollment.expungement_pending event published
    // Assert: expungement_notice_sent_at set on issuance record
}

#[tokio::test]
async fn test_expungement_on_expiry_date() {
    // Setup: issuance with expiry_date = today, expunged_at = NULL
    // Run ExpungementJob::run_expungements()
    // Assert: EbtAdapter::get_balance called
    // Assert: EbtAdapter::expunge_benefits called
    // Assert: expunged_at set, expunged_amount recorded
    // Assert: enrollment.benefits_expunged event published
}

#[tokio::test]
async fn test_issuance_history_api() {
    // Insert enrollment with 3 issuances (1 prorated, 2 full)
    // GET /v1/enrollments/snap/{id}/issuances
    // Assert: 3 issuances returned with correct proration details
}

#[tokio::test]
async fn test_pending_issuance_queue() {
    // Insert enrollment with initial_issuance_date = NULL, initial_issuance_due_date = yesterday
    // GET /v1/enrollments/snap/queue
    // Assert: enrollment appears in queue
}