"""
Sales Service - Tenant Data Deletion
Handles deletion of all sales-related data for a tenant
"""
from typing import Dict
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, delete, func
import structlog

from shared.services.tenant_deletion import BaseTenantDataDeletionService, TenantDataDeletionResult
from app.models.sales import SalesData

logger = structlog.get_logger()


class SalesTenantDeletionService(BaseTenantDataDeletionService):
    """Service for deleting all sales-related data for a tenant"""

    def __init__(self, db_session: AsyncSession):
        super().__init__("sales-service")
        self.db = db_session

    async def get_tenant_data_preview(self, tenant_id: str) -> Dict[str, int]:
        """Get counts of what would be deleted"""

        try:
            preview = {}

            # Count sales data
            sales_count = await self.db.scalar(
                select(func.count(SalesData.id)).where(SalesData.tenant_id == tenant_id)
            )
            preview["sales_records"] = sales_count or 0

            return preview

        except Exception as e:
            logger.error("Error getting deletion preview",
                        tenant_id=tenant_id,
                        error=str(e))
            return {}

    async def delete_tenant_data(self, tenant_id: str) -> TenantDataDeletionResult:
        """Delete all data for a tenant"""

        result = TenantDataDeletionResult(tenant_id, self.service_name)

        try:
            # Delete all sales data for the tenant
            try:
                sales_delete = await self.db.execute(
                    delete(SalesData).where(SalesData.tenant_id == tenant_id)
                )
                deleted_sales = sales_delete.rowcount
                result.add_deleted_items("sales_records", deleted_sales)

                logger.info("Deleted sales data for tenant",
                           tenant_id=tenant_id,
                           count=deleted_sales)

            except Exception as e:
                logger.error("Error deleting sales data",
                           tenant_id=tenant_id,
                           error=str(e))
                result.add_error(f"Sales data deletion: {str(e)}")

            # Commit all deletions
            await self.db.commit()

            logger.info("Tenant data deletion completed",
                       tenant_id=tenant_id,
                       deleted_counts=result.deleted_counts)

        except Exception as e:
            logger.error("Fatal error during tenant data deletion",
                        tenant_id=tenant_id,
                        error=str(e))
            await self.db.rollback()
            result.add_error(f"Fatal error: {str(e)}")

        return result
