"""Tests de l'éditeur de flow à nœuds (déclencheur / condition / action)."""
import json
import re


def _create_screen(client, slug, name="Accueil"):
    resp = client.post(f"/game/{slug}/screens/new", data={"name": name}, follow_redirects=False)
    return int(re.search(r"/screens/(\d+)/edit", resp.headers["Location"]).group(1))


def test_flow_node_and_edge_crud(client, game):
    screen_id = _create_screen(client, game)
    resp = client.post(f"/game/{game}/screens/{screen_id}/elements/add", data={"widget": "bouton"})
    element_id = int(re.search(r"selected=(\d+)", resp.headers["Location"]).group(1))

    resp = client.post(
        f"/game/{game}/screens/{screen_id}/flow/nodes/add",
        data=json.dumps({"node_type": "trigger", "trigger_element_id": element_id, "trigger_event": "clic"}),
        content_type="application/json",
    )
    assert resp.status_code == 200
    trigger_node = resp.get_json()
    assert trigger_node["node_type"] == "trigger"

    resp = client.post(
        f"/game/{game}/screens/{screen_id}/flow/nodes/add",
        data=json.dumps({"node_type": "action", "action_type": "ecran_suivant"}),
        content_type="application/json",
    )
    action_node = resp.get_json()

    resp = client.post(
        f"/game/{game}/screens/{screen_id}/flow/edges/add",
        data=json.dumps({"from_node_id": trigger_node["id"], "from_port": "out", "to_node_id": action_node["id"]}),
        content_type="application/json",
    )
    assert resp.status_code == 200

    html = client.get(f"/game/{game}/screens/{screen_id}/edit").data.decode()
    assert str(trigger_node["id"]) in html


def test_multiple_actions_from_one_trigger(client, game):
    """Régression : un déclencheur doit pouvoir avoir PLUSIEURS arêtes
    sortantes (plusieurs actions exécutées au même clic)."""
    screen_id = _create_screen(client, game)
    resp = client.post(f"/game/{game}/screens/{screen_id}/elements/add", data={"widget": "bouton"})
    element_id = int(re.search(r"selected=(\d+)", resp.headers["Location"]).group(1))

    resp = client.post(
        f"/game/{game}/screens/{screen_id}/flow/nodes/add",
        data=json.dumps({"node_type": "trigger", "trigger_element_id": element_id, "trigger_event": "clic"}),
        content_type="application/json",
    )
    trigger_node = resp.get_json()

    action_ids = []
    for action_type in ("ecran_suivant", "rien"):
        resp = client.post(
            f"/game/{game}/screens/{screen_id}/flow/nodes/add",
            data=json.dumps({"node_type": "action", "action_type": action_type}),
            content_type="application/json",
        )
        action_ids.append(resp.get_json()["id"])

    for aid in action_ids:
        resp = client.post(
            f"/game/{game}/screens/{screen_id}/flow/edges/add",
            data=json.dumps({"from_node_id": trigger_node["id"], "from_port": "out", "to_node_id": aid}),
            content_type="application/json",
        )
        assert resp.status_code == 200

    import screens
    edges = screens.list_flow_edges(game, screen_id)
    from_trigger = [e for e in edges if e["from_node_id"] == trigger_node["id"]]
    assert len(from_trigger) == 2


def test_repeater_rows_carry_stable_row_id(client, game, mail_object):
    """Régression 1.1 : contrairement à data-element-id (l'id du MODÈLE de
    ligne, identique sur chaque ligne rendue), chaque ligne d'un Répéteur
    doit porter un data-row-id qui identifie la VRAIE ligne de données
    affichée — sans ça, un déclencheur posé sur le Répéteur ne peut pas
    savoir laquelle de ses lignes a été cliquée."""
    slug, definition_id = mail_object["slug"], mail_object["definition_id"]
    client.post(f"/game/{slug}/objects/{definition_id}/data/new", data={"sujet": "Sujet 1", "expediteur": "a@test.com"})
    client.post(f"/game/{slug}/objects/{definition_id}/data/new", data={"sujet": "Sujet 2", "expediteur": "b@test.com"})

    screen_id = _create_screen(client, slug)
    resp = client.post(f"/game/{slug}/screens/{screen_id}/elements/add", data={"widget": "repeteur_donnees"})
    rep_id = int(re.search(r"selected=(\d+)", resp.headers["Location"]).group(1))
    client.post(f"/game/{slug}/elements/{rep_id}/save", data={"ctrl_definition_id": str(definition_id)})

    html = client.get(f"/game/{slug}/screens/{screen_id}/edit").data.decode()
    assert 'class="repeaterItem" data-row-id="' in html
    assert f'data-definition-id="{definition_id}"' in html
    # Deux lignes de données -> deux data-row-id DIFFÉRENTS.
    row_ids = re.findall(r'data-row-id="(\d+)"', html)
    assert len(row_ids) == 2
    assert len(set(row_ids)) == 2


def test_ouvrir_ligne_action_node_persists_target_screen(client, game):
    """Régression 1.1 : la nouvelle action "Ouvrir la ligne de Répéteur
    cliquée" doit accepter un écran cible comme l'action "aller_a", pour
    que l'écran de détail (ex: lecture d'un mail) puisse être choisi dans
    l'éditeur de logique."""
    import json

    inbox_id = _create_screen(client, game, "Boîte de réception")
    detail_id = _create_screen(client, game, "Détail du mail")
    resp = client.post(f"/game/{game}/screens/{inbox_id}/elements/add", data={"widget": "repeteur_donnees"})
    rep_id = int(re.search(r"selected=(\d+)", resp.headers["Location"]).group(1))

    resp = client.post(
        f"/game/{game}/screens/{inbox_id}/flow/nodes/add",
        data=json.dumps({"node_type": "trigger", "trigger_element_id": rep_id, "trigger_event": "clic"}),
        content_type="application/json",
    )
    trigger_node = resp.get_json()

    resp = client.post(
        f"/game/{game}/screens/{inbox_id}/flow/nodes/add",
        data=json.dumps({"node_type": "action", "action_type": "ouvrir_ligne", "target_screen_id": detail_id}),
        content_type="application/json",
    )
    assert resp.status_code == 200
    action_node = resp.get_json()
    assert action_node["action_type"] == "ouvrir_ligne"
    assert action_node["target_screen_id"] == detail_id

    resp = client.post(
        f"/game/{game}/screens/{inbox_id}/flow/edges/add",
        data=json.dumps({"from_node_id": trigger_node["id"], "from_port": "out", "to_node_id": action_node["id"]}),
        content_type="application/json",
    )
    assert resp.status_code == 200


def test_play_page_exposes_row_bindings_helpers(client, game):
    """Le runtime jouable doit embarquer la logique côté client capable de
    résoudre les {{champ}} de la ligne ouverte (voir README, section
    "Cliquer une ligne de Répéteur") — vérifie que le JS livré au joueur
    contient bien les briques attendues, sans dépendre d'un navigateur."""
    resp = client.get(f"/game/{game}/play")
    html = resp.data.decode()
    assert "applyOpenRowBindings" in html
    assert "lastClickedRowId" in html
    assert "'ouvrir_ligne'" in html


def test_repeater_filter_literal_value(client, game, mail_object):
    """Régression 1.2 : un filtre réglé sur le Répéteur (champ + opérateur +
    valeur fixe) ne doit garder que les lignes qui correspondent, sur un
    écran UNIQUE (pas un écran par niveau) — voir claude/forge-engine-lacunes-boitemail.md."""
    slug, definition_id = mail_object["slug"], mail_object["definition_id"]
    client.post(f"/game/{slug}/objects/{definition_id}/data/new", data={"sujet": "Sujet 1", "expediteur": "a@test.com"})
    client.post(f"/game/{slug}/objects/{definition_id}/data/new", data={"sujet": "Sujet 2", "expediteur": "b@test.com"})

    screen_id = _create_screen(client, slug)
    resp = client.post(f"/game/{slug}/screens/{screen_id}/elements/add", data={"widget": "repeteur_donnees"})
    rep_id = int(re.search(r"selected=(\d+)", resp.headers["Location"]).group(1))
    client.post(f"/game/{slug}/elements/{rep_id}/save", data={
        "ctrl_definition_id": str(definition_id), "ctrl_content": "{{sujet}}",
        "ctrl_filtre_champ": "sujet", "ctrl_filtre_operateur": "egal", "ctrl_filtre_valeur": "Sujet 2",
    })

    html = client.get(f"/game/{slug}/screens/{screen_id}/edit").data.decode()
    rows = re.findall(r'<div class="repeaterItem"[^>]*>(.*?)</div>', html)
    assert len(rows) == 1, f"le filtre aurait dû ne garder qu'UNE ligne, en a laissé {len(rows)}"
    assert "Sujet 2" in rows[0]


def test_repeater_filter_reference_to_another_object(client, game, mail_object):
    """Régression 1.2 : le filtre doit aussi savoir comparer à une valeur qui
    change en cours de partie via "{{NomObjet.champ}}" (ex: {{Partie.niveau}}),
    pas seulement à une valeur fixe — c'est ce qui permet à UN SEUL écran de
    s'adapter à la progression sans dupliquer un écran par niveau."""
    slug, definition_id = mail_object["slug"], mail_object["definition_id"]
    client.post(f"/game/{slug}/objects/{definition_id}/data/new", data={"sujet": "Sujet 1", "expediteur": "a@test.com"})
    client.post(f"/game/{slug}/objects/{definition_id}/data/new", data={"sujet": "Sujet 2", "expediteur": "b@test.com"})

    # Objet "Partie" à une seule ligne, jouant le rôle d'état global de partie.
    resp = client.post(f"/game/{slug}/objects/new", data={
        "object_name": "Partie", "field_name[]": ["sujet_actif"], "field_type[]": ["texte"],
        "field_relation[]": [""], "field_required[]": ["0"],
    }, follow_redirects=False)
    partie_def_id = int(resp.headers["Location"].rstrip("/").split("/")[-1])
    client.post(f"/game/{slug}/objects/{partie_def_id}/data/new", data={"sujet_actif": "Sujet 1"})

    screen_id = _create_screen(client, slug)
    resp = client.post(f"/game/{slug}/screens/{screen_id}/elements/add", data={"widget": "repeteur_donnees"})
    rep_id = int(re.search(r"selected=(\d+)", resp.headers["Location"]).group(1))
    client.post(f"/game/{slug}/elements/{rep_id}/save", data={
        "ctrl_definition_id": str(definition_id), "ctrl_content": "{{sujet}}",
        "ctrl_filtre_champ": "sujet", "ctrl_filtre_operateur": "egal",
        "ctrl_filtre_valeur": "{{Partie.sujet_actif}}",
    })

    html = client.get(f"/game/{slug}/screens/{screen_id}/edit").data.decode()
    rows = re.findall(r'<div class="repeaterItem"[^>]*>(.*?)</div>', html)
    assert len(rows) == 1, f"le filtre aurait dû ne garder qu'UNE ligne, en a laissé {len(rows)}"
    assert "Sujet 1" in rows[0]


def test_affichage_trigger_does_not_require_element(client, game):
    """Régression 1.2 : le nouveau déclencheur "affichage" doit pouvoir être
    créé SANS élément cible (il concerne l'écran entier), contrairement au
    déclencheur "clic" — voir screens/flow/constants.py."""
    screen_id = _create_screen(client, game)
    resp = client.post(
        f"/game/{game}/screens/{screen_id}/flow/nodes/add",
        data=json.dumps({"node_type": "trigger", "trigger_event": "affichage"}),
        content_type="application/json",
    )
    assert resp.status_code == 200
    node = resp.get_json()
    assert node["trigger_event"] == "affichage"
    assert node["trigger_element_id"] is None


def test_play_page_exposes_screen_show_trigger_helper(client, game):
    """Le runtime jouable doit exécuter les nœuds "affichage" à chaque fois
    qu'un écran est montré (premier affichage, retour en arrière, données
    modifiées) — voir README, section correspondante."""
    resp = client.get(f"/game/{game}/play")
    html = resp.data.decode()
    assert "runScreenShowTriggers" in html
    assert "'affichage'" in html