Plan: Application Intake (canopy-applications)

submitted → processing → [determination complete] → complete
         ↘ withdrawn (household withdraws before determination)
         ↘ abandoned (no household contact, timed out)

pending → [determination from orchestrator] → approved | denied | withdrawn

CREATE TABLE applications (
    id UUID PRIMARY KEY,
    household_id UUID NOT NULL,
    submitted_by UUID NOT NULL,              -- person_id of submitter
    authorized_representative_id UUID,       -- set if submitted by someone other than household
    programs_requested TEXT[] NOT NULL,      -- array of Program enum values
    submission_channel TEXT NOT NULL,        -- 'online', 'phone', 'in_person', 'mail'
    submitted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    received_at TIMESTAMPTZ NOT NULL DEFAULT now(),  -- may differ from submitted_at for mail
    status TEXT NOT NULL DEFAULT 'submitted',
    -- 'submitted', 'processing', 'complete', 'withdrawn', 'abandoned'
    interview_required BOOLEAN NOT NULL DEFAULT true,
    interview_completed_at TIMESTAMPTZ,
    interview_waived BOOLEAN NOT NULL DEFAULT false,
    interview_waived_reason TEXT,
    expedited_screened_at TIMESTAMPTZ,
    expedited_eligible BOOLEAN,
    expedited_basis TEXT,                    -- 'low_income_assets', 'income_vs_expenses', 'migrant_farmworker'
    -- NOTE: processing_deadline has moved to application_programs (per-program).
    -- Each program has a different federal timeline. See application_programs table.
    submitted_by_role TEXT NOT NULL DEFAULT 'worker',
    -- 'applicant', 'worker', 'authorized_rep', 'agency_system' — required for audit/appeals
    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    active BOOLEAN NOT NULL DEFAULT true
);

CREATE INDEX applications_household_idx ON applications (household_id);
CREATE INDEX applications_status_idx ON applications (status) WHERE active = true;

CREATE TABLE application_programs (
    id UUID PRIMARY KEY,
    application_id UUID NOT NULL REFERENCES applications(id),
    program TEXT NOT NULL,
    status TEXT NOT NULL DEFAULT 'pending',  -- 'pending', 'approved', 'denied', 'withdrawn'
    determination_id UUID,
    determination_received_at TIMESTAMPTZ,
    denial_reason_codes TEXT[],
    -- Per-program processing deadline (different programs have different federal timelines)
    -- SNAP: received_at + 30 days (7 days if expedited) per 7 CFR 273.2(g)
    -- TANF: received_at + 30 days per 45 CFR 206.10(a)(3)
    -- Medicaid: received_at + 45 days (90 days if disability determination) per 42 CFR 435.912
    -- CHIP: received_at + 45 days per 42 CFR 457.340(d)
    processing_deadline DATE,
    -- TANF-only: distinguish cash assistance (subject to time limits, WPR, ACF-199) from
    -- non-assistance services (employment prep, transportation, one-time diversion).
    -- Non-assistance is NOT subject to 60-month limit, WPR, or most 42 USC §608 prohibitions.
    -- Also used by SNAP categorical eligibility: TANF non-cash triggers BBCE.
    -- Values: 'assistance', 'non_assistance'. NULL for non-TANF programs.
    tanf_service_type TEXT,
    active BOOLEAN NOT NULL DEFAULT true,
    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

CREATE UNIQUE INDEX application_programs_unique ON application_programs (application_id, program) WHERE active = true;

CREATE TABLE authorized_representatives (
    id UUID PRIMARY KEY,
    household_id UUID NOT NULL,
    representative_person_id UUID NOT NULL,
    relationship TEXT NOT NULL,  -- 'authorized_rep', 'legal_guardian', 'power_of_attorney', 'agency_rep'
    written_consent_on_file BOOLEAN NOT NULL DEFAULT false,
    effective_date DATE NOT NULL,
    expiration_date DATE,
    active BOOLEAN NOT NULL DEFAULT true,
    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

CREATE INDEX auth_reps_household_idx ON authorized_representatives (household_id) WHERE active = true;

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

// POST /v1/applications request body
pub struct CreateApplicationRequest {
    pub household_id: Uuid,
    pub programs_requested: Vec<canopy_reference::Program>,
    pub submission_channel: SubmissionChannel,
    pub authorized_representative_id: Option<Uuid>,
    pub received_at: Option<chrono::DateTime<chrono::Utc>>, // for mail/phone backdate
    pub submitted_by_role: SubmitterRole,
    /// Self-reported data for expedited screening (7 CFR 273.2(i)).
    /// Required when SNAP is in programs_requested; ignored for other programs.
    /// Uses applicant-attested values, NOT data from canopy-persons (ADR-001).
    pub expedited_screening_data: Option<ExpeditedScreeningData>,
    /// TANF-only: 'assistance' (cash) or 'non_assistance' (employment services, diversion).
    /// Required when TANF is in programs_requested; ignored for other programs.
    pub tanf_service_type: Option<TanfServiceType>,
}

pub enum SubmitterRole {
    Applicant,
    Worker,
    AuthorizedRep,
    AgencySystem,
}

pub enum TanfServiceType {
    Assistance,
    NonAssistance,
}

/// Self-reported data used ONLY for expedited screening (7 CFR 273.2(i)).
/// These are applicant attestations, not verified data.
pub struct ExpeditedScreeningData {
    pub gross_monthly_income: rust_decimal::Decimal,
    pub liquid_resources: rust_decimal::Decimal,
    pub monthly_rent_or_mortgage: rust_decimal::Decimal,
    pub monthly_utility_costs: rust_decimal::Decimal,
    pub is_migrant_farmworker: bool,
}

pub enum SubmissionChannel {
    Online,
    Phone,
    InPerson,
    Mail,
}

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

// GET /v1/applications/{id} response
pub struct ApplicationResponse {
    pub id: Uuid,
    pub household_id: Uuid,
    pub submitted_by: Uuid,
    pub programs: Vec<ApplicationProgramResponse>,
    pub submission_channel: SubmissionChannel,
    pub submitted_at: DateTime<Utc>,
    pub status: ApplicationStatus,
    pub interview_required: bool,
    pub interview_completed_at: Option<DateTime<Utc>>,
    pub interview_waived: bool,
    pub expedited_eligible: Option<bool>,
    pub processing_deadline: Option<NaiveDate>,
}

pub struct ApplicationProgramResponse {
    pub program: canopy_reference::Program,
    pub status: ProgramApplicationStatus,
    pub determination_id: Option<Uuid>,
}

// application.submitted
{
    "application_id": "uuid",
    "household_id": "uuid",
    "programs_requested": ["snap", "medicaid"],
    "submission_channel": "online",
    "submitted_at": "2026-04-15T14:30:00Z"
}

// application.expedited_identified
{
    "application_id": "uuid",
    "household_id": "uuid",
    "expedited_basis": "low_income_assets",
    "processing_deadline": "2026-04-22"
}

// application.status_changed
{
    "application_id": "uuid",
    "old_status": "submitted",
    "new_status": "processing"
}

// application.withdrawn
{
    "application_id": "uuid",
    "household_id": "uuid",
    "withdrawn_at": "2026-04-16T10:00:00Z"
}

boot.db.run_migrations().await.context("database migration failed")?;

pub struct ApplicationStore {
    pool: sqlx::PgPool,
}

impl ApplicationStore {
    pub async fn create(&self, req: &CreateApplicationRequest, expedited_result: ExpeditedResult) -> anyhow::Result<Application>;
    pub async fn get_by_id(&self, id: Uuid) -> anyhow::Result<Option<Application>>;
    pub async fn list_by_household(&self, household_id: Uuid, page: &Paginator) -> anyhow::Result<Vec<Application>>;
    pub async fn update_status(&self, id: Uuid, status: ApplicationStatus) -> anyhow::Result<()>;
    pub async fn withdraw(&self, id: Uuid) -> anyhow::Result<()>;
    pub async fn waive_interview(&self, id: Uuid, reason: &str) -> anyhow::Result<()>;
    pub async fn complete_interview(&self, id: Uuid, completed_at: DateTime<Utc>) -> anyhow::Result<()>;
    pub async fn record_determination(&self, id: Uuid, program: Program, det_id: Uuid, status: ProgramApplicationStatus, denial_codes: Vec<String>) -> anyhow::Result<()>;
}

pub struct ExpeditedScreener {
    persons_client: PersonsClient,  // HTTP client for canopy-persons
}

impl ExpeditedScreener {
    pub async fn screen(&self, household_id: Uuid, channel: &SubmissionChannel) -> ExpeditedResult;
}

pub struct ExpeditedResult {
    pub eligible: Option<bool>,  // None if screening could not complete
    pub basis: Option<ExpeditedBasis>,
}

pub enum ExpeditedBasis {
    LowIncomeAndAssets,   // income < $150 AND assets < $100
    IncomeVsExpenses,     // income + assets < rent + utilities
    MigrantFarmworker,
}

pub fn routes() -> Router<AppState> {
    Router::new()
        .route("/v1/applications", post(create_application).get(list_applications))
        .route("/v1/applications/:id", get(get_application).put(update_application).delete(withdraw_application))
        .route("/v1/applications/:id/interview/waive", post(waive_interview))
        .route("/v1/applications/:id/interview/complete", post(complete_interview))
        .route("/v1/applications/:id/programs/:program/determination", post(record_determination))
}