"""Regression: choose-for-me on form-field questions after quote/contact are stated."""

from src.domain.projects.discovery_fidelity import (
    local_choose_for_me_turn,
    question_is_unnecessary,
    seed_stated_form_workflows,
)
from src.domain.projects.discovery_readiness import finalize_discovery_result
from src.domain.projects.discovery_schemas import (
    Actor,
    DiscoveryQuestion,
    DiscoveryReadiness,
    DiscoverySpec,
    DiscoveryTurnResult,
    ProductDefinition,
)


def _agency_state():
    spec = DiscoverySpec(
        product=ProductDefinition(
            name="San Diego Agency",
            name_status="working",
            purpose="Showcase web design services",
            first_build_goal="Attract new clients",
        ),
        archetypes=["marketing_site"],
        actors=[Actor(id="visitor", name="Visitor", description="Prospective clients")],
    )
    question = DiscoveryQuestion(
        decision_id="missing_primary_workflow",
        text=(
            "What information should be collected in the 'Get a Quote' form "
            "and the contact form for existing customers?"
        ),
    )
    messages = [
        {
            "role": "user",
            "content": (
                "So we are a web design web development company located in san diego, "
                "we need to showcase our services we provide logo design, web design, "
                "ecommerce and AI Development work."
            ),
        },
        {"role": "assistant", "content": "Primary purpose?"},
        {"role": "user", "content": "Attract new clients"},
        {"role": "assistant", "content": "Workflows?"},
        {
            "role": "user",
            "content": (
                "Get a Quote form on our services pages as well as a contact form "
                "for existence customers."
            ),
        },
        {"role": "assistant", "content": "Form fields?"},
        {"role": "user", "content": "Choose the recommended setup for me."},
    ]
    return {
        "latest_input": {
            "type": "choose_for_me",
            "decision_id": "missing_primary_workflow",
        },
        "messages": messages,
        "result": {
            "decision": "clarify",
            "message": "Form details",
            "question": question.model_dump(),
            "spec": spec.model_dump(),
            "project_type": "nuxt_app",
            "requested_capabilities": [],
            "template_fit": "none",
            "template_reason": "",
        },
    }


def test_portfolio_navigation_question_is_conventional_codegen_detail():
    question = DiscoveryQuestion(
        decision_id="missing_primary_workflow",
        text=(
            "What are the main user interactions or flows you envision for the portfolio, "
            "such as navigation through sections or engagement with content?"
        ),
    )
    spec = DiscoverySpec(
        product=ProductDefinition(
            name="Agency site",
            name_status="working",
            purpose="Showcase design services",
            first_build_goal="Attract clients",
        ),
        archetypes=["marketing_site"],
        actors=[Actor(id="visitor", name="Visitor")],
    )
    payload = {
        "messages": [
            {
                "role": "user",
                "content": "Portfolio site for our San Diego web design agency to attract clients.",
            }
        ],
        "latest_input": {
            "type": "message",
            "content": "Portfolio site for our San Diego web design agency to attract clients.",
        },
    }
    assert question_is_unnecessary(question, spec, payload)


def test_seed_marketing_showcase_browse_convert_when_no_forms_named():
    spec = DiscoverySpec(
        product=ProductDefinition(
            name="Agency",
            name_status="working",
            purpose="Showcase services",
            first_build_goal="Attract clients",
        ),
        archetypes=["marketing_site"],
        actors=[Actor(id="visitor", name="Visitor")],
    )
    seeded = seed_stated_form_workflows(
        spec,
        {
            "messages": [
                {
                    "role": "user",
                    "content": (
                        "Portfolio site for our San Diego web design agency "
                        "to showcase services and attract new clients."
                    ),
                }
            ]
        },
    )
    assert [item.id for item in seeded.workflows] == ["browse_and_convert"]


def test_form_field_question_is_conventional_codegen_detail():
    state = _agency_state()
    question = DiscoveryQuestion.model_validate(state["result"]["question"])
    spec = DiscoverySpec.model_validate(state["result"]["spec"])
    payload = {"messages": state["messages"], "latest_input": state["latest_input"]}
    assert question_is_unnecessary(question, spec, payload)


def test_seed_quote_and_contact_workflows_from_user_text():
    state = _agency_state()
    spec = DiscoverySpec.model_validate(state["result"]["spec"])
    seeded = seed_stated_form_workflows(
        spec, {"messages": state["messages"], "latest_input": state["latest_input"]}
    )
    assert {item.id for item in seeded.workflows} == {"get_quote", "contact"}


def test_choose_for_me_resolves_locally_to_ready_without_provider():
    state = _agency_state()
    turn = local_choose_for_me_turn(state)
    assert turn is not None
    payload = {
        "messages": state["messages"],
        "latest_input": state["latest_input"],
        "templates": [],
        "boilerplates": {"nuxt_app": "Nuxt"},
    }
    result = finalize_discovery_result(turn, payload)
    assert result.decision == "ready"
    assert result.question is None
    assert {item.id for item in result.spec.workflows} == {"get_quote", "contact"}


def test_embedded_jotform_does_not_trigger_native_field_or_action_questions():
    spec = DiscoverySpec(
        product=ProductDefinition(
            purpose="Marketing website for a local business",
            first_build_goal="Embed our Jotform on the contact page",
        ),
        archetypes=["marketing_site"],
        actors=[Actor(id="visitor", name="Visitor")],
    )
    payload = {
        "messages": [
            {
                "role": "user",
                "content": "Build a website and embed our Jotform on the contact page.",
            }
        ],
        "latest_input": {
            "type": "message",
            "content": "Build a website and embed our Jotform on the contact page.",
        },
    }
    question = DiscoveryQuestion(
        decision_id="missing_primary_workflow",
        text="What fields and submission actions should the form include?",
    )
    assert question_is_unnecessary(question, spec, payload)
    seeded = seed_stated_form_workflows(spec, payload)
    assert [item.id for item in seeded.workflows] == ["external_form_submission"]
    assert seeded.forms == ["Jotform"]
    assert seeded.integrations[0].provider == "Jotform"


def test_embedded_jotform_clarification_is_promoted_to_ready():
    prompt = "Build a small business website and embed our Jotform on the contact page."
    turn = DiscoveryTurnResult(
        decision="clarify",
        message="I need the form fields and actions.",
        question=DiscoveryQuestion(
            decision_id="missing_primary_workflow",
            text="What fields and actions should the Jotform include?",
        ),
        spec=DiscoverySpec(
            product=ProductDefinition(
                purpose="Small business website",
                first_build_goal="Embed our Jotform on the contact page",
            ),
            archetypes=["marketing_site"],
            actors=[Actor(id="visitor", name="Visitor")],
        ),
        readiness=DiscoveryReadiness(buildable=False),
        project_type="nuxt_app",
    )
    result = finalize_discovery_result(
        turn,
        {
            "latest_input": {"type": "message", "content": prompt},
            "messages": [{"role": "user", "content": prompt}],
            "boilerplates": {"nuxt_app": "Nuxt"},
            "templates": [],
        },
    )
    assert result.decision == "ready"
    assert result.question is None
    assert result.spec.integrations[0].provider == "Jotform"