use std::fs;
use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH};

use sgclaw::compat::scene_platform::scheduled_registry::load_scheduled_monitoring_registry;
use sgclaw::generated_scene::generator::{
    generate_scheduled_monitoring_action_skill_package, GenerateScheduledMonitoringActionSkillRequest,
};

fn temp_workspace(prefix: &str) -> PathBuf {
    let nanos = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_nanos();
    let path = std::env::temp_dir().join(format!("{prefix}-{nanos}"));
    fs::create_dir_all(&path).unwrap();
    path
}

#[test]
fn scheduled_monitoring_registry_loads_materialized_skill() {
    let output_root = temp_workspace("sgclaw-scheduled-monitoring-registry");
    generate_scheduled_monitoring_action_skill_package(GenerateScheduledMonitoringActionSkillRequest {
        scene_id: "command-center-fee-control-monitor".to_string(),
        scene_name: "指挥中心费控异常监测".to_string(),
        output_root: output_root.clone(),
        source_evidence_json: PathBuf::from(
            "tests/fixtures/generated_scene/monitoring_action_source_evidence_extraction_2026-04-21.json",
        ),
        ir_contract_json: PathBuf::from(
            "tests/fixtures/generated_scene/scheduled_monitoring_action_ir_contract_2026-04-22.json",
        ),
        trigger_contract_json: PathBuf::from(
            "tests/fixtures/generated_scene/scheduled_monitoring_action_trigger_runtime_contract_2026-04-22.json",
        ),
    })
    .unwrap();

    let registry = load_scheduled_monitoring_registry(&output_root.join("skills")).unwrap();
    assert_eq!(registry.len(), 1);
    assert_eq!(
        registry[0].workflow_id,
        "command_center_fee_control_monitoring_action"
    );
    assert_eq!(
        registry[0].manifest.scene.kind,
        "scheduled_monitoring_action_workflow"
    );
}

#[test]
fn scheduled_monitoring_registry_loads_archive_workorder_skill() {
    let skills_dir = PathBuf::from(
        "dist/sgclaw_scheduled_monitoring_read_only_validation_bundle_2026-04-22/skills",
    );

    let registry = load_scheduled_monitoring_registry(&skills_dir).unwrap();
    let entry = registry
        .iter()
        .find(|entry| entry.workflow_id == "archive_workorder_grid_push_monitoring_action")
        .expect("archive workorder skill must be registered");

    assert_eq!(entry.manifest.scene.id, "archive-workorder-grid-push-monitor");
    assert_eq!(
        entry.manifest.scene.kind,
        "scheduled_monitoring_action_workflow"
    );
    assert_eq!(entry.manifest.scene.category, "monitoring");
    let safety = entry.manifest.safety.as_ref().unwrap();
    assert_eq!(safety.active_enabled, false);
    assert_eq!(safety.queue_process_enabled, false);
    assert_eq!(
        entry.manifest.runtime_context.as_ref().unwrap().expected_domain,
        "yx.gs.sgcc.com.cn"
    );
}

#[test]
fn scheduled_monitoring_registry_loads_available_balance_below_zero_skill() {
    let skills_dir = PathBuf::from(
        "dist/sgclaw_scheduled_monitoring_read_only_validation_bundle_2026-04-22/skills",
    );

    let registry = load_scheduled_monitoring_registry(&skills_dir).unwrap();
    let entry = registry
        .iter()
        .find(|entry| entry.workflow_id == "available_balance_below_zero_monitoring_action")
        .expect("available balance below zero skill must be registered");

    assert_eq!(entry.manifest.scene.id, "available-balance-below-zero-monitor");
    assert_eq!(
        entry.manifest.scene.kind,
        "scheduled_monitoring_action_workflow"
    );
    assert_eq!(entry.manifest.scene.category, "monitoring");
    let safety = entry.manifest.safety.as_ref().unwrap();
    assert_eq!(safety.active_enabled, false);
    assert_eq!(safety.queue_process_enabled, false);
    assert_eq!(
        entry.manifest.runtime_context.as_ref().unwrap().expected_domain,
        "yx.gs.sgcc.com.cn"
    );
}

#[test]
fn scheduled_monitoring_registry_loads_sgcc_todo_crawler_skill() {
    let skills_dir = PathBuf::from(
        "dist/sgclaw_scheduled_monitoring_read_only_validation_bundle_2026-04-22/skills",
    );

    let registry = load_scheduled_monitoring_registry(&skills_dir).unwrap();
    let entry = registry
        .iter()
        .find(|entry| entry.workflow_id == "sgcc_todo_crawler_monitoring_action")
        .expect("sgcc todo crawler skill must be registered");

    assert_eq!(entry.manifest.scene.id, "sgcc-todo-crawler");
    assert_eq!(
        entry.manifest.scene.kind,
        "scheduled_monitoring_action_workflow"
    );
    assert_eq!(entry.manifest.scene.category, "monitoring");
    let safety = entry.manifest.safety.as_ref().unwrap();
    assert_eq!(safety.active_enabled, false);
    assert_eq!(safety.queue_process_enabled, false);
    assert_eq!(
        entry.manifest.runtime_context.as_ref().unwrap().expected_domain,
        "xcoa.sgcc.com.cn"
    );
    let tools = entry.manifest.tools.as_ref().unwrap();
    assert_eq!(tools.detect, "scripts/detect.js");
    assert_eq!(tools.decide, "scripts/decide.js");
    assert_eq!(tools.action_plan, "scripts/action_plan.js");
}