import aiosqlite
from database.db import DB_PATH


async def get_or_create_session(session_id: str, persona_id: str = "default") -> dict:
    async with aiosqlite.connect(DB_PATH) as db:
        db.row_factory = aiosqlite.Row
        async with db.execute(
            "SELECT * FROM sessions WHERE session_id = ?", (session_id,)
        ) as cursor:
            row = await cursor.fetchone()

        if row:
            return dict(row)

        await db.execute(
            "INSERT INTO sessions (session_id, persona_id) VALUES (?, ?)",
            (session_id, persona_id),
        )
        await db.commit()

        async with db.execute(
            "SELECT * FROM sessions WHERE session_id = ?", (session_id,)
        ) as cursor:
            row = await cursor.fetchone()
        return dict(row)


async def get_all_sessions() -> list:
    async with aiosqlite.connect(DB_PATH) as db:
        db.row_factory = aiosqlite.Row
        async with db.execute(
            "SELECT * FROM sessions ORDER BY updated_at DESC"
        ) as cursor:
            rows = await cursor.fetchall()
    return [dict(r) for r in rows]


async def get_session(session_id: str) -> dict | None:
    async with aiosqlite.connect(DB_PATH) as db:
        db.row_factory = aiosqlite.Row
        async with db.execute(
            "SELECT * FROM sessions WHERE session_id = ?",
            (session_id,),
        ) as cursor:
            row = await cursor.fetchone()
    return dict(row) if row else None


async def update_session_title(session_id: str, title: str):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "UPDATE sessions SET title = ?, updated_at = CURRENT_TIMESTAMP WHERE session_id = ?",
            (title, session_id),
        )
        await db.commit()


async def update_session_persona(session_id: str, persona_id: str):
    async with aiosqlite.connect(DB_PATH) as db:
        db.row_factory = aiosqlite.Row
        async with db.execute(
            "SELECT persona_id FROM sessions WHERE session_id = ?",
            (session_id,),
        ) as cur:
            row = await cur.fetchone()
        prev = row["persona_id"] if row else None

        await db.execute(
            "UPDATE sessions SET persona_id = ?, updated_at = CURRENT_TIMESTAMP WHERE session_id = ?",
            (persona_id, session_id),
        )

        # If persona changed, reset RPG state bound to the persona/arc.
        if prev is not None and prev != persona_id:
            await db.execute(
                """UPDATE sessions
                   SET facts_json = '[]',
                       global_plot = '',
                       status_quo = '',
                       plot_arc_json = '{}'
                   WHERE session_id = ?""",
                (session_id,),
            )
            await db.execute(
                "DELETE FROM action_resolutions WHERE session_id = ?",
                (session_id,),
            )
        await db.commit()


async def update_session_rpg(session_id: str, rpg_enabled: bool):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "UPDATE sessions SET rpg_enabled = ?, updated_at = CURRENT_TIMESTAMP WHERE session_id = ?",
            (1 if rpg_enabled else 0, session_id),
        )
        await db.commit()


async def update_session_facts(session_id: str, facts_json: str):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "UPDATE sessions SET facts_json = ?, updated_at = CURRENT_TIMESTAMP WHERE session_id = ?",
            (facts_json, session_id),
        )
        await db.commit()


async def update_session_global_plot(session_id: str, global_plot: str):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "UPDATE sessions SET global_plot = ?, updated_at = CURRENT_TIMESTAMP WHERE session_id = ?",
            (global_plot, session_id),
        )
        await db.commit()


async def update_session_status_quo(session_id: str, status_quo: str):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "UPDATE sessions SET status_quo = ?, updated_at = CURRENT_TIMESTAMP WHERE session_id = ?",
            (status_quo, session_id),
        )
        await db.commit()


async def update_session_plot_arc(session_id: str, plot_arc_json: str):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "UPDATE sessions SET plot_arc_json = ?, updated_at = CURRENT_TIMESTAMP WHERE session_id = ?",
            (plot_arc_json, session_id),
        )
        await db.commit()


async def add_action_resolution(
    session_id: str,
    intent_text: str,
    roll: int,
    outcome: str,
    resolution_text: str,
    message_id: int | None = None,
):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            """INSERT INTO action_resolutions
               (session_id, message_id, intent_text, roll, outcome, resolution_text)
               VALUES (?, ?, ?, ?, ?, ?)""",
            (session_id, message_id, intent_text, roll, outcome, resolution_text),
        )
        await db.commit()


async def get_last_action_resolution(session_id: str) -> dict | None:
    async with aiosqlite.connect(DB_PATH) as db:
        db.row_factory = aiosqlite.Row
        async with db.execute(
            """SELECT * FROM action_resolutions
               WHERE session_id = ?
               ORDER BY id DESC LIMIT 1""",
            (session_id,),
        ) as cur:
            row = await cur.fetchone()
    return dict(row) if row else None


async def delete_session(session_id: str):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("DELETE FROM messages WHERE session_id = ?", (session_id,))
        await db.execute("DELETE FROM sessions WHERE session_id = ?", (session_id,))
        await db.commit()


async def get_history(session_id: str) -> list:
    async with aiosqlite.connect(DB_PATH) as db:
        db.row_factory = aiosqlite.Row
        async with db.execute(
            """SELECT role, content, image_prompt, image_path
               FROM messages WHERE session_id = ? ORDER BY id""",
            (session_id,),
        ) as cursor:
            rows = await cursor.fetchall()
    return [
        {
            "role": r["role"],
            "content": r["content"],
            "image_prompt": r["image_prompt"],
            "image_path": r["image_path"],
        }
        for r in rows
    ]


async def add_message(
    session_id: str,
    role: str,
    content: str,
    image_prompt: str | None = None,
    image_path: str | None = None,
):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            """INSERT INTO messages (session_id, role, content, image_prompt, image_path)
               VALUES (?, ?, ?, ?, ?)""",
            (session_id, role, content, image_prompt, image_path),
        )
        await db.execute(
            "UPDATE sessions SET updated_at = CURRENT_TIMESTAMP WHERE session_id = ?",
            (session_id,),
        )
        await db.commit()


async def update_message_image(message_id: int, image_path: str):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "UPDATE messages SET image_path = ? WHERE id = ?",
            (image_path, message_id),
        )
        await db.commit()


async def get_last_assistant_message_id(session_id: str) -> int | None:
    async with aiosqlite.connect(DB_PATH) as db:
        db.row_factory = aiosqlite.Row
        async with db.execute(
            """SELECT id FROM messages
               WHERE session_id = ? AND role = 'assistant'
               ORDER BY id DESC LIMIT 1""",
            (session_id,),
        ) as cursor:
            row = await cursor.fetchone()
    return row["id"] if row else None


async def clear_history(session_id: str):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "DELETE FROM messages WHERE session_id = ?", (session_id,)
        )
        await db.commit()


async def get_message_count(session_id: str) -> int:
    async with aiosqlite.connect(DB_PATH) as db:
        db.row_factory = aiosqlite.Row
        async with db.execute(
            "SELECT COUNT(*) as cnt FROM messages WHERE session_id = ? AND role != 'system'",
            (session_id,),
        ) as cursor:
            row = await cursor.fetchone()
    return row["cnt"]