"""
POS Configuration Repository using Repository Pattern
"""

from typing import List, Optional, Dict, Any
from uuid import UUID
from sqlalchemy import select, and_, or_
from sqlalchemy.ext.asyncio import AsyncSession
import structlog

from app.models.pos_config import POSConfiguration
from shared.database.repository import BaseRepository

logger = structlog.get_logger()


class POSConfigurationRepository(BaseRepository[POSConfiguration, dict, dict]):
    """Repository for POS configuration operations"""

    def __init__(self, session: AsyncSession):
        super().__init__(POSConfiguration, session)

    async def get_configurations_by_tenant(
        self,
        tenant_id: UUID,
        pos_system: Optional[str] = None,
        is_active: Optional[bool] = None,
        skip: int = 0,
        limit: int = 100
    ) -> List[POSConfiguration]:
        """Get POS configurations for a specific tenant with optional filters"""
        try:
            query = select(self.model).where(self.model.tenant_id == tenant_id)

            # Apply filters
            conditions = []
            if pos_system:
                conditions.append(self.model.pos_system == pos_system)
            if is_active is not None:
                conditions.append(self.model.is_active == is_active)

            if conditions:
                query = query.where(and_(*conditions))

            query = query.offset(skip).limit(limit).order_by(self.model.created_at.desc())

            result = await self.session.execute(query)
            return result.scalars().all()

        except Exception as e:
            logger.error("Failed to get configurations by tenant", error=str(e), tenant_id=tenant_id)
            raise

    async def count_configurations_by_tenant(
        self,
        tenant_id: UUID,
        pos_system: Optional[str] = None,
        is_active: Optional[bool] = None
    ) -> int:
        """Count POS configurations for a specific tenant with optional filters"""
        try:
            from sqlalchemy import func

            query = select(func.count(self.model.id)).where(self.model.tenant_id == tenant_id)

            # Apply filters
            conditions = []
            if pos_system:
                conditions.append(self.model.pos_system == pos_system)
            if is_active is not None:
                conditions.append(self.model.is_active == is_active)

            if conditions:
                query = query.where(and_(*conditions))

            result = await self.session.execute(query)
            count = result.scalar() or 0
            return count

        except Exception as e:
            logger.error("Failed to count configurations by tenant", error=str(e), tenant_id=tenant_id)
            raise