from fastapi import HTTPException
from sqlalchemy.ext.asyncio import AsyncSession

from job.candidate.models import Notes
from job.candidate.views import assert_manager_candidate_access
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):
        return await Notes.get_note_by_id(self.session,record_id)

    async def get_note(self,note_id=None,user_id=None,current_user=None):
        if note_id:
            row=await self._load(note_id)
            if not row:
                raise HTTPException(status_code=404,detail="Note not found")
            await assert_manager_candidate_access(
                self.session,current_user,user_id=row.user_id,
            )
            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")
        await assert_manager_candidate_access(self.session,current_user,user_id=uid)
        rows=await Notes.get_notes_by_user(self.session,uid)
        return [serialize_note(r) for r in rows]

    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")
        await assert_manager_candidate_access(
            self.session,current_user,user_id=fields["user_id"],
        )
        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")
        await assert_manager_candidate_access(
            self.session,current_user,user_id=before.user_id,
        )
        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)