from database import get_db
from sqlalchemy.orm import Session
from models import Clinics
from schemas.UpdateSchemas import ClinicUpdate
from schemas.ResponseSchemas import Clinic
from typing import List
from exceptions import ResourceNotFoundException
from enums.enums import ClinicStatus

class ClinicServices:
    def __init__(self):
        self.db: Session = next(get_db())

    def get_clinics(self, limit:int, offset:int) -> List[Clinic]:
        clinics =  self.db.query(Clinics).limit(limit).offset(offset).all()

        clinic_response = [Clinic(**clinic.__dict__.copy()) for clinic in clinics]

        return clinic_response

    def get_latest_clinic_id(self) -> int:
        clinic = self.db.query(Clinics).order_by(Clinics.id.desc()).first()
        return clinic.id if clinic else 0


    def get_clinic_by_id(self, clinic_id: int) -> Clinic:
        clinic = self.db.query(Clinics).filter(Clinics.id == clinic_id).first()

        if clinic is None:
            raise ResourceNotFoundException("Clinic not found")

        clinic_response = Clinic(**clinic.__dict__.copy())
        return clinic_response

    def update_clinic(self, clinic_id: int, clinic_data: ClinicUpdate):
        clinic = self.db.query(Clinics).filter(Clinics.id == clinic_id).first()

        if clinic is None:
            raise ResourceNotFoundException("Clinic not found")

        update_data = clinic_data.model_dump(exclude_unset=True)
        for key, value in update_data.items():
            setattr(clinic, key, value)

        self.db.add(clinic)
        self.db.commit()
        self.db.refresh(clinic)
        return Clinic(**clinic.__dict__.copy())

    def delete_clinic(self, clinic_id: int):
        clinic = self.db.query(Clinics).filter(Clinics.id == clinic_id).first()

        if clinic is None:
            raise ResourceNotFoundException("Clinic not found")

        clinic.soft_delete(self.db)

    def get_clinic_count(self):
        from sqlalchemy import func
        
        # Get total count
        totalClinics = self.db.query(Clinics).count()
        
        # Get counts for specific statuses in a single query
        status_counts = self.db.query(
            Clinics.status, 
            func.count(Clinics.id).label('count')
        ).filter(
            Clinics.status.in_([
                ClinicStatus.ACTIVE,
                ClinicStatus.UNDER_REVIEW,
                ClinicStatus.REJECTED
            ])
        ).group_by(Clinics.status).all()
        
        # Initialize counts with 0
        counts = {
            "totalClinics": totalClinics,
            "totalActiveClinics": 0,
            "totalUnderReviewClinics": 0,
            "totalRejectedClinics": 0
        }
        
        # Map status values to their respective count keys
        status_to_key = {
            ClinicStatus.ACTIVE: "totalActiveClinics",
            ClinicStatus.UNDER_REVIEW: "totalUnderReviewClinics",
            ClinicStatus.REJECTED: "totalRejectedClinics"
        }
        
        # Update counts with actual values from the query
        for status, count in status_counts:
            key = status_to_key.get(status)
            if key:
                counts[key] = count
                
        return counts