# reports-app/backend/tests/test_services_real.py
"""
Tests for backend services with REAL Oracle database.
Requires SSH tunnel and valid Oracle credentials.
"""
import pytest
from decimal import Decimal


@pytest.mark.oracle
@pytest.mark.asyncio
class TestDashboardServiceReal:
    """Tests for DashboardService with real Oracle"""

    async def test_get_schema_returns_valid_schema(self, oracle_available, test_company_id, cache_initialized):
        """Verify _get_schema returns correct schema"""
        from app.services.dashboard_service import DashboardService

        schema = await DashboardService._get_schema(test_company_id)

        assert schema is not None
        assert isinstance(schema, str)
        assert len(schema) > 0
        # Schema should be format OWNER_XXXX or uppercase
        assert "_" in schema or schema.isupper()

    async def test_get_complete_summary_returns_valid_data(self, oracle_available, test_company_id, auth_token, cache_initialized):
        """Verify dashboard summary returns valid structure"""
        from app.services.dashboard_service import DashboardService

        result = await DashboardService.get_complete_summary(
            company=str(test_company_id),
            username="test_user"
        )

        # Verify result is not None
        assert result is not None

        # Check if it's a Pydantic model or dict
        if hasattr(result, 'dict'):
            result_dict = result.dict()
        else:
            result_dict = result

        # Verify some expected fields exist
        assert isinstance(result_dict, dict)

    async def test_dashboard_caching_works(self, oracle_available, test_company_id, auth_token, cache_initialized):
        """Verify cache stores and retrieves results"""
        from app.services.dashboard_service import DashboardService
        import time

        # First call - may be cache miss
        start1 = time.time()
        result1 = await DashboardService.get_complete_summary(
            company=str(test_company_id),
            username="test_user"
        )
        time1 = time.time() - start1

        # Second call - should be cache hit (faster)
        start2 = time.time()
        result2 = await DashboardService.get_complete_summary(
            company=str(test_company_id),
            username="test_user"
        )
        time2 = time.time() - start2

        # Both should return valid results
        assert result1 is not None
        assert result2 is not None

        print(f"First request: {time1:.3f}s, Second request: {time2:.3f}s")


@pytest.mark.oracle
@pytest.mark.asyncio
class TestInvoiceServiceReal:
    """Tests for InvoiceService with real Oracle"""

    async def test_get_invoices_returns_valid_response(self, oracle_available, test_company_id, cache_initialized):
        """Verify get_invoices returns valid structure"""
        from app.services.invoice_service import InvoiceService
        from app.models.invoice import InvoiceFilter

        filter_params = InvoiceFilter(
            company=str(test_company_id),
            partner_type="CLIENTI",
            date_from=None,
            date_to=None,
            partner_name=None,
            cont=None,
            only_unpaid=True,
            min_amount=None,
            max_amount=None,
            page=1,
            page_size=10
        )

        result = await InvoiceService.get_invoices(filter_params, "test_user")

        assert result is not None
        # Result should be InvoiceListResponse with items and pagination
        if hasattr(result, 'items'):
            assert isinstance(result.items, list)
        elif isinstance(result, dict):
            assert 'items' in result or 'data' in result

    async def test_invoices_pagination_works(self, oracle_available, test_company_id, cache_initialized):
        """Verify pagination returns different results"""
        from app.services.invoice_service import InvoiceService
        from app.models.invoice import InvoiceFilter

        # First page
        filter1 = InvoiceFilter(
            company=str(test_company_id),
            partner_type="CLIENTI",
            date_from=None,
            date_to=None,
            partner_name=None,
            cont=None,
            only_unpaid=False,  # Get all invoices for better pagination test
            min_amount=None,
            max_amount=None,
            page=1,
            page_size=5
        )
        result1 = await InvoiceService.get_invoices(filter1, "test_user")

        # Second page
        filter2 = InvoiceFilter(
            company=str(test_company_id),
            partner_type="CLIENTI",
            date_from=None,
            date_to=None,
            partner_name=None,
            cont=None,
            only_unpaid=False,
            min_amount=None,
            max_amount=None,
            page=2,
            page_size=5
        )
        result2 = await InvoiceService.get_invoices(filter2, "test_user")

        # Both should be valid
        assert result1 is not None
        assert result2 is not None

    async def test_invoices_filter_by_partner_type(self, oracle_available, test_company_id, cache_initialized):
        """Verify filtering by partner type works"""
        from app.services.invoice_service import InvoiceService
        from app.models.invoice import InvoiceFilter

        # Test CLIENTI
        filter_clienti = InvoiceFilter(
            company=str(test_company_id),
            partner_type="CLIENTI",
            date_from=None,
            date_to=None,
            partner_name=None,
            cont=None,
            only_unpaid=True,
            min_amount=None,
            max_amount=None,
            page=1,
            page_size=10
        )
        result_clienti = await InvoiceService.get_invoices(filter_clienti, "test_user")

        # Test FURNIZORI
        filter_furnizori = InvoiceFilter(
            company=str(test_company_id),
            partner_type="FURNIZORI",
            date_from=None,
            date_to=None,
            partner_name=None,
            cont=None,
            only_unpaid=True,
            min_amount=None,
            max_amount=None,
            page=1,
            page_size=10
        )
        result_furnizori = await InvoiceService.get_invoices(filter_furnizori, "test_user")

        # Both should return valid results
        assert result_clienti is not None
        assert result_furnizori is not None


@pytest.mark.oracle
@pytest.mark.asyncio
class TestTreasuryServiceReal:
    """Tests for TreasuryService with real Oracle"""

    async def test_get_bank_cash_register_returns_data(self, oracle_available, test_company_id, cache_initialized):
        """Verify treasury service returns data"""
        from app.services.treasury_service import TreasuryService
        from app.models.treasury import RegisterFilter

        filter_params = RegisterFilter(
            company=str(test_company_id),
            page=1,
            page_size=10
        )

        result = await TreasuryService.get_bank_cash_register(filter_params, "test_user")

        assert result is not None

    async def test_treasury_with_date_filter(self, oracle_available, test_company_id, cache_initialized):
        """Verify treasury service works with date filters"""
        from app.services.treasury_service import TreasuryService
        from app.models.treasury import RegisterFilter
        from datetime import date, timedelta

        # Last 30 days
        date_to = date.today()
        date_from = date_to - timedelta(days=30)

        filter_params = RegisterFilter(
            company=str(test_company_id),
            date_from=date_from,
            date_to=date_to,
            page=1,
            page_size=50
        )

        result = await TreasuryService.get_bank_cash_register(filter_params, "test_user")

        assert result is not None


@pytest.mark.oracle
@pytest.mark.asyncio
class TestTrialBalanceServiceReal:
    """Tests for TrialBalanceService with real Oracle"""

    async def test_get_trial_balance_returns_data(self, oracle_available, test_company_id, cache_initialized):
        """Verify trial balance service returns data"""
        from app.services.trial_balance_service import TrialBalanceService
        from datetime import date

        # Use current month and year
        current_date = date.today()

        result = await TrialBalanceService.get_trial_balance(
            company_id=int(test_company_id),
            luna=current_date.month,
            an=current_date.year,
            cont_filter=None,
            denumire_filter=None,
            sort_by="CONT",
            sort_order="asc",
            page=1,
            page_size=50,
            username="test_user"
        )

        assert result is not None