Data Exchange Adapters

/// Adapter factory — returns the appropriate adapter for a partner type.
pub fn adapter_for(partner_type: &str, exchange_format: &str) -> Box<dyn ExchangeAdapter> {
    match partner_type {
        "cwca_provider" => Box::new(CwcaAdapter::new(exchange_format)),
        "financial" => Box::new(FinancialAdapter::new()),
        "medicaid" => Box::new(MedicaidAdapter::new()),
        "child_abuse_registry" => Box::new(ChildAbuseAdapter::new()),
        "tanf" => Box::new(TanfAdapter::new()),
        "child_support" => Box::new(ChildSupportAdapter::new()),
        "external_data" => Box::new(ExternalDataAdapter::new()),
        "court_system" => Box::new(CourtAdapter::new()),
        "education" => Box::new(EducationAdapter::new()),
        "health_agency" => Box::new(HealthAdapter::new()),
        "tribal" => Box::new(TribalAdapter::new()),
        _ => Box::new(NoopAdapter),
    }
}

adapters/
  mod.rs          — trait + factory
  noop.rs         — existing NoopAdapter
  cwca.rs         — CWCA adapter
  financial.rs    — Title IV-B/IV-E
  medicaid.rs     — Medicaid eligibility
  child_abuse.rs  — Central registry
  tanf.rs         — TANF/Title IV-A
  child_support.rs — Title IV-D
  external_data.rs — External data collection
  court.rs        — Court system
  education.rs    — Education system
  health.rs       — Health agency
  tribal.rs       — Tribal entity
  mapping/
    mod.rs        — shared mapping utilities
    person.rs     — person data mapping (used by all adapters)
    afcars.rs     — AFCARS code translation (reuses craig-reference)
    ncands.rs     — NCANDS code translation (reuses craig-reference)

pub struct CwcaAdapter {
    format: String,  // "json", "xml", "flat_file"
}

impl CwcaAdapter {
    pub fn new(format: &str) -> Self {
        Self { format: format.to_string() }
    }

    /// Transform CRAIG internal JSON into CWCA exchange format.
    fn transform_outbound(&self, payload: &Value) -> Result<Value, String> {
        let exchange_type = payload["exchange_type"].as_str().unwrap_or("case_data");
        match exchange_type {
            "case_data" => mapping::cwca::map_case_data(payload),
            "service_record" => mapping::cwca::map_service_record(payload),
            "placement_notification" => mapping::cwca::map_placement(payload),
            _ => Err(format!("unsupported CWCA exchange type: {exchange_type}")),
        }
    }

    /// Transform inbound CWCA data into CRAIG internal format.
    pub fn transform_inbound(&self, payload: &Value) -> Result<Value, String> {
        mapping::cwca::parse_inbound(payload)
    }
}

impl ExchangeAdapter for CwcaAdapter {
    async fn test_connectivity(&self, endpoint_url: &str) -> Result<String, String> {
        let client = reqwest::Client::new();
        let resp = client.get(format!("{endpoint_url}/health"))
            .timeout(std::time::Duration::from_secs(5))
            .send()
            .await
            .map_err(|e| e.to_string())?;
        Ok(format!("status: {}", resp.status()))
    }

    async fn send(&self, endpoint_url: &str, payload: &Value) -> Result<Value, String> {
        let transformed = self.transform_outbound(payload)?;
        let client = reqwest::Client::new();
        let resp = client.post(endpoint_url)
            .json(&transformed)
            .timeout(std::time::Duration::from_secs(30))
            .send()
            .await
            .map_err(|e| e.to_string())?;

        if !resp.status().is_success() {
            let body = resp.text().await.unwrap_or_default();
            return Err(format!("HTTP {}: {body}", resp.status()));
        }
        resp.json().await.map_err(|e| e.to_string())
    }
}

// Routes:
// POST /exchange/{adapter_type} — validate payload, return mock response
// GET /health — connectivity test endpoint
// GET /received — list received payloads (for test assertions)

pub async fn receive_exchange(
    State(app): State<AppState>,
    Extension(partner): Extension<ValidatedPartner>,  // from API key middleware
    Json(payload): Json<Value>,
) -> Result<Json<Value>, ApiError> {
    let adapter = adapter_for(&partner.partner_type, &partner.exchange_format);
    let normalized = adapter.transform_inbound(&payload)
        .map_err(|e| ApiError::BadRequest(format!("invalid payload: {e}")))?;

    let tx = store::transactions::create_inbound_transaction(
        app.db.inner(), partner.id, &normalized, payload.clone()
    ).await.map_err(|e| ApiError::Internal(e.to_string()))?;

    events::publish_exchange_received(&publisher, tx.id, partner.id).await;

    Ok(Json(json!({ "status": "accepted", "transaction_id": tx.id })))
}

ALTER TABLE exchange_partners DROP CONSTRAINT IF EXISTS exchange_partners_partner_type_check;
ALTER TABLE exchange_partners ADD CONSTRAINT exchange_partners_partner_type_check
    CHECK (partner_type IN (
        'state_agency', 'court_system', 'federal_agency', 'tribal_authority', 'private_provider',
        'cwca_provider', 'financial', 'medicaid', 'child_abuse_registry',
        'tanf', 'child_support', 'external_data', 'education', 'health_agency'
    ));