Plan: WIC Eligibility (canopy-wic)

// services/canopy-wic/src/store/models.rs
// SPDX-License-Identifier: AGPL-3.0-or-later

use chrono::{DateTime, NaiveDate, Utc};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

#[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
pub struct WicParticipant {
    pub id: Uuid,
    pub person_id: Uuid,
    pub participant_category: String,  // pregnant, postpartum, breastfeeding, infant, child
    pub certification_start: NaiveDate,
    pub certification_end: NaiveDate,
    pub food_package: String,          // I, II, III, IV, V, VI, VII
    pub status: String,                // active, expired, terminated, transferred
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
pub struct WicDetermination {
    pub id: Uuid,
    pub application_id: Uuid,
    pub household_id: Uuid,
    pub person_id: Uuid,
    pub determination_status: String,
    pub categorical_eligible: bool,
    pub income_eligible: bool,
    pub adjunctive_eligible: bool,
    pub adjunctive_program: Option<String>,
    pub nutritional_risk_documented: bool,
    pub participant_category: Option<String>,
    pub food_package: Option<String>,
    pub effective_date: NaiveDate,
    pub end_date: Option<NaiveDate>,
    pub ruleset_version: String,
    pub jws_token: Option<String>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
pub struct WicNutritionalRiskAssessment {
    pub id: Uuid,
    pub person_id: Uuid,
    pub assessment_date: NaiveDate,
    pub assessor_worker_id: Uuid,
    pub anthropometric_risk: bool,
    pub biochemical_risk: bool,
    pub dietary_risk: bool,
    pub medical_risk: bool,
    pub risk_codes: Vec<String>,
    pub notes: Option<String>,
    pub created_at: DateTime<Utc>,
}

// services/canopy-wic/src/store/determinations.rs
// SPDX-License-Identifier: AGPL-3.0-or-later

use sqlx::PgPool;
use uuid::Uuid;
use super::models::WicDetermination;

pub async fn create_determination(
    pool: &PgPool,
    det: &WicDetermination,
) -> Result<WicDetermination, sqlx::Error> {
    sqlx::query_as::<_, WicDetermination>(
        r#"INSERT INTO wic_determinations
           (id, application_id, household_id, person_id, determination_status,
            categorical_eligible, income_eligible, adjunctive_eligible, adjunctive_program,
            nutritional_risk_documented, participant_category, food_package,
            effective_date, end_date, ruleset_version, jws_token)
           VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16)
           RETURNING *"#,
    )
    .bind(det.id).bind(det.application_id).bind(det.household_id).bind(det.person_id)
    .bind(&det.determination_status).bind(det.categorical_eligible)
    .bind(det.income_eligible).bind(det.adjunctive_eligible)
    .bind(&det.adjunctive_program).bind(det.nutritional_risk_documented)
    .bind(&det.participant_category).bind(&det.food_package)
    .bind(det.effective_date).bind(det.end_date)
    .bind(&det.ruleset_version).bind(&det.jws_token)
    .fetch_one(pool)
    .await
}

pub async fn get_determination(
    pool: &PgPool,
    id: Uuid,
) -> Result<Option<WicDetermination>, sqlx::Error> {
    sqlx::query_as::<_, WicDetermination>(
        "SELECT * FROM wic_determinations WHERE id = $1",
    )
    .bind(id)
    .fetch_optional(pool)
    .await
}

pub async fn list_determinations_by_person(
    pool: &PgPool,
    person_id: Uuid,
) -> Result<Vec<WicDetermination>, sqlx::Error> {
    sqlx::query_as::<_, WicDetermination>(
        "SELECT * FROM wic_determinations WHERE person_id = $1 ORDER BY created_at DESC",
    )
    .bind(person_id)
    .fetch_all(pool)
    .await
}

// services/canopy-wic/src/store/participants.rs
// SPDX-License-Identifier: AGPL-3.0-or-later

use sqlx::PgPool;
use uuid::Uuid;
use super::models::WicParticipant;

pub async fn create_participant(
    pool: &PgPool,
    p: &WicParticipant,
) -> Result<WicParticipant, sqlx::Error> {
    sqlx::query_as::<_, WicParticipant>(
        r#"INSERT INTO wic_participants
           (id, person_id, participant_category, certification_start, certification_end,
            food_package, status)
           VALUES ($1,$2,$3,$4,$5,$6,$7)
           RETURNING *"#,
    )
    .bind(p.id).bind(p.person_id).bind(&p.participant_category)
    .bind(p.certification_start).bind(p.certification_end)
    .bind(&p.food_package).bind(&p.status)
    .fetch_one(pool)
    .await
}

pub async fn get_active_participant(
    pool: &PgPool,
    person_id: Uuid,
) -> Result<Option<WicParticipant>, sqlx::Error> {
    sqlx::query_as::<_, WicParticipant>(
        "SELECT * FROM wic_participants WHERE person_id = $1 AND status = 'active' ORDER BY certification_end DESC LIMIT 1",
    )
    .bind(person_id)
    .fetch_optional(pool)
    .await
}

// services/canopy-wic/src/eligibility.rs
// SPDX-License-Identifier: AGPL-3.0-or-later

use chrono::{NaiveDate, Utc};
use serde::{Deserialize, Serialize};
use sqlx::PgPool;
use uuid::Uuid;

use crate::errors::ApiError;
use crate::food_package::assign_food_package;
use crate::certification::compute_certification_end;
use crate::store;
use crate::store::models::{WicDetermination, WicParticipant};

/// Input received from canopy-eligibility via POST /v1/wic/evaluate.
#[derive(Debug, Clone, Deserialize)]
pub struct WicEvaluationRequest {
    pub application_id: Uuid,
    pub household_id: Uuid,
    pub person_id: Uuid,
    pub participant_category: String,    // pregnant, postpartum, breastfeeding, infant, child
    pub household_size: u32,
    pub gross_monthly_income: f64,
    pub jurisdiction: String,
}

/// Output returned to canopy-eligibility.
#[derive(Debug, Clone, Serialize)]
pub struct WicEvaluationResponse {
    pub determination_id: Uuid,
    pub determination_status: String,
    pub categorical_eligible: bool,
    pub income_eligible: bool,
    pub adjunctive_eligible: bool,
    pub nutritional_risk_documented: bool,
    pub participant_category: Option<String>,
    pub food_package: Option<String>,
    pub effective_date: NaiveDate,
    pub end_date: Option<NaiveDate>,
    pub jws_token: Option<String>,
}

/// Adjunctive eligibility client trait.
/// Calls canopy-eligibility cross-program enrollment API.
/// Returns only enrolled/not-enrolled per ADR-001 — no income data,
/// no determination details from other programs.
#[trait_variant::make(Send)]
pub trait AdjunctiveClient: Send + Sync {
    async fn check_enrollment(
        &self,
        person_id: Uuid,
        program: &str,
    ) -> Result<bool, ApiError>;
}

/// Rules engine client trait. Evaluates JDM rulesets via canopy-rules.
#[trait_variant::make(Send)]
pub trait RulesClient: Send + Sync {
    async fn evaluate(
        &self,
        rule_set_name: &str,
        context_id: Uuid,
        input: serde_json::Value,
    ) -> Result<serde_json::Value, ApiError>;
}

/// Determination signer trait per ADR-002.
pub trait DeterminationSigner: Send + Sync {
    fn sign(&self, payload: &[u8]) -> Result<String, anyhow::Error>;
}

/// Core WIC eligibility evaluation.
///
/// Flow:
/// 1. Validate participant_category is one of: pregnant, postpartum, breastfeeding, infant, child
/// 2. Call canopy-rules with WIC categorical + income ruleset (185% FPL threshold)
/// 3. If income-ineligible, check adjunctive eligibility (SNAP, Medicaid, TANF enrollment)
/// 4. Check for documented nutritional risk assessment
/// 5. If all three pillars pass (categorical + income/adjunctive + nutritional risk): approved
/// 6. Assign food package, compute certification period, sign, persist
pub async fn evaluate(
    db: &PgPool,
    rules: &dyn RulesClient,
    adjunctive: &dyn AdjunctiveClient,
    signer: &dyn DeterminationSigner,
    req: WicEvaluationRequest,
) -> Result<WicEvaluationResponse, ApiError> {
    // 1. Validate participant category
    let valid_categories = ["pregnant", "postpartum", "breastfeeding", "infant", "child"];
    if !valid_categories.contains(&req.participant_category.as_str()) {
        return Err(ApiError::Validation(format!(
            "invalid participant_category: {}; must be one of: {}",
            req.participant_category,
            valid_categories.join(", ")
        )));
    }

    // 2. Evaluate categorical + income eligibility via canopy-rules
    let ruleset_name = format!("{}-wic-eligibility", req.jurisdiction);
    let rules_output = rules.evaluate(
        &ruleset_name,
        req.application_id,
        serde_json::json!({
            "participant_category": req.participant_category,
            "household_size": req.household_size,
            "gross_monthly_income": req.gross_monthly_income,
        }),
    ).await?;

    let categorical_eligible = rules_output.get("categorical_eligible")
        .and_then(|v| v.as_bool())
        .unwrap_or(false);
    let income_eligible = rules_output.get("income_eligible")
        .and_then(|v| v.as_bool())
        .unwrap_or(false);
    let ruleset_version = rules_output.get("ruleset_version")
        .and_then(|v| v.as_str())
        .unwrap_or("unknown")
        .to_string();

    // 3. If income-ineligible, check adjunctive eligibility
    let (adjunctive_eligible, adjunctive_program) = if !income_eligible {
        check_adjunctive(adjunctive, req.person_id).await?
    } else {
        (false, None)
    };

    let effectively_income_eligible = income_eligible || adjunctive_eligible;

    // 4. Check for documented nutritional risk assessment
    let assessment = store::assessments::get_latest_assessment(db, req.person_id).await
        .map_err(|e| ApiError::Internal(format!("failed to query assessments: {e}")))?;
    let nutritional_risk_documented = assessment
        .as_ref()
        .map(|a| a.anthropometric_risk || a.biochemical_risk || a.dietary_risk || a.medical_risk)
        .unwrap_or(false);

    // 5. Determine overall eligibility
    let approved = categorical_eligible && effectively_income_eligible && nutritional_risk_documented;
    let status = if approved { "approved" } else { "denied" };

    let now = Utc::now();
    let effective_date = now.date_naive();
    let (end_date, food_package, participant_category) = if approved {
        let end = compute_certification_end(&req.participant_category, effective_date);
        let pkg = assign_food_package(&req.participant_category);
        (Some(end), Some(pkg), Some(req.participant_category.clone()))
    } else {
        (None, None, None)
    };

    // 6. Build determination, sign, persist
    let det_id = Uuid::new_v4();
    let mut det = WicDetermination {
        id: det_id,
        application_id: req.application_id,
        household_id: req.household_id,
        person_id: req.person_id,
        determination_status: status.to_string(),
        categorical_eligible,
        income_eligible: effectively_income_eligible,
        adjunctive_eligible,
        adjunctive_program: adjunctive_program.clone(),
        nutritional_risk_documented,
        participant_category: participant_category.clone(),
        food_package: food_package.clone(),
        effective_date,
        end_date,
        ruleset_version,
        jws_token: None,
        created_at: now,
        updated_at: now,
    };

    // Sign before persisting — unsigned determinations must never exist in the database
    let payload = serde_json::to_vec(&det)
        .map_err(|e| ApiError::Internal(format!("serialization failed: {e}")))?;
    let token = signer.sign(&payload)
        .map_err(|e| ApiError::Internal(format!("signing failed: {e}")))?;
    det.jws_token = Some(token.clone());

    let persisted = store::determinations::create_determination(db, &det).await
        .map_err(|e| ApiError::Internal(format!("failed to persist determination: {e}")))?;

    Ok(WicEvaluationResponse {
        determination_id: persisted.id,
        determination_status: persisted.determination_status,
        categorical_eligible,
        income_eligible: effectively_income_eligible,
        adjunctive_eligible,
        nutritional_risk_documented,
        participant_category,
        food_package,
        effective_date,
        end_date,
        jws_token: Some(token),
    })
}

/// Check adjunctive eligibility by querying canopy-eligibility cross-program
/// enrollment API for SNAP, Medicaid, and TANF. Returns on first match.
/// Per ADR-001 this returns only enrolled/not-enrolled — no income data.
async fn check_adjunctive(
    client: &dyn AdjunctiveClient,
    person_id: Uuid,
) -> Result<(bool, Option<String>), ApiError> {
    for program in &["snap", "medicaid", "tanf"] {
        match client.check_enrollment(person_id, program).await {
            Ok(true) => return Ok((true, Some(program.to_string()))),
            Ok(false) => continue,
            Err(e) => {
                tracing::warn!(person_id = %person_id, program, error = %e,
                    "adjunctive check failed; continuing to next program");
                continue;
            }
        }
    }
    Ok((false, None))
}

// Input
{
  "participant_category": "pregnant",
  "household_size": 3,
  "gross_monthly_income": 2800.00
}
// Output
{
  "categorical_eligible": true,
  "income_eligible": true,
  "fpl_threshold_185": 3256.25,
  "ruleset_version": "wic-2026.1"
}

// services/canopy-wic/src/store/assessments.rs
// SPDX-License-Identifier: AGPL-3.0-or-later

use sqlx::PgPool;
use uuid::Uuid;
use super::models::WicNutritionalRiskAssessment;

pub async fn create_assessment(
    pool: &PgPool,
    a: &WicNutritionalRiskAssessment,
) -> Result<WicNutritionalRiskAssessment, sqlx::Error> {
    sqlx::query_as::<_, WicNutritionalRiskAssessment>(
        r#"INSERT INTO wic_nutritional_risk_assessments
           (id, person_id, assessment_date, assessor_worker_id,
            anthropometric_risk, biochemical_risk, dietary_risk, medical_risk,
            risk_codes, notes)
           VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10)
           RETURNING *"#,
    )
    .bind(a.id).bind(a.person_id).bind(a.assessment_date)
    .bind(a.assessor_worker_id)
    .bind(a.anthropometric_risk).bind(a.biochemical_risk)
    .bind(a.dietary_risk).bind(a.medical_risk)
    .bind(&a.risk_codes).bind(&a.notes)
    .fetch_one(pool)
    .await
}

pub async fn get_latest_assessment(
    pool: &PgPool,
    person_id: Uuid,
) -> Result<Option<WicNutritionalRiskAssessment>, sqlx::Error> {
    sqlx::query_as::<_, WicNutritionalRiskAssessment>(
        "SELECT * FROM wic_nutritional_risk_assessments WHERE person_id = $1 ORDER BY assessment_date DESC LIMIT 1",
    )
    .bind(person_id)
    .fetch_optional(pool)
    .await
}

pub async fn get_assessment(
    pool: &PgPool,
    id: Uuid,
) -> Result<Option<WicNutritionalRiskAssessment>, sqlx::Error> {
    sqlx::query_as::<_, WicNutritionalRiskAssessment>(
        "SELECT * FROM wic_nutritional_risk_assessments WHERE id = $1",
    )
    .bind(id)
    .fetch_optional(pool)
    .await
}

// services/canopy-wic/src/api/assessments.rs
// SPDX-License-Identifier: AGPL-3.0-or-later

use axum::{extract::{Path, State}, Json};
use chrono::NaiveDate;
use uuid::Uuid;

use crate::errors::ApiError;
use crate::state::WicState;
use crate::store;
use crate::store::models::WicNutritionalRiskAssessment;

#[derive(Debug, serde::Deserialize)]
pub struct CreateAssessmentRequest {
    pub person_id: Uuid,
    pub assessment_date: NaiveDate,
    pub assessor_worker_id: Uuid,
    pub anthropometric_risk: bool,
    pub biochemical_risk: bool,
    pub dietary_risk: bool,
    pub medical_risk: bool,
    pub risk_codes: Vec<String>,
    pub notes: Option<String>,
}

/// POST /v1/wic/assessments
///
/// Clinical staff records a nutritional risk assessment.
/// Validates that at least one risk type is documented.
pub async fn post_assessment(
    State(state): State<WicState>,
    Json(req): Json<CreateAssessmentRequest>,
) -> Result<Json<WicNutritionalRiskAssessment>, ApiError> {
    // Validate: at least one risk type must be true
    if !req.anthropometric_risk && !req.biochemical_risk
        && !req.dietary_risk && !req.medical_risk
    {
        return Err(ApiError::Validation(
            "at least one nutritional risk type must be documented (anthropometric, biochemical, dietary, or medical)".to_string(),
        ));
    }

    // Validate: risk_codes must not be empty when a risk type is flagged
    if req.risk_codes.is_empty() {
        return Err(ApiError::Validation(
            "risk_codes must contain at least one WIC risk factor code".to_string(),
        ));
    }

    let assessment = WicNutritionalRiskAssessment {
        id: Uuid::new_v4(),
        person_id: req.person_id,
        assessment_date: req.assessment_date,
        assessor_worker_id: req.assessor_worker_id,
        anthropometric_risk: req.anthropometric_risk,
        biochemical_risk: req.biochemical_risk,
        dietary_risk: req.dietary_risk,
        medical_risk: req.medical_risk,
        risk_codes: req.risk_codes,
        notes: req.notes,
        created_at: chrono::Utc::now(),
    };

    let persisted = store::assessments::create_assessment(&state.db, &assessment).await
        .map_err(|e| ApiError::Internal(format!("failed to persist assessment: {e}")))?;

    Ok(Json(persisted))
}

/// GET /v1/wic/assessments/{id}
pub async fn get_assessment(
    State(state): State<WicState>,
    Path(id): Path<Uuid>,
) -> Result<Json<WicNutritionalRiskAssessment>, ApiError> {
    let assessment = store::assessments::get_assessment(&state.db, id).await
        .map_err(|e| ApiError::Internal(format!("query failed: {e}")))?
        .ok_or(ApiError::NotFound(format!("assessment {id} not found")))?;
    Ok(Json(assessment))
}