from odoo.tests.common import TransactionCase


class TestHrEmployee(TransactionCase):
    """Tests for hr.employee extensions (_compute*, generate_lv_allocation)."""

    @classmethod
    def setUpClass(cls):
        super().setUpClass()
        # Use a demo employee (created by hr module)
        cls.employee = cls.env.ref("hr.employee_admin")
        # Ensure a clean slate
        cls.employee.write(
            {
                "total_acquired_lv": 0,
                "distributed_lv": 0,
                "dued_lv": 0,
            }
        )

    # ------------------------------------------------------------------
    # _compute_total_acquired_lv
    # ------------------------------------------------------------------

    def test_compute_total_acquired_lv_no_allocations(self):
        """No allocations → total_acquired_lv is 0."""
        self.employee.refresh_lv_values()
        self.assertEqual(self.employee.total_acquired_lv, 0)

    def test_compute_total_acquired_lv_with_allocations(self):
        """Confirmed + distributed allocations are summed."""
        self._create_allocation(state="confirmed", number_acquired_lv=5)
        self._create_allocation(state="distributed", number_acquired_lv=3)
        self.employee.refresh_lv_values()
        self.assertEqual(self.employee.total_acquired_lv, 8)

    def test_compute_total_acquired_lv_excludes_draft(self):
        """Draft allocations are NOT counted."""
        self._create_allocation(state="draft", number_acquired_lv=10)
        self.employee.refresh_lv_values()
        self.assertEqual(self.employee.total_acquired_lv, 0)

    # ------------------------------------------------------------------
    # _compute_distributed_lv
    # ------------------------------------------------------------------

    def test_compute_distributed_lv_no_allocations(self):
        """No allocations → distributed_lv is 0."""
        self.employee.refresh_lv_values()
        self.assertEqual(self.employee.distributed_lv, 0)

    def test_compute_distributed_lv_only_distributed(self):
        """Only 'distributed' state allocations are counted."""
        self._create_allocation(state="distributed", number_distributed_lv=4)
        self._create_allocation(state="confirmed", number_distributed_lv=2)
        self._create_allocation(state="draft", number_distributed_lv=1)
        self.employee.refresh_lv_values()
        self.assertEqual(self.employee.distributed_lv, 4)

    def test_compute_distributed_lv_multiple_distributed(self):
        """Multiple distributed allocations are summed."""
        self._create_allocation(state="distributed", number_distributed_lv=3)
        self._create_allocation(state="distributed", number_distributed_lv=7)
        self.employee.refresh_lv_values()
        self.assertEqual(self.employee.distributed_lv, 10)

    # ------------------------------------------------------------------
    # _compute_dued_lv
    # ------------------------------------------------------------------

    def test_compute_dued_lv(self):
        """dued_lv = total_acquired_lv - distributed_lv."""
        self.employee.write(
            {"total_acquired_lv": 20, "distributed_lv": 6}
        )
        self.employee._compute_dued_lv()
        self.assertEqual(self.employee.dued_lv, 14)

    def test_compute_dued_lv_zero_when_equal(self):
        """dued_lv is 0 when acquired equals distributed."""
        self.employee.write(
            {"total_acquired_lv": 10, "distributed_lv": 10}
        )
        self.employee._compute_dued_lv()
        self.assertEqual(self.employee.dued_lv, 0)

    # ------------------------------------------------------------------
    # generate_lv_allocation
    # ------------------------------------------------------------------

    def test_generate_lv_allocation_creates_record(self):
        """generate_lv_allocation creates an hr.lv.allocation with correct values."""
        campaign_name = "Test Campaign"
        values = {
            "distrib_campaign_name": campaign_name,
            "date_from": "2026-01-01",
            "date_to": "2026-01-31",
        }
        self.employee.generate_lv_allocation(values)
        alloc = self.env["hr.lv.allocation"].search(
            [
                ("employee_id", "=", self.employee.id),
                ("distrib_campaign_name", "=", campaign_name),
            ]
        )
        self.assertTrue(alloc)
        self.assertEqual(len(alloc), 1)
        self.assertEqual(alloc.distrib_campaign_name, campaign_name)
        self.assertEqual(alloc.employee_id, self.employee)
        self.assertIn(self.employee.name, alloc.name)

    def test_generate_lv_allocation_sets_employee_id(self):
        """The passed employee_id in values is overridden by the record's own id."""
        other = self.env["hr.employee"].create(
            {
                "name": "Other Employee",
                "resource_calendar_id": self.employee.resource_calendar_id.id,
            }
        )
        values = {
            "distrib_campaign_name": "Campaign Override",
            "employee_id": other.id,
            "date_from": "2026-02-01",
            "date_to": "2026-02-28",
        }
        self.employee.generate_lv_allocation(values)
        alloc = self.env["hr.lv.allocation"].search(
            [("distrib_campaign_name", "=", "Campaign Override")]
        )
        self.assertEqual(alloc.employee_id, self.employee)

    def test_generate_lv_allocation_updates_counters(self):
        """After creation, acquired and due are computed (triggers create logic)."""
        values = {
            "distrib_campaign_name": "Counters Check",
            "date_from": "2026-03-01",
            "date_to": "2026-03-31",
        }
        self.employee.generate_lv_allocation(values)
        alloc = self.env["hr.lv.allocation"].search(
            [("distrib_campaign_name", "=", "Counters Check")]
        )
        # number_acquired_lv should be computed (may be 0 on non-working days)
        self.assertIsNotNone(alloc.number_acquired_lv)
        self.assertIsNotNone(alloc.number_dued_lv)

    # ------------------------------------------------------------------
    # helpers
    # ------------------------------------------------------------------

    def _create_allocation(self, **kwargs):
        # Extract numeric fields that create() overrides, to set them after creation
        numeric_fields = {
            k: kwargs.pop(k)
            for k in ["number_acquired_lv", "number_dued_lv", "number_distributed_lv"]
            if k in kwargs
        }
        defaults = {
            "employee_id": self.employee.id,
            "distrib_campaign_name": "Test",
            "date_from": "2026-01-01",
            "date_to": "2026-01-31",
            "name": "Test - Employee",
        }
        defaults.update(kwargs)
        alloc = self.env["hr.lv.allocation"].create(defaults)
        if numeric_fields:
            alloc.write(numeric_fields)
        return alloc