//! Targets page — lists onboarded targets (the unified `OnboardedTarget`
//! records the wizard creates) and lets the user run a scan, inspect the
//! classification / applicable scans, or delete a target.
//!
//! Creation lives in the Onboard wizard (`/onboard`); this page is the
//! "where is my target, and what did the scan find" surface.

use dioxus::prelude::*;
use dioxus_free_icons::icons::bs_icons::*;
use dioxus_free_icons::Icon;

use crate::components::page_header::PageHeader;
use crate::components::toast::{ToastType, Toasts};
use crate::infrastructure::onboarding::{
    delete_target, fetch_applicable_scans, fetch_targets, trigger_target_scan, update_target,
    validate_artifact_ref, validate_target_name, ArtifactInputDto,
};

/// The nine target families (value, label) for the edit form's type selector.
const TARGET_TYPES: &[(&str, &str)] = &[
    ("web_app", "Web Application"),
    ("backend_service", "Backend / API"),
    ("desktop_app", "Desktop App"),
    ("android_app", "Android App"),
    ("ios_app", "iOS App"),
    ("firmware_bare_metal", "Firmware — bare metal"),
    ("firmware_rtos", "Firmware — RTOS"),
    ("embedded_linux_yocto", "Embedded Linux / Yocto"),
    ("plc_sps", "PLC / SPS"),
];

/// The artifact kinds (value, label) for the edit form.
const ARTIFACT_KINDS: &[(&str, &str)] = &[
    ("git_repo", "Git repository"),
    ("source_archive", "Source archive (zip)"),
    ("firmware_image", "Firmware image"),
    ("mobile_package", "Mobile package (APK/IPA)"),
    ("container_image", "Container image"),
    ("live_url", "Live URL"),
    ("plc_project", "PLC project"),
    ("plaintext_description", "Description (text)"),
];

/// Prettify a snake_case target-type value into a human label.
fn pretty_type(v: &str) -> String {
    match v {
        "web_app" => "Web Application".into(),
        "backend_service" => "Backend / API".into(),
        "desktop_app" => "Desktop App".into(),
        "android_app" => "Android App".into(),
        "ios_app" => "iOS App".into(),
        "firmware_bare_metal" => "Firmware — bare metal".into(),
        "firmware_rtos" => "Firmware — RTOS".into(),
        "embedded_linux_yocto" => "Embedded Linux / Yocto".into(),
        "plc_sps" => "PLC / SPS".into(),
        other => other.replace('_', " "),
    }
}

fn str_at<'a>(v: &'a serde_json::Value, key: &str) -> &'a str {
    v.get(key).and_then(|x| x.as_str()).unwrap_or("")
}

fn target_id(t: &serde_json::Value) -> String {
    t.get("_id")
        .and_then(|o| o.get("$oid"))
        .and_then(|s| s.as_str())
        .unwrap_or_default()
        .to_string()
}

/// The applicable-scans matrix for one target, fetched on expand.
#[component]
fn TargetScans(id: String) -> Element {
    let scan_id = id.clone();
    let scans = use_resource(move || {
        let id = scan_id.clone();
        async move { fetch_applicable_scans(id).await.ok() }
    });

    let snapshot = scans.read().clone();
    match &snapshot {
        Some(Some(resp)) => {
            let rows = resp.data.scans.clone();
            let pentest = resp.data.pentest_supported;
            rsx! {
                div { style: "margin-top: 8px;",
                    if rows.is_empty() {
                        div { style: "opacity: 0.6;", "No scans available (no code / URL / firmware artifact present)." }
                    }
                    for s in rows {
                        {
                            let name = str_at(&s, "scan").to_string();
                            let rationale = str_at(&s, "rationale").to_string();
                            let blocked = s.get("blocked_reason").and_then(|b| b.as_str()).map(String::from);
                            let default_on = s.get("default_on").and_then(|b| b.as_bool()).unwrap_or(false);
                            let badge = if blocked.is_some() {
                                "badge badge-info"
                            } else if default_on {
                                "badge badge-success"
                            } else {
                                "badge"
                            };
                            rsx! {
                                div { style: "display: flex; gap: 8px; align-items: center; padding: 4px 0;",
                                    span { class: "{badge}", "{name}" }
                                    span { style: "opacity: 0.8; font-size: 0.9em;", "{rationale}" }
                                    if let Some(b) = blocked {
                                        span { style: "opacity: 0.6; font-style: italic; font-size: 0.9em;", "— {b}" }
                                    }
                                }
                            }
                        }
                    }
                    if pentest {
                        div { style: "margin-top: 6px; opacity: 0.75; font-size: 0.85em;",
                            "Active pentest is supported for this target type."
                        }
                    }
                }
            }
        }
        Some(None) => rsx! { div { style: "opacity: 0.6;", "Failed to load applicable scans." } },
        None => rsx! { div { style: "opacity: 0.6;", "Loading scans..." } },
    }
}

#[component]
pub fn TargetsPage() -> Element {
    let mut toasts = use_context::<Toasts>();
    let mut scanning_ids = use_signal(Vec::<String>::new);
    let mut expanded_ids = use_signal(Vec::<String>::new);
    let mut confirm_delete = use_signal(|| Option::<(String, String)>::None);

    // Edit-target modal state.
    let mut edit_id = use_signal(|| Option::<String>::None);
    let mut edit_name = use_signal(String::new);
    let mut edit_type = use_signal(String::new);
    let mut edit_arts = use_signal(Vec::<ArtifactInputDto>::new);
    let mut edit_saving = use_signal(|| false);
    // In-modal "add artifact" mini-form.
    let mut e_kind = use_signal(|| "git_repo".to_string());
    let mut e_source = use_signal(String::new);
    let mut e_branch = use_signal(|| "main".to_string());

    let mut targets = use_resource(move || async move { fetch_targets().await.ok() });

    rsx! {
        PageHeader {
            title: "Targets",
            description: "Onboarded targets and what their scans found. Add new targets from Onboard.",
        }

        div { style: "margin-bottom: 16px; display: flex; gap: 8px;",
            Link { to: crate::app::Route::OnboardingPage {}, class: "btn btn-primary",
                "+ Onboard a target"
            }
            button {
                class: "btn btn-secondary",
                onclick: move |_| targets.restart(),
                "Refresh"
            }
        }

        // ── Delete confirmation ──
        if let Some((del_id, del_name)) = confirm_delete() {
            div { class: "modal-overlay",
                div { class: "modal-dialog",
                    h3 { "Delete Target" }
                    p { "Delete " strong { "{del_name}" } "?" }
                    p { class: "modal-warning",
                        "This permanently removes the target and its findings, SBOM entries, scan runs, and CVE alerts."
                    }
                    div { class: "modal-actions",
                        button {
                            class: "btn btn-secondary",
                            onclick: move |_| confirm_delete.set(None),
                            "Cancel"
                        }
                        button {
                            class: "btn btn-danger",
                            onclick: move |_| {
                                let id = del_id.clone();
                                let name = del_name.clone();
                                confirm_delete.set(None);
                                spawn(async move {
                                    match delete_target(id).await {
                                        Ok(_) => {
                                            toasts.push(ToastType::Success, format!("{name} deleted"));
                                            targets.restart();
                                        }
                                        Err(e) => toasts.push(ToastType::Error, e.to_string()),
                                    }
                                });
                            },
                            "Delete"
                        }
                    }
                }
            }
        }

        // ── Edit target ──
        if let Some(eid) = edit_id() {
            {
            let name_err = validate_target_name(&edit_name());
            let e_source_err = if e_source().is_empty() {
                None
            } else {
                validate_artifact_ref(&e_kind(), &e_source())
            };
            rsx! {
                div { class: "modal-overlay",
                    div { class: "modal-dialog",
                        h3 { "Edit target" }
                        div { class: "form-group",
                            label { "Name" }
                            input {
                                r#type: "text",
                                value: "{edit_name}",
                                oninput: move |e| edit_name.set(e.value()),
                            }
                            if !edit_name().is_empty() {
                                if let Some(err) = name_err.clone() {
                                    div { style: "color: var(--danger, #d33); font-size: 0.85em;", "{err}" }
                                }
                            }
                        }
                        div { class: "form-group",
                            label { "Type" }
                            select {
                                value: "{edit_type}",
                                oninput: move |e| edit_type.set(e.value()),
                                for (v, l) in TARGET_TYPES.iter().copied() {
                                    option { value: "{v}", selected: edit_type() == v, "{l}" }
                                }
                            }
                        }
                        label { style: "font-weight: 600;", "Artifacts" }
                        for (i, a) in edit_arts().iter().enumerate() {
                            div { style: "display: flex; justify-content: space-between; align-items: center; padding: 4px 0;",
                                span { style: "font-size: 0.9em;",
                                    span { style: "opacity: 0.7;", "{a.kind}: " }
                                    span { style: "font-family: monospace;", "{a.source_ref}" }
                                }
                                button {
                                    class: "btn btn-ghost btn-ghost-danger btn-sm",
                                    onclick: move |_| { edit_arts.write().remove(i); },
                                    "Remove"
                                }
                            }
                        }
                        div { style: "display: flex; gap: 8px; align-items: flex-end; margin-top: 8px;",
                            div { class: "form-group", style: "margin: 0;",
                                label { "Kind" }
                                select {
                                    value: "{e_kind}",
                                    oninput: move |e| e_kind.set(e.value()),
                                    for (v, l) in ARTIFACT_KINDS.iter().copied() {
                                        option { value: "{v}", selected: e_kind() == v, "{l}" }
                                    }
                                }
                            }
                            div { class: "form-group", style: "margin: 0; flex: 1;",
                                label { "Reference" }
                                input {
                                    r#type: "text",
                                    value: "{e_source}",
                                    oninput: move |e| e_source.set(e.value()),
                                }
                            }
                            if e_kind() == "git_repo" {
                                div { class: "form-group", style: "margin: 0;",
                                    label { "Branch" }
                                    input {
                                        r#type: "text",
                                        value: "{e_branch}",
                                        oninput: move |e| e_branch.set(e.value()),
                                    }
                                }
                            }
                            button {
                                class: "btn btn-secondary",
                                disabled: e_source().trim().is_empty() || e_source_err.is_some(),
                                onclick: move |_| {
                                    let kind = e_kind();
                                    if !e_source().trim().is_empty()
                                        && validate_artifact_ref(&kind, &e_source()).is_none()
                                    {
                                        let branch = if kind == "git_repo" { Some(e_branch()) } else { None };
                                        edit_arts.write().push(ArtifactInputDto {
                                            kind,
                                            source_ref: e_source(),
                                            branch,
                                            plc_format: None,
                                        });
                                        e_source.set(String::new());
                                    }
                                },
                                "+ Add"
                            }
                        }
                        if let Some(err) = e_source_err.clone() {
                            div { style: "color: var(--danger, #d33); font-size: 0.85em;", "{err}" }
                        }
                        div { class: "modal-actions",
                            button {
                                class: "btn btn-secondary",
                                onclick: move |_| edit_id.set(None),
                                "Cancel"
                            }
                            button {
                                class: "btn btn-primary",
                                disabled: edit_saving() || name_err.is_some(),
                                onclick: move |_| {
                                    let id = eid.clone();
                                    let nm = edit_name();
                                    let tt = edit_type();
                                    let arts = edit_arts();
                                    edit_saving.set(true);
                                    spawn(async move {
                                        match update_target(id, Some(nm), Some(tt), Some(arts)).await {
                                            Ok(_) => {
                                                toasts.push(ToastType::Success, "Target updated");
                                                targets.restart();
                                                edit_id.set(None);
                                            }
                                            Err(e) => toasts.push(ToastType::Error, e.to_string()),
                                        }
                                        edit_saving.set(false);
                                    });
                                },
                                if edit_saving() { "Saving..." } else { "Save" }
                            }
                        }
                    }
                }
            }
            }
        }

        {
        let targets_snapshot = targets.read().clone();
        match &targets_snapshot {
            Some(Some(resp)) => {
                let rows = resp.data.clone();
                if rows.is_empty() {
                    rsx! {
                        div { class: "card", style: "padding: 24px; text-align: center;",
                            p { style: "opacity: 0.7;", "No targets yet." }
                            Link { to: crate::app::Route::OnboardingPage {}, class: "btn btn-primary",
                                "Onboard your first target"
                            }
                        }
                    }
                } else {
                    rsx! {
                        div { class: "card",
                            div { class: "table-wrapper",
                                table {
                                    thead {
                                        tr {
                                            th { "Name" }
                                            th { "Type" }
                                            th { "Detected" }
                                            th { "Artifacts" }
                                            th { "Findings" }
                                            th { "Actions" }
                                        }
                                    }
                                    tbody {
                                        for t in rows {
                                            {
                                                let id = target_id(&t);
                                                let name = str_at(&t, "name").to_string();
                                                let ttype = pretty_type(str_at(&t, "target_type"));
                                                let suggested = t
                                                    .get("classification")
                                                    .and_then(|c| c.get("suggested"))
                                                    .and_then(|s| s.as_str())
                                                    .map(pretty_type);
                                                let artifacts = t
                                                    .get("artifacts")
                                                    .and_then(|a| a.as_array())
                                                    .cloned()
                                                    .unwrap_or_default();
                                                let findings = t
                                                    .get("findings_count")
                                                    .and_then(|n| n.as_u64())
                                                    .unwrap_or(0);
                                                let facts = t
                                                    .get("classification")
                                                    .and_then(|c| c.get("facts"))
                                                    .and_then(|f| f.as_array())
                                                    .cloned()
                                                    .unwrap_or_default();
                                                let is_scanning = scanning_ids().contains(&id);
                                                let is_expanded = expanded_ids().contains(&id);
                                                let id_scan = id.clone();
                                                let id_exp = id.clone();
                                                let id_del = id.clone();
                                                let id_edit = id.clone();
                                                let name_del = name.clone();
                                                let name_edit = name.clone();
                                                let ttype_raw = str_at(&t, "target_type").to_string();
                                                let artifacts_detail = artifacts.clone();
                                                let artifacts_edit = artifacts.clone();
                                                rsx! {
                                                    tr {
                                                        td { strong { "{name}" } }
                                                        td { "{ttype}" }
                                                        td {
                                                            if let Some(sug) = suggested.clone() {
                                                                span { class: "badge badge-success", "{sug}" }
                                                            } else {
                                                                span { style: "opacity: 0.5;", "—" }
                                                            }
                                                        }
                                                        td { "{artifacts.len()}" }
                                                        td { "{findings}" }
                                                        td { style: "display: flex; gap: 4px;",
                                                            button {
                                                                class: "btn btn-ghost",
                                                                title: "Details",
                                                                onclick: move |_| {
                                                                    let mut ids = expanded_ids();
                                                                    if ids.contains(&id_exp) {
                                                                        ids.retain(|i| i != &id_exp);
                                                                    } else {
                                                                        ids.push(id_exp.clone());
                                                                    }
                                                                    expanded_ids.set(ids);
                                                                },
                                                                Icon { icon: BsInfoCircle, width: 16, height: 16 }
                                                            }
                                                            button {
                                                                class: "btn btn-ghost",
                                                                title: "Edit target",
                                                                onclick: move |_| {
                                                                    edit_name.set(name_edit.clone());
                                                                    edit_type.set(ttype_raw.clone());
                                                                    let arts: Vec<ArtifactInputDto> = artifacts_edit
                                                                        .iter()
                                                                        .map(|a| ArtifactInputDto {
                                                                            kind: str_at(a, "kind").to_string(),
                                                                            source_ref: str_at(a, "source_ref").to_string(),
                                                                            branch: a
                                                                                .get("git")
                                                                                .and_then(|g| g.get("default_branch"))
                                                                                .and_then(|b| b.as_str())
                                                                                .map(String::from),
                                                                            plc_format: None,
                                                                        })
                                                                        .collect();
                                                                    edit_arts.set(arts);
                                                                    e_source.set(String::new());
                                                                    edit_id.set(Some(id_edit.clone()));
                                                                },
                                                                Icon { icon: BsPencil, width: 16, height: 16 }
                                                            }
                                                            button {
                                                                class: if is_scanning { "btn btn-ghost btn-scanning" } else { "btn btn-ghost" },
                                                                title: "Run scan",
                                                                disabled: is_scanning,
                                                                onclick: move |_| {
                                                                    let id = id_scan.clone();
                                                                    let mut ids = scanning_ids();
                                                                    ids.push(id.clone());
                                                                    scanning_ids.set(ids);
                                                                    spawn(async move {
                                                                        match trigger_target_scan(id.clone()).await {
                                                                            Ok(_) => toasts.push(ToastType::Success, "Scan triggered — findings appear as it runs. Use Refresh."),
                                                                            Err(e) => toasts.push(ToastType::Error, e.to_string()),
                                                                        }
                                                                        let mut ids = scanning_ids();
                                                                        ids.retain(|i| i != &id);
                                                                        scanning_ids.set(ids);
                                                                    });
                                                                },
                                                                if is_scanning {
                                                                    span { class: "spinner" }
                                                                } else {
                                                                    Icon { icon: BsPlayCircle, width: 16, height: 16 }
                                                                }
                                                            }
                                                            button {
                                                                class: "btn btn-ghost btn-ghost-danger",
                                                                title: "Delete target",
                                                                onclick: move |_| {
                                                                    confirm_delete.set(Some((id_del.clone(), name_del.clone())));
                                                                },
                                                                Icon { icon: BsTrash, width: 16, height: 16 }
                                                            }
                                                        }
                                                    }
                                                    if is_expanded {
                                                        tr {
                                                            td { colspan: "6",
                                                                div { style: "padding: 12px 8px;",
                                                                    h4 { style: "margin: 0 0 6px;", "Artifacts" }
                                                                    if artifacts_detail.is_empty() {
                                                                        div { style: "opacity: 0.6;", "No artifacts." }
                                                                    }
                                                                    for a in artifacts_detail {
                                                                        div { style: "font-size: 0.9em; padding: 2px 0;",
                                                                            span { style: "opacity: 0.7;", "{str_at(&a, \"kind\")}: " }
                                                                            span { style: "font-family: monospace;", "{str_at(&a, \"source_ref\")}" }
                                                                        }
                                                                    }
                                                                    if !facts.is_empty() {
                                                                        h4 { style: "margin: 12px 0 6px;", "Detected facts" }
                                                                        for f in facts {
                                                                            div { style: "font-size: 0.9em; padding: 2px 0;",
                                                                                span { style: "font-family: monospace;", "{str_at(&f, \"key\")}={str_at(&f, \"value\")}" }
                                                                                span { style: "opacity: 0.5;", " ({str_at(&f, \"source\")})" }
                                                                            }
                                                                        }
                                                                    }
                                                                    h4 { style: "margin: 12px 0 6px;", "Applicable scans" }
                                                                    TargetScans { id: id.clone() }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            Some(None) => rsx! {
                div { class: "card", p { "Failed to load targets." } }
            },
            None => rsx! {
                div { class: "loading", "Loading targets..." }
            },
        }
        }
    }
}