import json

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

from app.models import DigitalEmployee, EmployeeStatus


async def create_employee(
    session: AsyncSession,
    tenant_id: str,
    name: str,
    role: str,
    system_prompt: str,
    greeting: str | None = None,
    avatar_url: str | None = None,
    temperature: float = 0.7,
    max_context_messages: int = 20,
    knowledge_base_ids: list[str] | None = None,
) -> DigitalEmployee:
    employee = DigitalEmployee(
        tenant_id=tenant_id,
        name=name,
        role=role,
        system_prompt=system_prompt,
        greeting=greeting,
        avatar_url=avatar_url,
        temperature=temperature,
        max_context_messages=max_context_messages,
        knowledge_base_ids=json.dumps(knowledge_base_ids or []),
    )
    session.add(employee)
    await session.commit()
    await session.refresh(employee)
    return employee


async def get_employee(session: AsyncSession, employee_id: str) -> DigitalEmployee:
    result = await session.execute(
        select(DigitalEmployee).where(
            DigitalEmployee.id == employee_id,
            DigitalEmployee.status != EmployeeStatus.inactive,
        )
    )
    employee = result.scalar_one_or_none()
    if not employee:
        raise HTTPException(status_code=404, detail="Employee not found")
    return employee


async def list_employees(session: AsyncSession, tenant_id: str) -> list[DigitalEmployee]:
    result = await session.execute(
        select(DigitalEmployee).where(
            DigitalEmployee.tenant_id == tenant_id,
            DigitalEmployee.status != EmployeeStatus.inactive,
        )
    )
    return list(result.scalars().all())


async def update_employee(
    session: AsyncSession,
    employee_id: str,
    name: str | None = None,
    role: str | None = None,
    system_prompt: str | None = None,
    greeting: str | None = None,
    avatar_url: str | None = None,
    temperature: float | None = None,
    max_context_messages: int | None = None,
    knowledge_base_ids: list[str] | None = None,
    status: str | None = None,
) -> DigitalEmployee:
    employee = await get_employee(session, employee_id)

    if name is not None:
        employee.name = name
    if role is not None:
        employee.role = role
    if system_prompt is not None:
        employee.system_prompt = system_prompt
    if greeting is not None:
        employee.greeting = greeting
    if avatar_url is not None:
        employee.avatar_url = avatar_url
    if temperature is not None:
        employee.temperature = temperature
    if max_context_messages is not None:
        employee.max_context_messages = max_context_messages
    if knowledge_base_ids is not None:
        employee.knowledge_base_ids = json.dumps(knowledge_base_ids)
    if status is not None:
        employee.status = EmployeeStatus(status)

    await session.commit()
    await session.refresh(employee)
    return employee


async def delete_employee(session: AsyncSession, employee_id: str) -> None:
    employee = await get_employee(session, employee_id)
    employee.status = EmployeeStatus.inactive
    await session.commit()