from fastapi import HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import selectinload
from sqlmodel import select

from job.candidate.models import Notes
from job.history.enums import HistoryEvent
from job.history.views import HistoryRecorder
from job.notes.serializers import serialize_note


class Note:
    def __init__(self,session:AsyncSession):
        self.session=session

    async def _load(self,record_id):
        uid=Notes._as_uuid(record_id)
        if uid is None:
            return None
        result=await self.session.execute(
            select(Notes).options(selectinload(Notes.author)).where(Notes.id==uid)
        )
        return result.scalars().first()

    async def get_note(self,note_id=None,user_id=None):
        if note_id:
            row=await self._load(note_id)
            if not row:
                raise HTTPException(status_code=404,detail="Note not found")
            return serialize_note(row)
        if not user_id:
            raise HTTPException(status_code=400,detail="note_id or user_id is required")
        uid=Notes._as_uuid(user_id)
        if uid is None:
            raise HTTPException(status_code=400,detail="Invalid user_id")
        result=await self.session.execute(
            select(Notes)
            .options(selectinload(Notes.author))
            .where(Notes.user_id==uid)
            .order_by(Notes.created_at.desc())
        )
        return [serialize_note(r) for r in result.scalars().all()]

    async def create_note(self,payload,current_user):
        fields={
            "note":payload.get("note") or "",
            "user_id":payload.get("user_id"),
            "created_by":current_user.get("id") if isinstance(current_user,dict) else None,
        }
        if not fields["user_id"]:
            raise HTTPException(status_code=400,detail="user_id is required")
        row=await Notes.insert_note(self.session,fields)
        await HistoryRecorder(self.session).record(
            HistoryEvent.NOTE_CREATED.value,
            current_user=current_user,user_id=row.user_id,
            entity_type="note",entity_id=row.id,
            to_value=(row.note or "")[:120],commit=True,
        )
        row=await self._load(row.id)
        return serialize_note(row)

    async def update_note(self,note_id,payload,current_user=None):
        fields={k:v for k,v in payload.items() if v is not None and k in ("note",)}
        if not fields:
            raise HTTPException(status_code=400,detail="No fields to update")
        before=await self._load(note_id)
        if not before:
            raise HTTPException(status_code=404,detail="Note not found")
        old_note=before.note or ""
        row=await Notes.update_note(self.session,note_id,fields)
        if not row:
            raise HTTPException(status_code=404,detail="Note not found")
        new_note=row.note or ""
        await HistoryRecorder(self.session).record(
            HistoryEvent.NOTE_UPDATED.value,
            current_user=current_user,user_id=row.user_id,
            entity_type="note",entity_id=row.id,
            from_value=old_note[:120],to_value=new_note[:120],commit=True,
        )
        row=await self._load(row.id)
        return serialize_note(row)