Plan: Notice Generation (SNAP First)

CREATE TABLE notices (
    id UUID PRIMARY KEY,
    household_id UUID NOT NULL,
    recipient_person_id UUID NOT NULL,
    notice_type TEXT NOT NULL,           -- NoticeType enum value
    program TEXT,                        -- Program enum value; null for cross-program notices
    application_id UUID,
    determination_id UUID,
    subject TEXT NOT NULL,
    body_text TEXT NOT NULL,             -- plain text body (required)
    body_html TEXT,                      -- HTML body for email/portal (optional)
    locale TEXT NOT NULL DEFAULT 'en-US',
    regulatory_basis TEXT NOT NULL,      -- e.g., '7 CFR 273.13(a)'
    effective_date DATE,                 -- date adverse action takes effect; null for non-adverse
    notice_date DATE NOT NULL,           -- date notice generated
    advance_notice_days INTEGER,         -- days between notice_date and effective_date
    advance_notice_adjusted BOOLEAN NOT NULL DEFAULT false,
    -- true if effective_date was pushed forward to comply with 10-day rule
    delivery_status TEXT NOT NULL DEFAULT 'pending',
    -- 'pending', 'queued', 'sent', 'delivered', 'failed', 'suppressed'
    delivered_at TIMESTAMPTZ,
    delivery_channel TEXT DEFAULT 'test',
    -- 'mail', 'email', 'portal', 'test'
    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    active BOOLEAN NOT NULL DEFAULT true
);

CREATE INDEX notices_household_idx ON notices (household_id);
CREATE INDEX notices_delivery_status_idx ON notices (delivery_status) WHERE delivery_status = 'pending';

CREATE TABLE notice_appeals_rights (
    id UUID PRIMARY KEY,
    notice_id UUID NOT NULL REFERENCES notices(id),
    hearing_request_deadline DATE NOT NULL,  -- notice_date + 90 days for SNAP
    continued_benefits_available BOOLEAN NOT NULL DEFAULT false,
    continued_benefits_request_deadline DATE,  -- must request BEFORE effective_date
    hearing_phone TEXT NOT NULL,  -- loaded from jurisdiction.toml [notices] hearing_phone
    hearing_address TEXT,
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

NOTICE OF ACTION — FOOD STAMP BENEFITS APPROVED

Date: {{ notice_date }}
Case Number: {{ household_id }}
Head of Household: {{ recipient_name }}

YOUR APPLICATION FOR FOOD STAMP BENEFITS HAS BEEN APPROVED.

Benefit Amount: ${{ benefit_amount }} per month
Effective Date: {{ effective_date }}
Certification Period: {{ cert_start_date }} to {{ cert_end_date }}

... [hearing rights per 7 CFR 273.13] ...

NOTICE OF ACTION — FOOD STAMP BENEFITS DENIED

...
REASON FOR DENIAL:

Your household's income exceeds the gross income limit for your household size.

Regulatory basis: {{ regulatory_basis }}
Gross monthly income: [not included — never include income amounts in notices stored in shared DB]
Income limit for household of {{ household_size }}: See attached tables

... [hearing rights with continued benefits not available since denied] ...

pub trait NoticeDeliveryAdapter: Send + Sync {
    async fn deliver(&self, notice: &Notice) -> Result<DeliveryResult>;
}

pub struct TestDeliveryAdapter; // Records delivery attempt, returns success
pub struct MailDeliveryAdapter { /* future */ }
pub struct EmailDeliveryAdapter { /* future */ }

CREATE INDEX notices_household_idx ON notices (household_id);
CREATE INDEX notices_delivery_status_idx ON notices (delivery_status) WHERE delivery_status = 'pending';
CREATE INDEX notices_recipient_idx ON notices (recipient_person_id);
CREATE INDEX notices_determination_idx ON notices (determination_id) WHERE determination_id IS NOT NULL;
CREATE INDEX notice_appeals_rights_notice_idx ON notice_appeals_rights (notice_id);

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

use canopy_mq::subscriber::{EventSubscriber, EventHandler};
use canopy_mq::envelope::Envelope;
use uuid::Uuid;

/// Event payloads received from canopy.events topic exchange.
/// Per ADR-004: no personal data, income amounts, or SSNs in events.
#[derive(Debug, Deserialize)]
pub struct DeterminationCompletedEvent {
    pub determination_id: Uuid,
    pub household_id: Uuid,
    pub program: String,
    pub status: String,  // "approved", "denied", "PendingVerification"
}

#[derive(Debug, Deserialize)]
pub struct AdverseActionPendingEvent {
    pub household_id: Uuid,
    pub determination_id: Uuid,
    pub effective_date: NaiveDate,
    pub reason: String,
}

#[derive(Debug, Deserialize)]
pub struct AbawdWarningEvent {
    pub person_id: Uuid,
    pub household_id: Uuid,
    pub months_used: i32,
}

pub async fn handle_determination_completed(envelope: Envelope<DeterminationCompletedEvent>, generator: &NoticeGenerator) -> Result<()> {
    match envelope.payload.status.as_str() {
        "approved" => generator.generate_snap_approval(envelope.payload.determination_id, envelope.payload.household_id).await?,
        "denied" => generator.generate_snap_denial(envelope.payload.determination_id, envelope.payload.household_id, vec![]).await?,
        "PendingVerification" => generator.generate_snap_pending(envelope.payload.determination_id, envelope.payload.household_id).await?,
        _ => tracing::warn!(status = %envelope.payload.status, "Unknown determination status; no notice generated"),
    };
    Ok(())
}
// ... additional handlers for each event type

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

use askama::Template;
use chrono::NaiveDate;
use uuid::Uuid;

#[derive(Template)]
#[template(path = "snap/snap_approval.txt")]
pub struct SnapApprovalTemplate {
    pub notice_date: NaiveDate,
    pub household_id: Uuid,
    pub recipient_name: String,
    pub benefit_amount: String,  // formatted currency
    pub effective_date: NaiveDate,
    pub cert_start_date: NaiveDate,
    pub cert_end_date: NaiveDate,
    pub regulatory_basis: String,
    pub hearing_phone: String,
}

#[derive(Template)]
#[template(path = "snap/snap_denial.txt")]
pub struct SnapDenialTemplate {
    pub notice_date: NaiveDate,
    pub household_id: Uuid,
    pub recipient_name: String,
    pub denial_reason: String,
    pub household_size: i32,
    pub regulatory_basis: String,
    pub hearing_phone: String,
}

#[derive(Template)]
#[template(path = "snap/snap_termination.txt")]
pub struct SnapTerminationTemplate {
    pub notice_date: NaiveDate,
    pub household_id: Uuid,
    pub recipient_name: String,
    pub effective_date: NaiveDate,
    pub reason: String,
    pub regulatory_basis: String,
    pub continued_benefits_deadline: NaiveDate,
    pub hearing_phone: String,
}
// ... additional template structs for abawd_warning, expedited, expungement

pub struct NoticeGenerator {
    persons_client: PersonsClient,
    delivery: Box<dyn NoticeDeliveryAdapter>,
    store: NoticeStore,
}

impl NoticeGenerator {
    pub async fn generate_snap_approval(&self, determination_id: Uuid, household_id: Uuid) -> Result<Uuid>;
    pub async fn generate_snap_denial(&self, determination_id: Uuid, household_id: Uuid, denial_codes: Vec<String>) -> Result<Uuid>;
    pub async fn generate_snap_termination(&self, household_id: Uuid, effective_date: NaiveDate, reason: String) -> Result<Uuid>;
    // ... one method per notice type
}

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

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

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

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

use crate::store::models::Notice;
use anyhow::Result;

pub struct DeliveryResult {
    pub delivered: bool,
    pub channel: String,
    pub error: Option<String>,
}

pub trait NoticeDeliveryAdapter: Send + Sync {
    async fn deliver(&self, notice: &Notice) -> Result<DeliveryResult>;
}

pub struct TestDeliveryAdapter;

impl NoticeDeliveryAdapter for TestDeliveryAdapter {
    async fn deliver(&self, _notice: &Notice) -> Result<DeliveryResult> {
        Ok(DeliveryResult { delivered: true, channel: "test".into(), error: None })
    }
}

pub fn routes() -> Router<AppState> {
    Router::new()
        .route("/v1/notices", get(list_notices))           // Query: household_id
        .route("/v1/notices/:id", get(get_notice))
        .route("/v1/notices/:id/resend", post(resend_notice))
        .route("/v1/notices/:id/preview", get(preview_notice))
        .route("/v1/notices/queue", get(delivery_queue))   // canopy-snap-supervisor
}

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

use canopy_test_lib::{setup_test_db, setup_test_mq};

#[tokio::test]
async fn test_determination_approved_creates_approval_notice() {
    // Publish determination.completed event with status="approved"
    // Assert: notice record in DB with notice_type="ApprovalNotice", program="snap"
    // Assert: notice body contains regulatory_basis "7 CFR 273.13(a)"
    // Assert: notice_appeals_rights record created with hearing_request_deadline = notice_date + 90
}

#[tokio::test]
async fn test_termination_10_day_enforcement() {
    // Publish determination.adverse_action_pending with effective_date = today + 5
    // Assert: effective_date adjusted to today + 11
    // Assert: advance_notice_adjusted = true
    // Assert: notice.advance_notice_adjusted event published
    // Assert: continued_benefits_request_deadline = adjusted_effective_date - 1
}

#[tokio::test]
async fn test_termination_sufficient_notice() {
    // Publish determination.adverse_action_pending with effective_date = today + 15
    // Assert: effective_date NOT adjusted (15 >= 10)
    // Assert: advance_notice_adjusted = false
}

#[tokio::test]
async fn test_denial_notice_no_income_in_body() {
    // Publish determination.completed with status="denied"
    // Assert: notice body does NOT contain dollar amounts or income figures
    // Assert: body references "exceeds the limit" generically
}

#[tokio::test]
async fn test_list_notices_api() {
    // Insert 3 notices for household_id
    // GET /v1/notices?household_id={id}
    // Assert: 3 notices returned, newest first
}

#[tokio::test]
async fn test_delivery_adapter_called() {
    // Generate a notice with TestDeliveryAdapter
    // Assert: delivery_status = 'sent', delivered_at is set
}

#[tokio::test]
async fn test_abawd_warning_month_1() {
    // Publish abawd.warning_month_1 event
    // Assert: AbawdNotice created with month_1 warning content
}