"""Repo inspection, data model, metadata retrieval, and governor limit checks."""

from __future__ import annotations

import uuid

import httpx
import pytest

from packages.agents.salesforce_developer import SalesforceDeveloper
from packages.agents.solution_architect import (
    SolutionArchitect,
    apply_data_model_checks,
    apply_existing_code_checks,
    build_architect_prompt,
)
from packages.integrations.github_search import CodeEvidence
from packages.artifacts.design import DesignArtifact, MetadataPlanItem
from packages.artifacts.requirements import RequirementsArtifact
from packages.config import Settings
from packages.db.artifacts import ArtifactStore
from packages.integrations.github_repo import GitHubRepoReader
from packages.integrations.governor_limits import check_apex, check_flow, check_governor_limits
from packages.integrations.metadata_retriever import GitHubMetadataRetriever, MockMetadataRetriever
from packages.integrations.org_schema import (
    DataModel,
    FieldInfo,
    MockOrgSchemaProvider,
    ObjectSchema,
    RepoOrgSchemaProvider,
    detect_objects,
)
from packages.knowledge.retrievers import (
    GitHubRepoRetriever,
    KnowledgeService,
    MockConfluenceRetriever,
)

TIER_FIELD_XML = """<?xml version="1.0" encoding="UTF-8"?>
<CustomField xmlns="http://soap.sforce.com/2006/04/metadata">
    <fullName>Customer_Tier__c</fullName>
    <label>Customer Tier</label>
    <type>Picklist</type>
    <valueSet><valueSetDefinition>
        <value><fullName>Gold</fullName></value>
        <value><fullName>Silver</fullName></value>
    </valueSetDefinition></valueSet>
</CustomField>
"""

REPO_FILES = {
    "force-app/main/default/classes/AccountTierService.cls": "public with sharing class AccountTierService { }",
    "force-app/main/default/classes/AccountTierService.cls-meta.xml": "<ApexClass/>",
    "force-app/main/default/triggers/AccountTrigger.trigger": "trigger AccountTrigger on Account (before insert) {}",
    "force-app/main/default/flows/Account_Tier_Sync.flow-meta.xml": "<Flow/>",
    "force-app/main/default/lwc/tierBadge/tierBadge.js": "export default class TierBadge {}",
    "force-app/main/default/objects/Account/fields/Customer_Tier__c.field-meta.xml": TIER_FIELD_XML,
    "force-app/main/default/objects/Account/validationRules/Gold_Needs_Revenue.validationRule-meta.xml": "<ValidationRule/>",
    "README.md": "# repo",
}


def _github_settings() -> Settings:
    return Settings(
        git_provider="github",
        git_repo_url="https://github.com/acme/sfdx",
        git_default_branch="main",
        github_token="t",
    )


def _reader() -> GitHubRepoReader:
    def handler(request: httpx.Request) -> httpx.Response:
        path = request.url.path
        if path == "/repos/acme/sfdx/git/trees/main":
            return httpx.Response(
                200, json={"tree": [{"path": p, "type": "blob"} for p in REPO_FILES]}
            )
        prefix = "/repos/acme/sfdx/contents/"
        if path.startswith(prefix):
            content = REPO_FILES.get(path[len(prefix):])
            if content is None:
                return httpx.Response(404, json={"message": "Not Found"})
            return httpx.Response(200, text=content)
        return httpx.Response(404)

    return GitHubRepoReader(_github_settings(), transport=httpx.MockTransport(handler))


@pytest.mark.asyncio
async def test_repo_retriever_returns_inventory_and_matching_files():
    retriever = GitHubRepoRetriever(_github_settings(), reader=_reader())
    hits = await retriever.search("Account customer tier picklist", limit=5)

    assert hits[0].title.startswith("Repository inventory")
    assert "1 ApexClass" in hits[0].snippet
    assert "1 ApexTrigger" in hits[0].snippet
    assert "1 Flow" in hits[0].snippet
    assert "1 LightningComponentBundle" in hits[0].snippet
    assert "Account (1)" in hits[0].snippet
    titles = [h.title for h in hits[1:]]
    assert any("Customer_Tier__c" in t for t in titles)
    assert all(h.source == "git" for h in hits)
    assert not any(t.startswith("README") for t in titles)


@pytest.mark.asyncio
async def test_repo_schema_provider_parses_fields_and_rules():
    provider = RepoOrgSchemaProvider(_github_settings(), reader=_reader())
    model = await provider.describe(["Account", "Invoice__c"])

    account = model.get("Account")
    assert account is not None and account.exists
    tier = next(f for f in account.fields if f.name == "Customer_Tier__c")
    assert tier.type == "Picklist"
    assert tier.picklist_values == ["Gold", "Silver"]
    assert account.validation_rules == ["Gold_Needs_Revenue"]
    assert model.get("Invoice__c").exists is False
    assert "Customer_Tier__c" in model.prompt_block()


def test_detect_objects_finds_standard_and_custom_objects():
    text = "Add a tier field on Accounts and link the Invoice__c object to Opportunity"
    assert detect_objects(text) == ["Account", "Opportunity", "Invoice__c"]


def test_data_model_checks_switch_existing_field_to_update_and_flag_missing_object():
    model = DataModel(
        source="test",
        objects=[
            ObjectSchema(name="Account", fields=[FieldInfo(name="Customer_Tier__c", custom=True)]),
            ObjectSchema(name="Invoice__c", exists=False),
        ],
    )
    design = DesignArtifact(
        jira_key="SALES-1",
        summary="Tier",
        approach="x",
        metadata_plan=[
            MetadataPlanItem(metadata_type="CustomField", api_name="Customer_Tier__c", action="create", object="Account"),
            MetadataPlanItem(metadata_type="CustomField", api_name="Amount__c", action="create", object="Invoice__c"),
        ],
    )
    apply_data_model_checks(design, model)

    assert design.metadata_plan[0].action == "update"
    assert any("already exists" in r for r in design.risks_or_escalations)
    assert any("Invoice__c not found" in r for r in design.risks_or_escalations)


@pytest.mark.asyncio
async def test_architect_includes_data_model_and_writes_artifact(artifacts_tmpdir):
    schema = MockOrgSchemaProvider()
    schema.extra_fields["Account"] = [FieldInfo(name="Customer_Tier__c", type="picklist", custom=True)]
    architect = SolutionArchitect(
        knowledge=KnowledgeService(confluence=MockConfluenceRetriever()),
        schema=schema,
    )
    requirements = RequirementsArtifact(
        jira_key="SALES-101",
        summary="Add Customer Tier picklist on Account",
        acceptance_criteria=["Account has a Customer_Tier__c picklist field"],
        is_clear=True,
        confidence=0.9,
    )
    run_id = uuid.uuid4()
    design = await architect.design(requirements, run_id=run_id)

    assert schema.calls == [["Account"]]
    field_items = [i for i in design.metadata_plan if i.api_name == "Customer_Tier__c"]
    assert field_items and field_items[0].action == "update"
    saved = ArtifactStore().read_json(run_id, "data-model.json")
    assert saved["objects"][0]["name"] == "Account"


@pytest.mark.asyncio
async def test_developer_keeps_existing_source_from_retrieve(artifacts_tmpdir):
    retriever = MockMetadataRetriever()
    existing_cls = "public with sharing class AccountTierService {\n    // real logic\n}\n"
    retriever.existing["force-app/main/default/classes/AccountTierService.cls"] = existing_cls
    dev = SalesforceDeveloper(retriever=retriever)
    design = DesignArtifact(
        jira_key="SALES-2",
        summary="Tier service",
        approach="x",
        metadata_plan=[
            MetadataPlanItem(metadata_type="ApexClass", api_name="AccountTierService", action="update"),
            MetadataPlanItem(metadata_type="CustomField", api_name="New_Field__c", action="create", object="Account"),
        ],
    )
    run_id = uuid.uuid4()
    _artifact, files = await dev.implement(design, None, run_id)

    assert files["force-app/main/default/classes/AccountTierService.cls"] == existing_cls
    assert "Agent Nova stub" in files["force-app/main/default/objects/Account/fields/New_Field__c.field-meta.xml"]
    assert retriever.calls == [["ApexClass:AccountTierService", "CustomField:Account.New_Field__c"]]
    index = ArtifactStore().read_json(run_id, "retrieved-metadata.json")
    assert list(index["files"]) == ["force-app/main/default/classes/AccountTierService.cls"]
    assert "Existing versions kept" in files["implementation-summary.md"]


@pytest.mark.asyncio
async def test_github_metadata_retriever_reads_existing_and_reports_missing():
    from packages.integrations.metadata_retriever import MetadataRequest

    retriever = GitHubMetadataRetriever(_github_settings(), reader=_reader())
    result = await retriever.retrieve(
        [
            MetadataRequest(
                metadata_type="CustomField",
                member="Account.Customer_Tier__c",
                paths=["force-app/main/default/objects/Account/fields/Customer_Tier__c.field-meta.xml"],
            ),
            MetadataRequest(
                metadata_type="ApexClass",
                member="Missing",
                paths=["force-app/main/default/classes/Missing.cls"],
            ),
        ]
    )
    assert "Customer_Tier__c" in next(iter(result.files.values()))
    assert result.missing == ["force-app/main/default/classes/Missing.cls"]


def test_governor_flags_soql_and_dml_inside_loops_only():
    source = """public with sharing class TierService {
    public static void run(List<Account> accounts) {
        // [SELECT Id FROM Contact] in a comment is ignored
        for (Account a : [SELECT Id FROM Account WHERE Id IN :accounts]) {
            List<Contact> cs = [SELECT Id FROM Contact WHERE AccountId = :a.Id];
            update a;
        }
        for (Integer i = 0; i < 3; i++) insert new Task(Subject = 'update x');
        update accounts;
    }
}
"""
    violations = check_apex("force-app/main/default/classes/TierService.cls", source)
    by_rule = {(v.rule, v.line) for v in violations}
    assert ("SOQLInLoop", 5) in by_rule
    assert ("DMLInLoop", 6) in by_rule
    assert ("DMLInLoop", 8) in by_rule
    assert not any(v.line in (3, 4, 9) for v in violations)


def test_governor_flags_unbounded_soql_and_trigger_first_record():
    trigger = """trigger AccountTrigger on Account (before insert) {
    Account a = Trigger.new[0];
    List<Account> all = [SELECT Id FROM Account];
}
"""
    rules = {v.rule for v in check_apex("force-app/main/default/triggers/AccountTrigger.trigger", trigger)}
    assert rules == {"TriggerNotBulkified", "UnboundedSOQL"}


def test_governor_flags_flow_get_records_inside_loop():
    flow = """<?xml version="1.0" encoding="UTF-8"?>
<Flow xmlns="http://soap.sforce.com/2006/04/metadata">
    <loops>
        <name>Loop_Accounts</name>
        <nextValueConnector><targetReference>Get_Contacts</targetReference></nextValueConnector>
        <noMoreValuesConnector><targetReference>Update_All</targetReference></noMoreValuesConnector>
    </loops>
    <recordLookups>
        <name>Get_Contacts</name>
        <connector><targetReference>Loop_Accounts</targetReference></connector>
    </recordLookups>
    <recordUpdates>
        <name>Update_All</name>
    </recordUpdates>
</Flow>
"""
    violations = check_flow("force-app/main/default/flows/X.flow-meta.xml", flow)
    assert len(violations) == 1
    assert "Get_Contacts" in violations[0].message


def test_governor_clean_on_generated_stubs():
    files = {
        "force-app/main/default/classes/X.cls": "public with sharing class X { public static void run() {} }",
        "force-app/main/default/triggers/T.trigger": "trigger T on Account (before insert, before update) {}",
    }
    assert check_governor_limits(files) == []


TIER_PATH = "force-app/main/default/objects/Account/fields/Customer_Tier__c.field-meta.xml"


def _tier_design() -> DesignArtifact:
    return DesignArtifact(
        jira_key="SALES-101",
        summary="Tier",
        approach="x",
        metadata_plan=[
            MetadataPlanItem(metadata_type="CustomField", api_name="Customer_Tier__c", action="create", object="Account"),
            MetadataPlanItem(metadata_type="ApexClass", api_name="TierService", action="create"),
            MetadataPlanItem(metadata_type="ApexClass", api_name="Brand_New", action="create"),
        ],
    )


def test_existing_code_checks_flip_to_update_and_flag_open_work():
    design = _tier_design()
    existing = [
        CodeEvidence(kind="code", repo="acme/sfdx", title=TIER_PATH, state="default"),
        CodeEvidence(
            kind="pr_file",
            repo="acme/sfdx",
            title="force-app/main/default/classes/TierService.cls",
            ref="wip/SALES-101",
            state="open",
        ),
        CodeEvidence(kind="branch", repo="acme/sfdx", title="wip/SALES-101", url="https://github.com/acme/sfdx/tree/wip/SALES-101", state="open"),
    ]
    apply_existing_code_checks(design, existing)

    field, cls, new = design.metadata_plan
    assert field.action == "update"
    assert cls.action == "create"
    assert new.action == "create"
    risks = design.risks_or_escalations
    assert any("Account.Customer_Tier__c already exists in acme/sfdx" in r for r in risks)
    assert any("TierService is also changed on open branch wip/SALES-101" in r for r in risks)
    assert any("Open branch for SALES-101" in r for r in risks)


def test_existing_code_default_branch_wins_over_open_pr_file():
    design = _tier_design()
    existing = [
        CodeEvidence(kind="pr_file", repo="acme/sfdx", title=TIER_PATH, ref="wip", state="open"),
        CodeEvidence(kind="code", repo="acme/sfdx", title=TIER_PATH, state="default"),
    ]
    apply_existing_code_checks(design, existing)
    assert design.metadata_plan[0].action == "update"


def test_architect_prompt_lists_existing_code():
    requirements = RequirementsArtifact(
        jira_key="SALES-101", summary="Tier", acceptance_criteria=[], is_clear=True, confidence=0.9
    )
    ev = CodeEvidence(
        kind="code", repo="acme/sfdx", title=TIER_PATH, url="https://github.com/acme/sfdx/blob/main/x", state="default"
    )
    prompt = build_architect_prompt(requirements, [], None, [ev])
    assert f"[code default] acme/sfdx: {TIER_PATH}" in prompt
    assert "never recreate a file that already" in prompt
    assert "(none found)" in build_architect_prompt(requirements, [], None, None)
