from __future__ import annotations

import importlib.util
import json
from pathlib import Path

from app.domains.data_access import constants as c
from app.domains.data_access.approval_mapping import (
    data_access_group_grant_flow_mapping,
)
from app.domains.data_access.service import (
    DATA_ACCESS_FEISHU_FORM_DEFAULT_TYPES,
    DATA_ACCESS_FEISHU_FORM_FIELD_ORDER,
)

REPO_ROOT = Path(__file__).resolve().parents[3]
ARTIFACT_DIR = (
    REPO_ROOT
    / "deploy"
    / "feishu"
    / "approval-definitions"
    / "data_access_group_grant"
)
DEPLOY_SCRIPT = REPO_ROOT / "deploy" / "feishu" / "deploy_data_access_group_grant.py"


def _load_json(name: str):
    return json.loads((ARTIFACT_DIR / name).read_text())


def _load_deploy_module():
    spec = importlib.util.spec_from_file_location(
        "deploy_data_access_group_grant",
        DEPLOY_SCRIPT,
    )
    assert spec is not None
    module = importlib.util.module_from_spec(spec)
    assert spec.loader is not None
    spec.loader.exec_module(module)
    return module


def test_data_access_feishu_mapping_matches_canonical_form_contract() -> None:
    mapping = _load_json("helix-flow-mapping.json")
    payload_schema = mapping["payload_schema"]

    assert mapping == data_access_group_grant_flow_mapping(
        external_code="REPLACE_WITH_FEISHU_APPROVAL_CODE",
    )
    assert mapping["flow_key"] == c.APPROVAL_FLOW_DATA_ACCESS_GROUP_GRANT
    assert mapping["accept_external_origin"] is False
    assert tuple(
        key for key in payload_schema if key != "approval_process"
    ) == DATA_ACCESS_FEISHU_FORM_FIELD_ORDER

    for field_name in DATA_ACCESS_FEISHU_FORM_FIELD_ORDER:
        assert payload_schema[field_name]["id"] == f"dax_{field_name}"
        assert (
            payload_schema[field_name]["type"]
            == DATA_ACCESS_FEISHU_FORM_DEFAULT_TYPES[field_name]
        )
    assert payload_schema["approval_process"] == {
        "sequence": [
            {
                "key": "requester_line_manager_review",
                "approver_source": "feishu_requester_line_manager",
                "instance_payload_field": None,
            },
            {
                "key": "data_owner_review",
                "approver_source": "helix_resource_owner",
                "instance_payload_field": "node_approver_open_id_list",
            },
        ],
        "approver_nodes": {
            "data_owner_review": {
                "id": "data_owner_review",
                "approver_source": "helix_resource_owner",
                "instance_payload_field": "node_approver_open_id_list",
            },
        },
    }


def test_feishu_definition_widgets_match_helix_flow_mapping() -> None:
    definition = _load_json("definition.json")
    mapping = _load_json("helix-flow-mapping.json")
    payload_schema = mapping["payload_schema"]
    widgets_by_field = {
        widget["canonical_field"]: widget for widget in definition["form_widgets"]
    }

    assert definition["schema_version"] == "helix-feishu-approval-definition-v1"
    assert definition["flow_key"] == c.APPROVAL_FLOW_DATA_ACCESS_GROUP_GRANT
    assert definition["deploy_mode"] == "manual_feishu_admin_or_github_action"
    assert definition["origin"] == "helix_only"
    assert definition["accept_external_origin"] is False
    assert definition["callback_path"] == "/api/v1/approval/feishu/callback"
    assert tuple(widgets_by_field) == DATA_ACCESS_FEISHU_FORM_FIELD_ORDER
    assert definition["approval_process"]["recommended_nodes"] == [
        {
            "key": "requester_line_manager_review",
            "label": "Requester line manager review",
            "approver_source": "feishu_requester_line_manager",
            "sequence": 1,
            "feishu_node_type": "line_manager_auto",
            "instance_payload_field": None,
        },
        {
            "key": "data_owner_review",
            "label": "Data owner review",
            "sequence": 2,
            "approver_source": "helix_resource_owner",
            "feishu_node_id": "data_owner_review",
            "instance_payload_field": "node_approver_open_id_list",
        },
    ]
    assert definition["feishu_v4_api_contract"]["endpoint"] == (
        "/open-apis/approval/v4/approvals"
        "?user_id_type=open_id&department_id_type=open_department_id"
    )
    assert definition["feishu_v4_api_contract"]["viewers"] == [
        {"viewer_type": "TENANT"},
    ]
    assert definition["feishu_v4_api_contract"]["approval_name_key"] == (
        "@i18n@approval_name"
    )
    assert definition["feishu_v4_api_contract"]["description_key"] == (
        "@i18n@description"
    )
    assert definition["feishu_v4_api_contract"]["i18n_keys"] == {
        "form_widgets": {
            "request_summary": "@i18n@request_summary",
            "requested_access": "@i18n@requested_access",
            "dataset_list": "@i18n@dataset_list",
            "business_reason": "@i18n@business_reason",
            "detail_url": "@i18n@detail_url",
        },
        "nodes": {
            "requester_line_manager_review": (
                "@i18n@requester_line_manager_review"
            ),
            "data_owner_review": "@i18n@data_owner_review",
        },
    }
    assert definition["feishu_v4_api_contract"]["node_list"] == [
        {"id": "START"},
        {
            "id": "requester_line_manager_review",
            "name": "@i18n@requester_line_manager_review",
            "node_type": "AND",
            "approver": [{"type": "Supervisor", "level": "1"}],
        },
        {
            "id": "data_owner_review",
            "name": "@i18n@data_owner_review",
            "node_type": "OR",
            "approver": [{"type": "Free"}],
            "approver_chosen_multi": True,
        },
        {"id": "END"},
    ]
    assert (
        definition["feishu_v4_api_contract"]["instance_dynamic_approver_payload"]
        == {
            "node_approver_open_id_list": [
                {"key": "data_owner_review", "value": ["ou_xxx"]},
            ],
        }
    )

    for field_name in DATA_ACCESS_FEISHU_FORM_FIELD_ORDER:
        widget = widgets_by_field[field_name]
        assert widget["custom_id"] == payload_schema[field_name]["id"]
        assert widget["type"] == payload_schema[field_name]["type"]
        assert widget["required"] is True

    default_i18n = next(
        item
        for item in definition["feishu_v4_api_contract"]["i18n_resources"]
        if item["is_default"] is True
    )
    default_texts = {
        item["key"]: item["value"] for item in default_i18n["texts"]
    }
    assert default_i18n["locale"] == "en-US"
    assert default_texts["@i18n@approval_name"] == definition["name"]
    assert default_texts["@i18n@description"] == definition["description"]
    for widget in definition["form_widgets"]:
        key = definition["feishu_v4_api_contract"]["i18n_keys"][
            "form_widgets"
        ][widget["canonical_field"]]
        assert default_texts[key] == widget["label"]


def test_sample_feishu_form_uses_exact_widget_ids_in_submit_order() -> None:
    mapping = _load_json("helix-flow-mapping.json")
    sample_form = _load_json("sample-form.json")
    expected_entries = [
        mapping["payload_schema"][field_name]
        for field_name in DATA_ACCESS_FEISHU_FORM_FIELD_ORDER
    ]

    assert [
        {"id": entry["id"], "type": entry["type"]} for entry in sample_form
    ] == expected_entries
    sample_text = "\n".join(entry["value"] for entry in sample_form)
    assert "gcp-digital-bi-dev" in sample_text
    assert "data-engineering@pingcap.com" in sample_text
    assert "principal_email_group_id" not in sample_text
    assert "provider_member" not in sample_text
    assert "{" not in sample_text


def test_feishu_definition_deploy_script_builds_v4_payload() -> None:
    definition = _load_json("definition.json")
    module = _load_deploy_module()
    payload = module.build_approval_definition_payload(
        definition,
        approval_code="approval-code-dax-prod",
    )

    assert payload["approval_code"] == "approval-code-dax-prod"
    assert payload["approval_name"] == "@i18n@approval_name"
    assert payload["description"] == "@i18n@description"
    assert payload["node_list"] == definition["feishu_v4_api_contract"]["node_list"]
    assert payload["viewers"] == definition["feishu_v4_api_contract"]["viewers"]
    assert (
        payload["i18n_resources"]
        == definition["feishu_v4_api_contract"]["i18n_resources"]
    )

    form_content = json.loads(payload["form"]["form_content"])
    assert [
        {"id": item["id"], "name": item["name"], "type": item["type"]}
        for item in form_content
    ] == [
        {
            "id": "dax_request_summary",
            "name": "@i18n@request_summary",
            "type": "textarea",
        },
        {
            "id": "dax_requested_access",
            "name": "@i18n@requested_access",
            "type": "textarea",
        },
        {
            "id": "dax_dataset_list",
            "name": "@i18n@dataset_list",
            "type": "textarea",
        },
        {
            "id": "dax_business_reason",
            "name": "@i18n@business_reason",
            "type": "textarea",
        },
        {
            "id": "dax_detail_url",
            "name": "@i18n@detail_url",
            "type": "input",
        },
    ]
    assert all(item["required"] is True for item in form_content)