import unittest
from unittest.mock import patch

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

from app.db import mock_seed as mock_seed_module
from app.db.mock_database import MockBase
from app.db.mock_models import Customer, Order, Vehicle
from app.services.orchestration.technical_normalizer import is_valid_cpf


class MockSeedDataTests(unittest.TestCase):
    def _build_session_local(self):
        engine = create_engine("sqlite:///:memory:")
        SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
        MockBase.metadata.create_all(bind=engine)
        self.addCleanup(engine.dispose)
        return SessionLocal

    def test_seed_mock_data_populates_target_volume_with_affordable_inventory(self):
        SessionLocal = self._build_session_local()

        with patch.object(mock_seed_module, "SessionMockLocal", SessionLocal), patch.object(
            mock_seed_module.settings,
            "mock_seed_enabled",
            True,
        ):
            mock_seed_module.seed_mock_data()

        db = SessionLocal()
        try:
            self.assertEqual(db.query(Vehicle).count(), mock_seed_module.TARGET_VEHICLE_COUNT)
            self.assertEqual(db.query(Customer).count(), mock_seed_module.TARGET_CUSTOMER_COUNT)
            self.assertEqual(db.query(Order).count(), mock_seed_module.TARGET_ORDER_COUNT)
            self.assertGreaterEqual(
                db.query(Vehicle).filter(Vehicle.preco <= 70000).count(),
                50,
            )
            sample_cpfs = [row.cpf for row in db.query(Customer).order_by(Customer.id).limit(5).all()]
            self.assertTrue(sample_cpfs)
            self.assertTrue(all(is_valid_cpf(cpf) for cpf in sample_cpfs))
        finally:
            db.close()

    def test_seed_mock_data_tops_up_existing_partial_database(self):
        SessionLocal = self._build_session_local()
        db = SessionLocal()
        try:
            db.add_all(
                [
                    Vehicle(modelo="Base Hatch 2020", categoria="hatch", preco=45990.0),
                    Vehicle(modelo="Base Sedan 2021", categoria="sedan", preco=58990.0),
                    Customer(
                        cpf=mock_seed_module._cpf_from_index(0),
                        nome="Cliente Base 1",
                        score=650,
                        limite_credito=75000.0,
                        possui_restricao=False,
                    ),
                    Order(
                        numero_pedido="PED-LEGADO-00001",
                        cpf=mock_seed_module._cpf_from_index(0),
                        status="Ativo",
                    ),
                ]
            )
            db.commit()
        finally:
            db.close()

        with patch.object(mock_seed_module, "SessionMockLocal", SessionLocal), patch.object(
            mock_seed_module.settings,
            "mock_seed_enabled",
            True,
        ):
            mock_seed_module.seed_mock_data()
            mock_seed_module.seed_mock_data()

        db = SessionLocal()
        try:
            self.assertEqual(db.query(Vehicle).count(), mock_seed_module.TARGET_VEHICLE_COUNT)
            self.assertEqual(db.query(Customer).count(), mock_seed_module.TARGET_CUSTOMER_COUNT)
            self.assertEqual(db.query(Order).count(), mock_seed_module.TARGET_ORDER_COUNT)
            self.assertEqual(db.query(Order).filter(Order.numero_pedido == "PED-LEGADO-00001").count(), 1)
            self.assertEqual(db.query(Vehicle).filter(Vehicle.modelo == "Base Hatch 2020").count(), 1)
        finally:
            db.close()


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