# Copyright 2025 Criptomart
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)


from odoo.tests.common import TransactionCase


class TestProductExtension(TransactionCase):
    """Test suite para las extensiones de product.template."""

    def setUp(self):
        super().setUp()
        self.product = self.env["product.product"].create(
            {
                "name": "Test Product",
            }
        )
        self.order = self.env["group.order"].create(
            {"name": "Test Order", "product_ids": [(4, self.product.id)]}
        )

    def test_product_template_group_order_ids_field_exists(self):
        """Test que el campo group_order_ids existe en product.template."""
        product_template = self.product.product_tmpl_id

        # El campo debe existir y ser readonly
        self.assertTrue(hasattr(product_template, "group_order_ids"))

    def test_product_group_order_ids_readonly(self):
        """Test that group_order_ids is a readonly field"""
        field = self.env["product.template"]._fields["group_order_ids"]
        self.assertTrue(field.readonly)

    def test_product_group_order_ids_reverse_lookup(self):
        """Test that adding a product to an order reflects in group_order_ids"""
        related_orders = self.product.product_tmpl_id.group_order_ids
        self.assertIn(self.order, related_orders)

    def test_product_group_order_ids_empty_by_default(self):
        """Test that a new product has no group orders"""
        new_product = self.env["product.product"].create({"name": "New Product"})
        self.assertFalse(new_product.product_tmpl_id.group_order_ids)

    def test_product_group_order_ids_multiple_orders(self):
        """Test that group_order_ids can contain multiple orders"""
        order2 = self.env["group.order"].create(
            {"name": "Test Order 2", "product_ids": [(4, self.product.id)]}
        )
        self.assertIn(self.order, self.product.product_tmpl_id.group_order_ids)
        self.assertIn(order2, self.product.product_tmpl_id.group_order_ids)

    def test_product_group_order_ids_empty_after_remove_from_order(self):
        """Test that group_order_ids is empty after removing the product from all orders"""
        self.order.write({"product_ids": [(3, self.product.id)]})
        self.assertFalse(self.product.product_tmpl_id.group_order_ids)

    def test_product_group_order_ids_with_multiple_products(self):
        """Test group_order_ids with multiple products in one order"""
        product2 = self.env["product.product"].create({"name": "Test Product 2"})
        self.order.write({"product_ids": [(4, self.product.id), (4, product2.id)]})
        self.assertIn(self.order, self.product.product_tmpl_id.group_order_ids)
        self.assertIn(self.order, product2.product_tmpl_id.group_order_ids)

    def test_product_with_variants_group_order_ids(self):
        """Test that group_order_ids works correctly with product variants"""
        # Create a product template with two variants
        product_template = self.env["product.template"].create(
            {
                "name": "Product with Variants",
                "attribute_line_ids": [
                    (
                        0,
                        0,
                        {
                            "attribute_id": self.env.ref(
                                "product.product_attribute_1"
                            ).id,
                            "value_ids": [
                                (
                                    4,
                                    self.env.ref(
                                        "product.product_attribute_value_1"
                                    ).id,
                                ),
                                (
                                    4,
                                    self.env.ref(
                                        "product.product_attribute_value_2"
                                    ).id,
                                ),
                            ],
                        },
                    )
                ],
            }
        )
        variant1 = product_template.product_variant_ids[0]
        variant2 = product_template.product_variant_ids[1]

        # Add one variant to an order (store variant id, not template id)
        order_with_variant = self.env["group.order"].create(
            {"name": "Order with Variant", "product_ids": [(4, variant1.id)]}
        )

        # Check that the order appears in the group_order_ids of the template
        self.assertIn(order_with_variant, product_template.group_order_ids)

        # Check that the order also appears for both variants (as it's a related field on template)
        related_orders_v1 = variant1.product_tmpl_id.group_order_ids
        related_orders_v2 = variant2.product_tmpl_id.group_order_ids
        self.assertIn(order_with_variant, related_orders_v1)
        self.assertIn(order_with_variant, related_orders_v2)