agent-supplements-rec 0.1.0

use assert_cmd::Command;
use predicates::prelude::*;

fn cmd() -> Command {
    Command::cargo_bin("agent-supplements-rec").unwrap()
}

#[test]
fn test_agent_info() {
    cmd()
        .arg("agent-info")
        .assert()
        .success()
        .stdout(predicate::str::contains("\"name\": \"agent-supplements-rec\""))
        .stdout(predicate::str::contains("\"capabilities\""))
        .stdout(predicate::str::contains("supplement_recommendation"));
}

#[test]
fn test_list_all() {
    cmd()
        .args(["list", "--json"])
        .assert()
        .success()
        .stdout(predicate::str::contains("\"version\": \"1\""))
        .stdout(predicate::str::contains("\"status\": \"success\""))
        .stdout(predicate::str::contains("vitamin-d3-5000"));
}

#[test]
fn test_list_by_category() {
    cmd()
        .args(["list", "--json", "--category", "vitamin"])
        .assert()
        .success()
        .stdout(predicate::str::contains("vitamin-d3-5000"))
        .stdout(predicate::str::contains("vitamin-b12-methyl"))
        .stdout(predicate::str::contains("methylfolate-1000"));
}

#[test]
fn test_list_by_brand() {
    cmd()
        .args(["list", "--json", "--brand", "thorne"])
        .assert()
        .success()
        .stdout(predicate::str::contains("vitamin-d3-5000"))
        .stdout(predicate::str::contains("berberine-500"));
}

#[test]
fn test_list_by_biomarker() {
    cmd()
        .args(["list", "--json", "--biomarker", "fasting_glucose"])
        .assert()
        .success()
        .stdout(predicate::str::contains("magnesium-glycinate"))
        .stdout(predicate::str::contains("berberine-500"))
        .stdout(predicate::str::contains("chromium-picolinate"));
}

#[test]
fn test_show_product() {
    cmd()
        .args(["show", "--json", "vitamin-d3-5000"])
        .assert()
        .success()
        .stdout(predicate::str::contains("\"name\": \"Vitamin D3 5000 IU\""))
        .stdout(predicate::str::contains("vitamin_d"))
        .stdout(predicate::str::contains("\"brand_id\": \"thorne\""));
}

#[test]
fn test_show_product_not_found() {
    cmd()
        .args(["show", "--json", "nonexistent-product"])
        .assert()
        .failure()
        .code(3)
        .stderr(predicate::str::contains("Product not found"));
}

#[test]
fn test_search() {
    cmd()
        .args(["search", "--json", "magnesium"])
        .assert()
        .success()
        .stdout(predicate::str::contains("magnesium-glycinate"));
}

#[test]
fn test_search_by_biomarker() {
    cmd()
        .args(["search", "--json", "homocysteine"])
        .assert()
        .success()
        .stdout(predicate::str::contains("vitamin-b12-methyl"))
        .stdout(predicate::str::contains("methylfolate-1000"));
}

#[test]
fn test_brands() {
    cmd()
        .args(["brands", "--json"])
        .assert()
        .success()
        .stdout(predicate::str::contains("Thorne"))
        .stdout(predicate::str::contains("Nordic Naturals"))
        .stdout(predicate::str::contains("Pure Encapsulations"))
        .stdout(predicate::str::contains("Jarrow Formulas"))
        .stdout(predicate::str::contains("Life Extension"));
}

#[test]
fn test_interactions_found() {
    cmd()
        .args([
            "interactions",
            "--json",
            "berberine-500",
            "iron-bisglycinate",
        ])
        .assert()
        .success()
        .stdout(predicate::str::contains("moderate"))
        .stdout(predicate::str::contains("Berberine may reduce iron absorption"));
}

#[test]
fn test_interactions_none() {
    cmd()
        .args([
            "interactions",
            "--json",
            "vitamin-d3-5000",
            "omega3-epa-dha",
        ])
        .assert()
        .success()
        .stdout(predicate::str::contains("\"data\": []"));
}

#[test]
fn test_interactions_product_not_found() {
    cmd()
        .args(["interactions", "--json", "nonexistent", "vitamin-d3-5000"])
        .assert()
        .failure()
        .code(3)
        .stderr(predicate::str::contains("Product not found"));
}

#[test]
fn test_recommend_no_input_error() {
    cmd()
        .args(["recommend", "--json"])
        .assert()
        .failure()
        .code(3)
        .stderr(predicate::str::contains("No input provided"));
}

#[test]
fn test_recommend_stdin() {
    let fixture = serde_json::json!({
        "version": "1",
        "status": "success",
        "data": {
            "mode": "full",
            "patient": { "sex": "male", "age": 42 },
            "scored_biomarkers": [
                {
                    "name": "Vitamin D",
                    "standardized_name": "vitamin_d",
                    "value": 18.0,
                    "unit": "ng/mL",
                    "status": "concern",
                    "severity": "high"
                },
                {
                    "name": "Triglycerides",
                    "standardized_name": "triglycerides",
                    "value": 220.0,
                    "unit": "mg/dL",
                    "status": "marginal",
                    "severity": "moderate"
                },
                {
                    "name": "Fasting Glucose",
                    "standardized_name": "fasting_glucose",
                    "value": 112.0,
                    "unit": "mg/dL",
                    "status": "attention",
                    "severity": "moderate"
                }
            ],
            "derived_values": [],
            "patterns_detected": [],
            "red_flags": [],
            "summary": {
                "total_markers": 3,
                "scored": 3,
                "unknown": 0,
                "optimal": 0,
                "good": 0,
                "attention": 1,
                "marginal": 1,
                "concern": 1
            }
        }
    });

    cmd()
        .args(["recommend", "--stdin", "--json"])
        .write_stdin(serde_json::to_string(&fixture).unwrap())
        .assert()
        .success()
        .stdout(predicate::str::contains("\"status\": \"success\""))
        .stdout(predicate::str::contains("recommendations"))
        .stdout(predicate::str::contains("vitamin-d3-5000"));
}

#[test]
fn test_recommend_with_red_flag() {
    let fixture = serde_json::json!({
        "version": "1",
        "status": "success",
        "data": {
            "mode": "full",
            "patient": { "sex": "female", "age": 35 },
            "scored_biomarkers": [
                {
                    "name": "Vitamin D",
                    "standardized_name": "vitamin_d",
                    "value": 8.0,
                    "unit": "ng/mL",
                    "status": "concern",
                    "severity": "high"
                }
            ],
            "derived_values": [],
            "patterns_detected": [],
            "red_flags": [
                {
                    "marker": "vitamin_d",
                    "value": 8.0,
                    "unit": "ng/mL",
                    "urgency": "routine",
                    "action": "Severe vitamin D deficiency. Start repletion.",
                    "referral": "endocrinology"
                }
            ],
            "summary": {
                "total_markers": 1,
                "scored": 1,
                "unknown": 0,
                "optimal": 0,
                "good": 0,
                "attention": 0,
                "marginal": 0,
                "concern": 1
            }
        }
    });

    cmd()
        .args(["recommend", "--stdin", "--json"])
        .write_stdin(serde_json::to_string(&fixture).unwrap())
        .assert()
        .success()
        .stdout(predicate::str::contains("red_flag"))
        .stdout(predicate::str::contains("vitamin-d3-5000"));
}

#[test]
fn test_recommend_with_pattern() {
    let fixture = serde_json::json!({
        "version": "1",
        "status": "success",
        "data": {
            "mode": "full",
            "patient": { "sex": "male", "age": 50 },
            "scored_biomarkers": [
                {
                    "name": "hsCRP",
                    "standardized_name": "hscrp",
                    "value": 4.2,
                    "unit": "mg/L",
                    "status": "concern",
                    "severity": "high"
                }
            ],
            "derived_values": [],
            "patterns_detected": [
                {
                    "name": "chronic_inflammation",
                    "confidence": "high",
                    "criteria_met": ["hscrp > 3.0"],
                    "action": "Address systemic inflammation."
                }
            ],
            "red_flags": [],
            "summary": {
                "total_markers": 1,
                "scored": 1,
                "unknown": 0,
                "optimal": 0,
                "good": 0,
                "attention": 0,
                "marginal": 0,
                "concern": 1
            }
        }
    });

    cmd()
        .args(["recommend", "--stdin", "--json"])
        .write_stdin(serde_json::to_string(&fixture).unwrap())
        .assert()
        .success()
        .stdout(predicate::str::contains("pattern"))
        .stdout(predicate::str::contains("curcumin-meriva"));
}

#[test]
fn test_recommend_evidence_filter() {
    let fixture = serde_json::json!({
        "version": "1",
        "status": "success",
        "data": {
            "mode": "full",
            "patient": { "sex": "male", "age": 42 },
            "scored_biomarkers": [
                {
                    "name": "hsCRP",
                    "standardized_name": "hscrp",
                    "value": 3.5,
                    "unit": "mg/L",
                    "status": "attention",
                    "severity": "moderate"
                }
            ],
            "derived_values": [],
            "patterns_detected": [],
            "red_flags": [],
            "summary": {
                "total_markers": 1,
                "scored": 1,
                "unknown": 0,
                "optimal": 0,
                "good": 0,
                "attention": 1,
                "marginal": 0,
                "concern": 0
            }
        }
    });

    // With --min-evidence strong, curcumin (moderate evidence for hscrp) should be excluded
    // but omega3 (strong for triglycerides, moderate for hscrp) passes because its best
    // evidence across all targets is "strong"
    cmd()
        .args(["recommend", "--stdin", "--json", "--min-evidence", "strong"])
        .write_stdin(serde_json::to_string(&fixture).unwrap())
        .assert()
        .success()
        // curcumin only has moderate evidence, so it should not appear
        .stdout(predicate::str::contains("curcumin").not())
        // omega3 has strong evidence (for triglycerides target), so it qualifies
        .stdout(predicate::str::contains("omega3-epa-dha"));
}