"""世界模型运行时数据访问（api-spec §12，按人物隔离）。"""

from sqlalchemy import func, select
from sqlalchemy.ext.asyncio import AsyncSession

from app.models.world import CharacterWorldEntity, WorldRelation


async def list_entities(
    session: AsyncSession,
    character_id: str,
    *,
    entity_type: str | None = None,
    status: str | None = None,
    page: int = 1,
    page_size: int = 20,
) -> tuple[list[CharacterWorldEntity], int]:
    conditions = [CharacterWorldEntity.character_id == character_id]
    if entity_type is not None:
        conditions.append(CharacterWorldEntity.type == entity_type)
    if status is not None:
        conditions.append(CharacterWorldEntity.status == status)
    total = (
        await session.execute(
            select(func.count()).select_from(CharacterWorldEntity).where(*conditions)
        )
    ).scalar_one()
    items_result = await session.execute(
        select(CharacterWorldEntity)
        .where(*conditions)
        .order_by(CharacterWorldEntity.updated_at.desc())
        .offset(max(page - 1, 0) * page_size)
        .limit(page_size)
    )
    return list(items_result.scalars().all()), int(total or 0)


async def get_entity(session: AsyncSession, entity_id: str) -> CharacterWorldEntity | None:
    return await session.get(CharacterWorldEntity, entity_id)


async def add_entity(session: AsyncSession, entity: CharacterWorldEntity) -> CharacterWorldEntity:
    session.add(entity)
    await session.flush()
    return entity


async def list_relations(
    session: AsyncSession,
    character_id: str,
    *,
    page: int = 1,
    page_size: int = 20,
) -> tuple[list[WorldRelation], int]:
    conditions = [WorldRelation.character_id == character_id]
    total = (
        await session.execute(select(func.count()).select_from(WorldRelation).where(*conditions))
    ).scalar_one()
    items_result = await session.execute(
        select(WorldRelation)
        .where(*conditions)
        .order_by(WorldRelation.updated_at.desc())
        .offset(max(page - 1, 0) * page_size)
        .limit(page_size)
    )
    return list(items_result.scalars().all()), int(total or 0)


async def get_relation(session: AsyncSession, relation_id: str) -> WorldRelation | None:
    return await session.get(WorldRelation, relation_id)


async def add_relation(session: AsyncSession, relation: WorldRelation) -> WorldRelation:
    session.add(relation)
    await session.flush()
    return relation


async def delete_relation(session: AsyncSession, relation_id: str) -> None:
    """删除世界关系。"""
    relation = await session.get(WorldRelation, relation_id)
    if relation:
        await session.delete(relation)
        await session.flush()


async def list_all_entities(session: AsyncSession, character_id: str) -> list[CharacterWorldEntity]:
    """获取人物的所有世界实体（无分页）。"""
    result = await session.execute(
        select(CharacterWorldEntity)
        .where(CharacterWorldEntity.character_id == character_id)
        .order_by(CharacterWorldEntity.updated_at.desc())
    )
    return list(result.scalars().all())


async def list_all_relations(session: AsyncSession, character_id: str) -> list[WorldRelation]:
    """获取人物的所有关系（无分页）。"""
    result = await session.execute(
        select(WorldRelation)
        .where(WorldRelation.character_id == character_id)
        .order_by(WorldRelation.updated_at.desc())
    )
    return list(result.scalars().all())