from sqlalchemy import insert, select, update, delete
from fastapi import HTTPException
from models.db import shelters_table
from models.schemas import Shelter, UpdateShelter
from sqlalchemy.ext.asyncio import AsyncSession

from services.auth_service import AuthService


class ShelterService:

    permissions = ["admin", "moderator"]

    @staticmethod
    async def create_shelter(shelter: Shelter, db, token):
        user = await AuthService.get_current_user(token, db)
        query = insert(shelters_table).values(
            label=shelter.label,
            description=shelter.description,
            status=shelter.status,
            contact_person=shelter.contact_person,
            gps_coordinates=shelter.gps_coordinates,
            added_by=user["id"],
        )
        try:
            result = await db.execute(query)
            await db.commit()
            shelter_id = result.inserted_primary_key[0]
            return {"id": shelter_id, **shelter.model_dump()}
        except Exception as e:
            await db.rollback()
            raise HTTPException(status_code=500, detail=f"Could not create shelter: {str(e)}")

    @staticmethod
    async def get_shelter(shelter_id: int, db):
        query = select(shelters_table).where(shelters_table.c.id == shelter_id)
        result = await db.execute(query)
        shelter = result.mappings().fetchone()
        if not shelter:
            raise HTTPException(status_code=404, detail="Shelter not found")
        return dict(shelter)

    @staticmethod
    async def get_all_shelters(db):
        query = select(shelters_table)
        result = await db.execute(query)
        shelters = result.mappings().fetchall()
        return [dict(shelter) for shelter in shelters]

    @staticmethod
    async def update_shelter(shelter_id: int, shelter: UpdateShelter, db, token):
        user = await AuthService.get_current_user(token, db)
        update_values = shelter.model_dump(exclude_unset=True)
        if not update_values:
            raise HTTPException(status_code=400, detail="No fields provided for update")
        
        query = (
            update(shelters_table)
            .where(shelters_table.c.id == shelter_id)
            .values(**update_values,
                    added_by=user["id"])
        )
        try:
            result = await db.execute(query)
            if result.rowcount == 0:
                raise HTTPException(status_code=404, detail="Shelter not found")
            await db.commit()
            return {"message": "Shelter updated successfully"}
        except Exception as e:
            await db.rollback()
            raise HTTPException(status_code=500, detail=f"Could not update shelter: {str(e)}")

    @staticmethod
    async def delete_shelter(shelter_id: int, db, token):
        #await AuthService.check_permissions(token, db, ShelterService.permissions)
        await AuthService.admin_required(token, db)
        query = delete(shelters_table).where(shelters_table.c.id == shelter_id)
        try:
            result = await db.execute(query)
            if result.rowcount == 0:
                raise HTTPException(status_code=404, detail="Shelter not found")
            await db.commit()
            return {"message": "Shelter deleted successfully"}
        except Exception as e:
            await db.rollback()
            raise HTTPException(status_code=500, detail=f"Could not delete shelter: {str(e)}")