from flask import Flask

from visual_workflow_builder.backend.services.competence_vwb_preview import (
    competence_yaml_to_vwb_preview,
    competence_yaml_to_vwb_steps,
)


def _by_type(preview):
    return [step["action_type"] for step in preview["steps"]]


def test_competence_to_vwb_preview_key_win_r_steps():
    preview = competence_yaml_to_vwb_preview("key_win_r_wait_explorer_exe")

    assert preview["readonly"] is True
    assert preview["write_back_enabled"] is False
    assert preview["workflow"]["competence_id"] == "key_win_r_wait_explorer_exe"
    assert preview["workflow"]["verdict_endpoint"] == (
        "/api/v1/lea/competences/key_win_r_wait_explorer_exe/verdict"
    )
    assert _by_type(preview) == [
        "pause_for_human",
        "keyboard_shortcut",
        "wait_for_state",
        "pause_for_human",
    ]


def test_keyboard_shortcut_keys_are_preserved():
    steps = competence_yaml_to_vwb_steps("key_win_r_wait_explorer_exe")
    shortcut = steps[1]

    assert shortcut["action_type"] == "keyboard_shortcut"
    assert shortcut["parameters"]["keys"] == ["win", "r"]
    assert shortcut["parameters"]["source"] == (
        "lea_competence:key_win_r_wait_explorer_exe"
    )
    assert shortcut["parameters"]["source_method_id"] == "step_1_key_combo"


def test_wait_for_state_expected_state_is_preserved():
    steps = competence_yaml_to_vwb_steps("key_win_r_wait_explorer_exe")
    wait_step = steps[2]

    assert wait_step["action_type"] == "wait_for_state"
    params = wait_step["parameters"]
    assert params["expected_state"]["window_title_in"] == ["Ex\u00e9cuter"]
    assert params["expected_state"]["process_active"] == "explorer.exe"
    assert params["timeout_ms"] == 5000
    assert params["poll_interval_ms"] == 250
    assert params["evidence_required"] == "window_or_process"
    assert params["supervised_popup_detection"] is True
    assert params["popup_policy"] == "pause_only"


def test_pause_for_human_before_and_after_are_supervision_only():
    steps = competence_yaml_to_vwb_steps("key_win_r_wait_explorer_exe")

    before = steps[0]
    after = steps[-1]
    assert before["parameters"]["phase"] == "before"
    assert before["parameters"]["verdict_required"] is False
    assert after["parameters"]["phase"] == "after"
    assert after["parameters"]["verdict_required"] is True
    assert after["parameters"]["write_back_enabled"] is False
    assert after["parameters"]["verdict_endpoint"] == (
        "/api/v1/lea/competences/key_win_r_wait_explorer_exe/verdict"
    )


def test_adapter_is_generic_on_methods_not_hardcoded_to_win_r():
    steps = competence_yaml_to_vwb_steps("key_ctrl_s_wait_notepad_exe")

    assert [step["action_type"] for step in steps] == [
        "pause_for_human",
        "keyboard_shortcut",
        "wait_for_state",
        "pause_for_human",
    ]
    assert steps[1]["parameters"]["keys"] == ["ctrl", "s"]
    assert steps[2]["parameters"]["expected_state"]["window_title_in"] == [
        "Enregistrer sous"
    ]
    assert steps[2]["parameters"]["expected_state"]["process_active"] == "Notepad.exe"


def test_preview_endpoint_returns_read_only_workflow():
    from visual_workflow_builder.backend.catalog_routes_v2_vlm import (
        competence_preview_bp,
    )

    app = Flask(__name__)
    app.register_blueprint(competence_preview_bp)

    with app.test_client() as client:
        response = client.post(
            "/api/vwb/competences/key_win_r_wait_explorer_exe/preview",
            json={"supervised": True},
        )

    assert response.status_code == 200
    data = response.get_json()
    assert data["success"] is True
    assert data["readonly"] is True
    assert data["write_back_enabled"] is False
    assert data["workflow"]["source"] == "lea_competence_preview"
    assert [step["action_type"] for step in data["steps"]] == [
        "pause_for_human",
        "keyboard_shortcut",
        "wait_for_state",
        "pause_for_human",
    ]


def test_unsupported_method_is_reported_as_warning(tmp_path):
    root = tmp_path / "competences"
    candidate = root / "candidate"
    candidate.mkdir(parents=True)
    (candidate / "unsupported_preview.yaml").write_text(
        "\n".join(
            [
                "schema_version: 1",
                "id: unsupported_preview",
                "name: Unsupported preview",
                "learning_state: candidate",
                "intent:",
                "  fr: tester une methode non supportee",
                "methods:",
                "- id: step_1_unknown",
                "  kind: shell_magic",
                "  primitive_ref: shell_magic",
                "  parameters: {}",
                "failure_message_template:",
                "  attendu: aucun replay automatique",
            ]
        ),
        encoding="utf-8",
    )

    preview = competence_yaml_to_vwb_preview("unsupported_preview", root=root)

    assert [step["action_type"] for step in preview["steps"]] == [
        "pause_for_human",
        "pause_for_human",
    ]
    assert preview["warnings"] == [
        "Methode non supportee en preview VWB: step_1_unknown"
    ]