import json
import unittest
from pathlib import Path


ROOT = Path(__file__).resolve().parents[1]
EVENT_SOURCE = ROOT / "packs" / "Salesforce-PingCAP-L2" / "objects" / "Event.json"
FINAL_OBJECTS = (
    ROOT
    / "packs"
    / "NOT-EDIT-final-merged-packs"
    / "objects"
    / "standard_objects_spec.json"
)
WHOID_REGRESSION_CASE = (
    ROOT
    / "staging-inspection"
    / "config"
    / "cases"
    / "uat-sales-workflows"
    / "activities"
    / "task-controlled-by-parent-whoid-visibility-api.json"
)
EXPECTED_ROW_READ = {
    "kind": "targetRecordRead",
    "targetAssociations": [
        {
            "targetObjectField": "WhatId_type",
            "targetRecordField": "WhatId",
        },
        {
            "targetObjectField": "WhoId_type",
            "targetRecordField": "WhoId",
        },
    ],
    "includeSourceVisibility": True,
}


class ActivityRowReadContractsTest(unittest.TestCase):
    def test_event_overlay_preserves_grouped_activity_visibility(self):
        event_source = json.loads(EVENT_SOURCE.read_text())[0]

        self.assertEqual(
            event_source.get("accessPolicy", {}).get("rowRead"),
            EXPECTED_ROW_READ,
        )

    def test_final_pack_composes_task_and_event_visibility_contracts(self):
        final_objects = json.loads(FINAL_OBJECTS.read_text())

        for api_name in ("Task", "Event"):
            with self.subTest(api_name=api_name):
                activity = next(
                    obj for obj in final_objects if obj["apiName"] == api_name
                )
                self.assertEqual(
                    activity.get("accessPolicy", {}).get("rowRead"),
                    EXPECTED_ROW_READ,
                )

    def test_whoid_visibility_regression_is_enabled_with_bounded_cleanup(self):
        regression_case = json.loads(WHOID_REGRESSION_CASE.read_text())

        self.assertFalse(regression_case.get("optional", False))
        self.assertNotIn("optionalReason", regression_case)
        self.assertEqual(
            [step["id"] for step in regression_case.get("cleanupSteps", [])],
            [
                "cleanup-delete-group-member",
                "cleanup-delete-user-child-group-member",
                "cleanup-delete-task",
                "cleanup-delete-lead",
                "cleanup-delete-disposable-membership-group",
            ],
        )
        for cleanup_step in regression_case["cleanupSteps"]:
            with self.subTest(cleanup_step=cleanup_step["id"]):
                self.assertIn("whenPathExists", cleanup_step)
                self.assertEqual(cleanup_step.get("expectStatuses"), [204, 404])
                self.assertEqual(cleanup_step.get("retry", {}).get("attempts"), 3)

        steps = {step["id"]: step for step in regression_case["steps"]}
        self.assertNotIn("create-disposable-lead-sharing-rule", steps)
        self.assertNotIn("create-disposable-sharing-group", steps)
        self.assertEqual(
            steps["peer-user-cannot-read-lead-before-membership"].get("expectStatus"),
            404,
        )
        self.assertEqual(
            steps["peer-user-cannot-read-task-before-parent-access"].get("expectStatus"),
            404,
        )
        self.assertEqual(steps["peer-user-reads-task-directly"].get("expectStatus"), 200)
        self.assertEqual(
            steps["peer-user-sees-task-in-lead-activity-query"].get("expectStatus"),
            200,
        )
        self.assertIn(
            {"path": "response.body.totalSize", "numericEquals": 1},
            steps["peer-user-sees-task-in-lead-activity-query"].get("assertions", []),
        )

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