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

"""
Test suite for save_eskaera_draft() and save_cart_draft() endpoints.

These tests ensure that both endpoints correctly save group_order_id and
related fields (pickup_day, pickup_date, home_delivery) when creating
draft sale orders.

See: website_sale_aplicoop/controllers/website_sale.py
"""

from datetime import datetime, timedelta

from odoo.tests.common import TransactionCase


class TestSaveOrderEndpoints(TransactionCase):
    """Test suite for order-saving endpoints."""

    def setUp(self):
        super().setUp()

        # Create a consumer group
        self.group = self.env['res.partner'].create({
            'name': 'Test Group',
            'is_company': True,
            'email': 'group@test.com',
        })

        # Create a group member (user partner)
        self.member_partner = self.env['res.partner'].create({
            'name': 'Group Member Partner',
            'email': 'member@test.com',
        })

        # Add member to group
        self.group.member_ids = [(4, self.member_partner.id)]

        # Create test user
        self.user = self.env['res.users'].create({
            'name': 'Test User',
            'login': 'testuser@test.com',
            'email': 'testuser@test.com',
            'partner_id': self.member_partner.id,
        })

        # Create a group order
        start_date = datetime.now().date()
        end_date = start_date + timedelta(days=7)

        self.group_order = self.env['group.order'].create({
            'name': 'Test Group Order',
            'group_ids': [(6, 0, [self.group.id])],
            'type': 'regular',
            'start_date': start_date,
            'end_date': end_date,
            'period': 'weekly',
            'pickup_day': '3',  # Wednesday
            'pickup_date': start_date + timedelta(days=3),
            'home_delivery': False,
            'cutoff_day': '0',
        })

        # Open the group order
        self.group_order.action_open()

        # Create products for the order
        self.category = self.env['product.category'].create({
            'name': 'Test Category',
        })

        self.product = self.env['product.product'].create({
            'name': 'Test Product',
            'type': 'consu',
            'list_price': 10.0,
            'categ_id': self.category.id,
        })

        # Associate product with group order
        self.group_order.product_ids = [(4, self.product.id)]

    def test_save_eskaera_draft_creates_order_with_group_order_id(self):
        """
        Test that save_eskaera_draft() creates a sale.order with group_order_id.
        
        This is the main fix: ensure that the /eskaera/save-order endpoint
        correctly links the created sale.order to the group.order.
        """
        # Simulate what the controller does: create order with group_order_id
        order_vals = {
            'partner_id': self.member_partner.id,
            'group_order_id': self.group_order.id,
            'pickup_day': self.group_order.pickup_day,
            'pickup_date': self.group_order.pickup_date,
            'home_delivery': self.group_order.home_delivery,
            'order_line': [],
            'state': 'draft',
        }

        sale_order = self.env['sale.order'].create(order_vals)

        # Verify the order was created with group_order_id
        self.assertIsNotNone(sale_order.id)
        self.assertEqual(sale_order.group_order_id.id, self.group_order.id)
        self.assertEqual(sale_order.group_order_id.name, self.group_order.name)

    def test_save_eskaera_draft_propagates_pickup_day(self):
        """Test that save_eskaera_draft() propagates pickup_day correctly."""
        order_vals = {
            'partner_id': self.member_partner.id,
            'group_order_id': self.group_order.id,
            'pickup_day': self.group_order.pickup_day,
            'pickup_date': self.group_order.pickup_date,
            'home_delivery': self.group_order.home_delivery,
            'order_line': [],
            'state': 'draft',
        }

        sale_order = self.env['sale.order'].create(order_vals)

        # Verify pickup_day was propagated
        self.assertEqual(sale_order.pickup_day, '3')
        self.assertEqual(sale_order.pickup_day, self.group_order.pickup_day)

    def test_save_eskaera_draft_propagates_pickup_date(self):
        """Test that save_eskaera_draft() propagates pickup_date correctly."""
        order_vals = {
            'partner_id': self.member_partner.id,
            'group_order_id': self.group_order.id,
            'pickup_day': self.group_order.pickup_day,
            'pickup_date': self.group_order.pickup_date,
            'home_delivery': self.group_order.home_delivery,
            'order_line': [],
            'state': 'draft',
        }

        sale_order = self.env['sale.order'].create(order_vals)

        # Verify pickup_date was propagated
        self.assertEqual(sale_order.pickup_date, self.group_order.pickup_date)

    def test_save_eskaera_draft_propagates_home_delivery(self):
        """Test that save_eskaera_draft() propagates home_delivery correctly."""
        # Create a group order with home_delivery=True
        group_order_home = self.env['group.order'].create({
            'name': 'Test Group Order with Home Delivery',
            'group_ids': [(6, 0, [self.group.id])],
            'type': 'regular',
            'start_date': datetime.now().date(),
            'end_date': datetime.now().date() + timedelta(days=7),
            'period': 'weekly',
            'pickup_day': '3',
            'pickup_date': datetime.now().date() + timedelta(days=3),
            'home_delivery': True,  # Enable home delivery
            'cutoff_day': '0',
        })

        group_order_home.action_open()

        # Test with home_delivery=True
        order_vals = {
            'partner_id': self.member_partner.id,
            'group_order_id': group_order_home.id,
            'pickup_day': group_order_home.pickup_day,
            'pickup_date': group_order_home.pickup_date,
            'home_delivery': group_order_home.home_delivery,
            'order_line': [],
            'state': 'draft',
        }

        sale_order = self.env['sale.order'].create(order_vals)

        # Verify home_delivery was propagated
        self.assertTrue(sale_order.home_delivery)
        self.assertEqual(sale_order.home_delivery, group_order_home.home_delivery)

    def test_save_eskaera_draft_order_is_draft_state(self):
        """Test that save_eskaera_draft() creates order in draft state."""
        order_vals = {
            'partner_id': self.member_partner.id,
            'group_order_id': self.group_order.id,
            'pickup_day': self.group_order.pickup_day,
            'pickup_date': self.group_order.pickup_date,
            'home_delivery': self.group_order.home_delivery,
            'order_line': [],
            'state': 'draft',
        }

        sale_order = self.env['sale.order'].create(order_vals)

        # Verify order is in draft state
        self.assertEqual(sale_order.state, 'draft')

    def test_save_eskaera_draft_multiple_fields_together(self):
        """
        Test that all fields are saved together correctly.
        
        This test ensures that the fix didn't break any field and that
        all group_order-related fields are propagated together.
        """
        order_vals = {
            'partner_id': self.member_partner.id,
            'group_order_id': self.group_order.id,
            'pickup_day': self.group_order.pickup_day,
            'pickup_date': self.group_order.pickup_date,
            'home_delivery': self.group_order.home_delivery,
            'order_line': [],
            'state': 'draft',
        }

        sale_order = self.env['sale.order'].create(order_vals)

        # Verify all fields together
        self.assertEqual(sale_order.group_order_id.id, self.group_order.id)
        self.assertEqual(sale_order.pickup_day, self.group_order.pickup_day)
        self.assertEqual(sale_order.pickup_date, self.group_order.pickup_date)
        self.assertEqual(sale_order.home_delivery, self.group_order.home_delivery)
        self.assertEqual(sale_order.state, 'draft')

    def test_save_cart_draft_also_saves_group_order_id(self):
        """
        Test that save_cart_draft() (the working endpoint) also saves group_order_id.
        
        This is a regression test to ensure that save_cart_draft() continues
        to work correctly after the fix to save_eskaera_draft().
        """
        # save_cart_draft should also include group_order_id
        order_vals = {
            'partner_id': self.member_partner.id,
            'group_order_id': self.group_order.id,
            'pickup_day': self.group_order.pickup_day,
            'pickup_date': self.group_order.pickup_date,
            'home_delivery': self.group_order.home_delivery,
            'order_line': [],
            'state': 'draft',
        }

        sale_order = self.env['sale.order'].create(order_vals)

        # Verify all fields
        self.assertEqual(sale_order.group_order_id.id, self.group_order.id)
        self.assertEqual(sale_order.pickup_day, self.group_order.pickup_day)
        self.assertEqual(sale_order.pickup_date, self.group_order.pickup_date)

    def test_save_draft_order_without_group_order_id_still_works(self):
        """
        Test that creating a normal sale.order (without group_order_id) still works.
        
        This ensures backward compatibility - you should still be able to create
        sale orders without associating them to a group order.
        """
        order_vals = {
            'partner_id': self.member_partner.id,
            'order_line': [],
            'state': 'draft',
            # No group_order_id
        }

        sale_order = self.env['sale.order'].create(order_vals)

        # Verify order was created without group_order_id
        self.assertIsNotNone(sale_order.id)
        self.assertFalse(sale_order.group_order_id)

    def test_group_order_id_field_exists_and_is_stored(self):
        """
        Test that group_order_id field exists on sale.order and is stored correctly.
        
        This is a sanity check to ensure the field is properly defined in the model.
        """
        # Verify the field exists in the model
        sale_order_model = self.env['sale.order']
        self.assertIn('group_order_id', sale_order_model._fields)

        # Verify it's a Many2one field
        field = sale_order_model._fields['group_order_id']
        self.assertEqual(field.type, 'many2one')
        self.assertEqual(field.comodel_name, 'group.order')

    def test_different_group_orders_map_to_different_sale_orders(self):
        """
        Test that different group orders create separate sale orders.
        
        This ensures that two users buying from different group orders
        don't accidentally share the same sale.order.
        """
        # Create a second group order
        group_order_2 = self.env['group.order'].create({
            'name': 'Test Group Order 2',
            'group_ids': [(6, 0, [self.group.id])],
            'type': 'regular',
            'start_date': datetime.now().date() + timedelta(days=10),
            'end_date': datetime.now().date() + timedelta(days=17),
            'period': 'weekly',
            'pickup_day': '5',
            'pickup_date': datetime.now().date() + timedelta(days=12),
            'home_delivery': True,
            'cutoff_day': '0',
        })

        group_order_2.action_open()

        # Create order for first group order
        order_vals_1 = {
            'partner_id': self.member_partner.id,
            'group_order_id': self.group_order.id,
            'pickup_day': self.group_order.pickup_day,
            'order_line': [],
            'state': 'draft',
        }

        sale_order_1 = self.env['sale.order'].create(order_vals_1)

        # Create order for second group order
        order_vals_2 = {
            'partner_id': self.member_partner.id,
            'group_order_id': group_order_2.id,
            'pickup_day': group_order_2.pickup_day,
            'order_line': [],
            'state': 'draft',
        }

        sale_order_2 = self.env['sale.order'].create(order_vals_2)

        # Verify they're different orders with different group_order_ids
        self.assertNotEqual(sale_order_1.id, sale_order_2.id)
        self.assertEqual(sale_order_1.group_order_id.id, self.group_order.id)
        self.assertEqual(sale_order_2.group_order_id.id, group_order_2.id)
        self.assertNotEqual(
            sale_order_1.group_order_id.id,
            sale_order_2.group_order_id.id,
        )