import json
import unittest
from pathlib import Path


REPO_ROOT = Path(__file__).resolve().parents[1]
CRM_PACK = REPO_ROOT / "salesforce-crm-standard"


def load_json(path: Path):
    with path.open(encoding="utf-8") as handle:
        return json.load(handle)


def object_spec(api_name: str):
    for spec in load_json(CRM_PACK / "objects" / "standard_objects_spec.json"):
        if spec.get("apiName") == api_name:
            return spec
    raise AssertionError(f"{api_name} object spec missing")


def field_spec(spec: dict, api_name: str):
    for field in spec.get("fields", []):
        if field.get("apiName") == api_name:
            return field
    raise AssertionError(f"{spec.get('apiName')}.{api_name} field spec missing")


def has_pack_or_system_field(spec: dict, api_name: str):
    if api_name == "Id":
        return True
    return any(field.get("apiName") == api_name for field in spec.get("fields", []))


class CampaignRollupStatisticsContractsTest(unittest.TestCase):
    def test_campaign_statistics_fields_are_rollup_summaries(self):
        campaign = object_spec("Campaign")
        expected = {
            "NumberOfLeads": {
                "summaryObject": "CampaignMember",
                "relationshipField": "CampaignId",
                "calcType": "COUNT",
                "filter": "LeadId IS NOT NULL",
                "maintenanceMode": "eventual",
            },
            "NumberOfContacts": {
                "summaryObject": "CampaignMember",
                "relationshipField": "CampaignId",
                "calcType": "COUNT",
                "filter": "ContactId IS NOT NULL",
                "maintenanceMode": "eventual",
            },
            "NumberOfResponses": {
                "summaryObject": "CampaignMember",
                "relationshipField": "CampaignId",
                "calcType": "COUNT",
                "filter": "HasResponded = true",
                "maintenanceMode": "eventual",
            },
            "NumberOfConvertedLeads": {
                "summaryObject": "CampaignMember",
                "relationshipField": "CampaignId",
                "calcType": "COUNT",
                "filter": "LeadId IS NOT NULL AND LeadIsConverted = true",
                "maintenanceMode": "eventual",
            },
            "NumberOfOpportunities": {
                "summaryObject": "Opportunity",
                "relationshipField": "CampaignId",
                "calcType": "COUNT",
            },
            "NumberOfWonOpportunities": {
                "summaryObject": "Opportunity",
                "relationshipField": "CampaignId",
                "calcType": "COUNT",
                "filter": "IsWon = true",
            },
            "AmountAllOpportunities": {
                "summaryObject": "Opportunity",
                "summaryField": "Amount",
                "relationshipField": "CampaignId",
                "calcType": "SUM",
            },
            "AmountWonOpportunities": {
                "summaryObject": "Opportunity",
                "summaryField": "Amount",
                "relationshipField": "CampaignId",
                "calcType": "SUM",
                "filter": "IsWon = true",
            },
        }
        expected_return_types = {
            "NumberOfLeads": "int",
            "NumberOfContacts": "int",
            "NumberOfResponses": "int",
            "NumberOfConvertedLeads": "int",
            "NumberOfOpportunities": "int",
            "NumberOfWonOpportunities": "int",
            "AmountAllOpportunities": "currency",
            "AmountWonOpportunities": "currency",
        }

        for field_api_name, rollup_config in expected.items():
            with self.subTest(field=field_api_name):
                field = field_spec(campaign, field_api_name)
                self.assertEqual(field.get("type"), "rollupsummary")
                self.assertEqual(field.get("returnType"), expected_return_types[field_api_name])
                self.assertFalse(field.get("createable"))
                self.assertFalse(field.get("updateable"))
                self.assertEqual(field.get("rollupConfig"), rollup_config)

    def test_rollup_referenced_fields_exist(self):
        campaign_member = object_spec("CampaignMember")
        opportunity = object_spec("Opportunity")

        for field_api_name in (
            "CampaignId",
            "LeadId",
            "ContactId",
            "HasResponded",
            "LeadIsConverted",
        ):
            with self.subTest(object="CampaignMember", field=field_api_name):
                self.assertIsNotNone(field_spec(campaign_member, field_api_name))

        for field_api_name in ("CampaignId", "Amount", "IsWon"):
            with self.subTest(object="Opportunity", field=field_api_name):
                self.assertIsNotNone(field_spec(opportunity, field_api_name))

    def test_number_of_converted_leads_uses_lead_projection(self):
        campaign_member = object_spec("CampaignMember")
        lead_is_converted = field_spec(campaign_member, "LeadIsConverted")

        self.assertEqual(lead_is_converted.get("type"), "boolean")
        self.assertFalse(lead_is_converted.get("createable"))
        self.assertFalse(lead_is_converted.get("updateable"))
        self.assertEqual(lead_is_converted.get("returnType"), "boolean")
        self.assertEqual(lead_is_converted.get("formulaMode"), "active")
        self.assertEqual(
            lead_is_converted.get("projection"),
            {
                "kind": "lookupValue",
                "targetObject": "Lead",
                "selectField": "IsConverted",
                "matches": [{"targetField": "Id", "sourceField": "LeadId"}],
                "excludeDeleted": True,
            },
        )

    def test_projection_references_resolve_to_pack_or_system_fields(self):
        projection_fields = [
            ("CampaignMember", "HasResponded"),
            ("CampaignMember", "LeadIsConverted"),
            ("Opportunity", "IsWon"),
        ]

        for source_object_name, field_api_name in projection_fields:
            with self.subTest(field=f"{source_object_name}.{field_api_name}"):
                source = object_spec(source_object_name)
                field = field_spec(source, field_api_name)
                projection = field.get("projection")
                self.assertIsInstance(projection, dict)

                target = object_spec(projection.get("targetObject"))
                self.assertTrue(
                    has_pack_or_system_field(target, projection.get("selectField")),
                    f"{projection.get('targetObject')}.{projection.get('selectField')} missing",
                )
                for match in projection.get("matches", []):
                    self.assertTrue(
                        has_pack_or_system_field(target, match.get("targetField")),
                        f"{projection.get('targetObject')}.{match.get('targetField')} missing",
                    )
                    self.assertTrue(
                        has_pack_or_system_field(source, match.get("sourceField")),
                        f"{source_object_name}.{match.get('sourceField')} missing",
                    )

    def test_opportunity_stage_object_and_is_won_projection(self):
        stage = object_spec("OpportunityStage")
        opportunity = object_spec("Opportunity")

        self.assertEqual(stage.get("keyPrefix"), "01J")
        self.assertEqual(stage.get("sharingModel"), "PublicRead")

        expected_field_types = {
            "MasterLabel": "string",
            "ApiName": "string",
            "IsActive": "boolean",
            "SortOrder": "double",
            "IsClosed": "boolean",
            "IsWon": "boolean",
            "ForecastCategory": "picklist",
            "ForecastCategoryName": "string",
            "DefaultProbability": "percent",
        }
        for field_api_name, field_type in expected_field_types.items():
            with self.subTest(object="OpportunityStage", field=field_api_name):
                self.assertEqual(field_spec(stage, field_api_name).get("type"), field_type)

        self.assertTrue(field_spec(stage, "MasterLabel").get("isNameField"))
        self.assertEqual(
            [
                option.get("value")
                for option in field_spec(stage, "ForecastCategory").get("options", [])
            ],
            ["Omitted", "Pipeline", "BestCase", "MostLikely", "Forecast", "Closed"],
        )

        is_won = field_spec(opportunity, "IsWon")
        self.assertEqual(is_won.get("type"), "boolean")
        self.assertFalse(is_won.get("createable"))
        self.assertFalse(is_won.get("updateable"))
        self.assertEqual(is_won.get("returnType"), "boolean")
        self.assertEqual(is_won.get("formulaMode"), "active")
        self.assertEqual(
            is_won.get("projection"),
            {
                "kind": "lookupValue",
                "targetObject": "OpportunityStage",
                "selectField": "IsWon",
                "matches": [{"targetField": "MasterLabel", "sourceField": "StageName"}],
                "excludeDeleted": True,
            },
        )


if __name__ == "__main__":
    unittest.main()