import unittest
from app import create_app, db
from app.models import Partners, Categories, Inventory, IssueOrders, IssueOrderItems, ReturnOrders, ReturnOrderItems
from app.utils import calculate_item_price
from datetime import datetime

class TestIntegration(unittest.TestCase):
    def setUp(self):
        self.app = create_app()
        self.app.config['TESTING'] = True
        self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
        self.ctx = self.app.app_context()
        self.ctx.push()
        db.create_all()

        # Создаём тестовые данные
        self.partner = Partners(name='Тестовый партнёр', email='test@test.ru')
        db.session.add(self.partner)
        self.category = Categories(name='Тестовая категория')
        db.session.add(self.category)
        db.session.commit()

        self.inventory = Inventory(
            category_id=self.category.id,
            name='Тестовый товар',
            base_price=1000.0,
            season_type='summer'
        )
        db.session.add(self.inventory)
        db.session.commit()

        self.issue = IssueOrders(
            partner_id=self.partner.id,
            issue_date=datetime.now(),
            notes='Тестовая выдача'
        )
        db.session.add(self.issue)
        db.session.commit()

        self.issue_item = IssueOrderItems(
            issue_order_id=self.issue.id,
            inventory_id=self.inventory.id,
            quantity=3
        )
        db.session.add(self.issue_item)
        db.session.commit()

    def tearDown(self):
        db.session.remove()
        db.drop_all()
        self.ctx.pop()

    def test_create_return_with_calculation(self):
        """Тест создания возврата с расчётом стоимости"""
        # Создаём возврат
        return_date = datetime.now()
        ret = ReturnOrders(
            issue_order_id=self.issue.id,
            return_date=return_date,
            notes='Тестовый возврат'
        )
        db.session.add(ret)
        db.session.commit()

        # Рассчитываем стоимость позиции
        price = calculate_item_price(
            base_price=self.inventory.base_price,
            quantity=self.issue_item.quantity,
            wear_level='medium',
            season_type=self.inventory.season_type,
            return_date=return_date
        )

        ret_item = ReturnOrderItems(
            return_order_id=ret.id,
            inventory_id=self.inventory.id,
            quantity=self.issue_item.quantity,
            wear_level='medium',
            calculated_price=price
        )
        db.session.add(ret_item)
        ret.total_amount = round(price, 2)
        db.session.commit()

        # Проверяем, что возврат создан и сумма рассчитана
        saved_return = ReturnOrders.query.get(ret.id)
        self.assertIsNotNone(saved_return)
        self.assertEqual(saved_return.total_amount, round(price, 2))

        # Проверяем, что выдача теперь закрыта (есть возврат)
        self.assertIsNotNone(self.issue.return_order)

    def test_return_prevents_duplicate(self):
        """Тест запрета повторного возврата для одной выдачи"""
        # Создаём первый возврат
        ret1 = ReturnOrders(issue_order_id=self.issue.id, return_date=datetime.now())
        db.session.add(ret1)
        db.session.commit()

        # Пытаемся создать второй возврат для той же выдачи
        ret2 = ReturnOrders(issue_order_id=self.issue.id, return_date=datetime.now())
        db.session.add(ret2)
        with self.assertRaises(Exception):
            db.session.commit()
        db.session.rollback()

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