# -*- coding: utf-8 -*-

from odoo.tests.common import TransactionCase
from odoo.exceptions import UserError, ValidationError


class TestModelName(TransactionCase):
    """Test cases for model.name functionality."""

    def setUp(self):
        """Set up test data."""
        super().setUp()

        self.Model = self.env['model.name']

        # Use existing records when possible
        self.partner = self.env['res.partner'].search([], limit=1)
        if not self.partner:
            self.skipTest("No partner available for testing")

        # Or create with .sudo()
        self.test_partner = self.env['res.partner'].sudo().create({
            'name': 'Test Partner',
            'is_company': True,
        })

    def test_01_create_record(self):
        """Test creating a new record with valid data."""
        record = self.Model.create({
            'name': 'Test Record',
            'partner_id': self.partner.id,
            # Add other required fields
        })

        self.assertTrue(record)
        self.assertEqual(record.name, 'Test Record')
        self.assertEqual(record.state, 'draft')  # Adjust as needed

    def test_02_update_record(self):
        """Test updating an existing record."""
        record = self.Model.create({
            'name': 'Test Record',
            'partner_id': self.partner.id,
        })

        # Update record
        record.write({
            'name': 'Updated Record',
        })

        self.assertEqual(record.name, 'Updated Record')

    def test_03_search_records(self):
        """Test searching for records."""
        # Create test records
        self.Model.create({
            'name': 'Record A',
            'partner_id': self.partner.id,
        })
        self.Model.create({
            'name': 'Record B',
            'partner_id': self.partner.id,
        })

        # Search for records
        records = self.Model.search([('partner_id', '=', self.partner.id)])

        self.assertGreaterEqual(len(records), 2)

    def test_04_computed_field(self):
        """Test computed field calculation."""
        record = self.Model.create({
            'name': 'Test Record',
            'partner_id': self.partner.id,
            'quantity': 10,
            'unit_price': 5.0,
        })

        # Test computed total
        self.assertEqual(record.total_amount, 50.0)

        # Update dependency and verify recomputation
        record.write({'quantity': 20})
        self.assertEqual(record.total_amount, 100.0)

    def test_05_onchange_method(self):
        """Test onchange method behavior."""
        record = self.Model.new({
            'name': 'Test Record',
        })

        # Trigger onchange
        record.partner_id = self.partner
        record._onchange_partner_id()

        # Verify onchange updated fields
        # self.assertEqual(record.some_field, expected_value)

    def test_06_constraint_validation(self):
        """Test constraint validation."""
        record = self.Model.create({
            'name': 'Test Record',
            'partner_id': self.partner.id,
        })

        # Test that invalid value raises ValidationError
        with self.assertRaises(ValidationError) as context:
            record.write({'invalid_field': 'invalid_value'})

        # Verify error message
        self.assertIn('expected error message', str(context.exception))

    def test_07_state_transition(self):
        """Test state transition workflow."""
        record = self.Model.create({
            'name': 'Test Record',
            'partner_id': self.partner.id,
        })

        # Initially in draft state
        self.assertEqual(record.state, 'draft')

        # Confirm record
        record.action_confirm()
        self.assertEqual(record.state, 'confirmed')

        # Test invalid transition
        with self.assertRaises(UserError) as context:
            record.action_confirm()  # Already confirmed

        self.assertIn('Cannot confirm', str(context.exception))

    def test_08_delete_record(self):
        """Test deleting a record (if applicable)."""
        record = self.Model.create({
            'name': 'Test Record',
            'partner_id': self.partner.id,
        })

        record_id = record.id

        # Delete record
        record.unlink()

        # Verify record no longer exists
        self.assertFalse(self.Model.browse(record_id).exists())