import json

import aiosqlite
from database.db import DB_PATH


async def get_or_create_session(session_id: str, persona_id: str | None = None) -> dict:
    """Existing sessions keep their persona_id; persona_id applies only on INSERT."""
    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)

        pid = (persona_id or "default").strip() or "default"
        await db.execute(
            "INSERT INTO sessions (session_id, persona_id) VALUES (?, ?)",
            (session_id, pid),
        )
        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 prev is not None and prev != persona_id:
            await _reset_persona_bound_state(db, session_id)
        await db.commit()


async def _reset_persona_bound_state(db: aiosqlite.Connection, session_id: str) -> None:
    from services.rpg_state import DEFAULT_NARRATIVE_STATS

    stats_default = json.dumps(DEFAULT_NARRATIVE_STATS, ensure_ascii=False)
    await db.execute(
        """UPDATE sessions
           SET facts_json = '[]',
               global_plot = '',
               status_quo = '',
               plot_arc_json = '{}',
               outfit_json = '[]',
               affinity = 0,
               scene_json = '{}',
               narrative_stats_json = ?
           WHERE session_id = ?""",
        (stats_default, session_id),
    )
    await db.execute("DELETE FROM action_resolutions WHERE session_id = ?", (session_id,))
    await db.execute("DELETE FROM rpg_quests WHERE session_id = ?", (session_id,))


async def upsert_static_system_message(
    session_id: str, static_prompt: str, history: list | None = None
) -> bool:
    """Store only static persona prompt in messages. Returns True if written."""
    hist = history if history is not None else await get_history(session_id)
    async with aiosqlite.connect(DB_PATH) as db:
        if not hist:
            await db.execute(
                """INSERT INTO messages (session_id, role, content, image_prompt, image_path)
                   VALUES (?, 'system', ?, NULL, NULL)""",
                (session_id, static_prompt),
            )
            await db.execute(
                "UPDATE sessions SET updated_at = CURRENT_TIMESTAMP WHERE session_id = ?",
                (session_id,),
            )
            await db.commit()
            return True

        if hist[0]["role"] == "system":
            if hist[0]["content"] == static_prompt:
                return False
            await db.execute(
                """UPDATE messages SET content = ?
                   WHERE session_id = ? AND role = 'system'
                   AND id = (SELECT MIN(id) FROM messages WHERE session_id = ?)""",
                (static_prompt, session_id, session_id),
            )
            await db.commit()
            return True

        await db.execute(
            """INSERT INTO messages (session_id, role, content, image_prompt, image_path)
               VALUES (?, 'system', ?, NULL, NULL)""",
            (session_id, static_prompt),
        )
        await db.commit()
        return True


async def delete_dialog_messages(session_id: str) -> None:
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "DELETE FROM messages WHERE session_id = ? AND role IN ('user', 'assistant')",
            (session_id,),
        )
        await db.commit()


async def rebind_session_persona(
    session_id: str,
    persona_id: str,
    *,
    clear_history: bool = False,
    static_prompt: str,
    first_mes: str | None = None,
) -> None:
    session = await get_session(session_id)
    if not session:
        raise ValueError("Session not found")

    await update_session_persona(session_id, persona_id)
    if clear_history:
        await delete_dialog_messages(session_id)

    history = await get_history(session_id)
    await upsert_static_system_message(session_id, static_prompt, history)

    if clear_history and first_mes and first_mes.strip():
        await add_message(session_id, "assistant", first_mes.strip())


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 rpg_quests WHERE session_id = ?", (session_id,))
        await db.execute("DELETE FROM action_resolutions WHERE session_id = ?", (session_id,))
        await db.execute("DELETE FROM sessions WHERE session_id = ?", (session_id,))
        await db.commit()


async def get_action_resolutions_map(session_id: str) -> dict[int, dict]:
    async with aiosqlite.connect(DB_PATH) as db:
        db.row_factory = aiosqlite.Row
        async with db.execute(
            """SELECT message_id, intent_text, roll, outcome, resolution_text
               FROM action_resolutions
               WHERE session_id = ? AND message_id IS NOT NULL
               ORDER BY id""",
            (session_id,),
        ) as cur:
            rows = await cur.fetchall()
    out: dict[int, dict] = {}
    for r in rows:
        mid = r["message_id"]
        if mid is not None:
            out[int(mid)] = {
                "intent_text": r["intent_text"],
                "roll": r["roll"],
                "outcome": r["outcome"],
                "resolution_text": r["resolution_text"],
            }
    return out


def narrator_message_content(narrator: dict) -> str:
    return json.dumps(
        {
            "roll": narrator.get("roll"),
            "outcome": narrator.get("outcome"),
            "text": narrator.get("text", ""),
            "original_intent": narrator.get("original_intent"),
        },
        ensure_ascii=False,
    )


def parse_narrator_message(content: str) -> dict | None:
    try:
        data = json.loads(content or "{}")
    except (json.JSONDecodeError, TypeError):
        return None
    if not isinstance(data, dict) or not (data.get("text") or "").strip():
        return None
    return data


async def seed_quests_from_arc(session_id: str, arc: dict) -> int:
    """Create active quests for arc beats that are not already in rpg_quests."""
    if not arc:
        return 0
    existing = {q["title"] for q in await get_quests(session_id)}
    added = 0
    for beat in arc.get("beats", []):
        title = (beat.get("title") or beat.get("injection", "")).strip()[:120]
        if title and title not in existing:
            await upsert_quest(session_id, title, "active")
            existing.add(title)
            added += 1
    return added


async def get_history(session_id: str) -> list:
    resolutions = await get_action_resolutions_map(session_id)
    async with aiosqlite.connect(DB_PATH) as db:
        db.row_factory = aiosqlite.Row
        async with db.execute(
            """SELECT id, role, content, image_prompt, image_path,
                      image_prompt_alt, image_path_alt, choices_json
               FROM messages WHERE session_id = ? ORDER BY id""",
            (session_id,),
        ) as cursor:
            rows = await cursor.fetchall()
    result = []
    for idx, r in enumerate(rows):
        item = {
            "id": r["id"],
            "role": r["role"],
            "content": r["content"],
            "image_prompt": r["image_prompt"],
            "image_path": r["image_path"],
            "image_prompt_alt": r["image_prompt_alt"],
            "image_path_alt": r["image_path_alt"],
            "choices_json": r["choices_json"],
        }
        if r["role"] == "user" and r["id"] in resolutions:
            item["action_resolution"] = resolutions[r["id"]]
        result.append(item)
        if r["role"] == "user" and r["id"] in resolutions:
            nxt = rows[idx + 1] if idx + 1 < len(rows) else None
            if not nxt or nxt["role"] != "narrator":
                res = resolutions[r["id"]]
                result.append(
                    {
                        "id": -int(r["id"]),
                        "role": "narrator",
                        "content": narrator_message_content(
                            {
                                "roll": res.get("roll"),
                                "outcome": res.get("outcome"),
                                "text": res.get("resolution_text", ""),
                            }
                        ),
                        "image_prompt": None,
                        "image_path": None,
                        "image_prompt_alt": None,
                        "image_path_alt": None,
                        "choices_json": None,
                    }
                )
    return result


async def get_message(message_id: int) -> dict | None:
    async with aiosqlite.connect(DB_PATH) as db:
        db.row_factory = aiosqlite.Row
        async with db.execute(
            "SELECT id, session_id, role, content FROM messages WHERE id = ?",
            (message_id,),
        ) as cursor:
            row = await cursor.fetchone()
    return dict(row) if row else None


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


async def delete_messages_after(session_id: str, message_id: int):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "DELETE FROM messages WHERE session_id = ? AND id > ?",
            (session_id, message_id),
        )
        await db.execute(
            "UPDATE sessions SET updated_at = CURRENT_TIMESTAMP WHERE session_id = ?",
            (session_id,),
        )
        await db.commit()
    await restore_session_to_message(session_id, message_id)


async def delete_message(message_id: int):
    msg = await get_message(message_id)
    if not msg:
        return
    session_id = msg["session_id"]
    anchor = await get_max_message_id_before(session_id, message_id)
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute("DELETE FROM messages WHERE id = ?", (message_id,))
        await db.execute(
            "UPDATE sessions SET updated_at = CURRENT_TIMESTAMP WHERE session_id = ?",
            (session_id,),
        )
        await db.commit()
    await restore_session_to_message(session_id, anchor)


async def delete_message_and_following(session_id: str, message_id: int) -> bool:
    anchor = await get_max_message_id_before(session_id, message_id)
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "DELETE FROM messages WHERE session_id = ? AND id >= ?",
            (session_id, message_id),
        )
        await db.execute(
            "UPDATE sessions SET updated_at = CURRENT_TIMESTAMP WHERE session_id = ?",
            (session_id,),
        )
        await db.commit()
    await restore_session_to_message(session_id, anchor)
    return True


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


async def clear_choices_for_session(session_id: str):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "UPDATE messages SET choices_json = NULL WHERE session_id = ?",
            (session_id,),
        )
        await db.commit()


async def get_last_message_preview(session_id: str, max_len: int = 80) -> str:
    async with aiosqlite.connect(DB_PATH) as db:
        db.row_factory = aiosqlite.Row
        async with db.execute(
            """SELECT content, role FROM messages
               WHERE session_id = ? AND role IN ('user', 'assistant')
               ORDER BY id DESC LIMIT 1""",
            (session_id,),
        ) as cursor:
            row = await cursor.fetchone()
    if not row:
        return ""
    prefix = "Вы: " if row["role"] == "user" else "AI: "
    text = (row["content"] or "").replace("\n", " ").strip()
    if len(text) > max_len:
        text = text[:max_len] + "…"
    return prefix + text


async def get_max_message_id_before(session_id: str, message_id: int) -> int | None:
    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute(
            "SELECT MAX(id) FROM messages WHERE session_id = ? AND id < ?",
            (session_id, message_id),
        ) as cur:
            row = await cur.fetchone()
    if not row or row[0] is None:
        return None
    return int(row[0])


async def _collect_action_resolutions(session_id: str) -> list[dict]:
    async with aiosqlite.connect(DB_PATH) as db:
        db.row_factory = aiosqlite.Row
        async with db.execute(
            """SELECT message_id, intent_text, roll, outcome, resolution_text
               FROM action_resolutions
               WHERE session_id = ?
               ORDER BY id""",
            (session_id,),
        ) as cur:
            rows = await cur.fetchall()
    return [
        {
            "message_id": r["message_id"],
            "intent_text": r["intent_text"],
            "roll": r["roll"],
            "outcome": r["outcome"],
            "resolution_text": r["resolution_text"],
        }
        for r in rows
    ]


async def save_state_snapshot(session_id: str, message_id: int) -> None:
    """Persist RPG session state as it exists right after this message."""
    session = await get_session(session_id)
    if not session:
        return
    quests = await get_quests(session_id)
    resolutions = await _collect_action_resolutions(session_id)
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            """INSERT INTO session_state_snapshots
               (message_id, session_id, facts_json, global_plot, status_quo,
                plot_arc_json, affinity, outfit_json, scene_json,
                narrative_stats_json, quests_json, action_resolutions_json)
               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
               ON CONFLICT(message_id) DO UPDATE SET
                 session_id = excluded.session_id,
                 facts_json = excluded.facts_json,
                 global_plot = excluded.global_plot,
                 status_quo = excluded.status_quo,
                 plot_arc_json = excluded.plot_arc_json,
                 affinity = excluded.affinity,
                 outfit_json = excluded.outfit_json,
                 scene_json = excluded.scene_json,
                 narrative_stats_json = excluded.narrative_stats_json,
                 quests_json = excluded.quests_json,
                 action_resolutions_json = excluded.action_resolutions_json""",
            (
                message_id,
                session_id,
                session.get("facts_json", "[]"),
                session.get("global_plot", ""),
                session.get("status_quo", ""),
                session.get("plot_arc_json", "{}"),
                int(session.get("affinity") or 0),
                session.get("outfit_json", "[]"),
                session.get("scene_json", "{}"),
                session.get("narrative_stats_json", '{"lust":0,"stamina":10,"tension":0}'),
                json.dumps(quests, ensure_ascii=False),
                json.dumps(resolutions, ensure_ascii=False),
            ),
        )
        await db.commit()


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


async def restore_session_from_snapshot(session_id: str, snapshot: dict) -> None:
    from services.rpg_state import DEFAULT_NARRATIVE_STATS

    stats_default = json.dumps(DEFAULT_NARRATIVE_STATS, ensure_ascii=False)
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            """UPDATE sessions SET
                 facts_json = ?,
                 global_plot = ?,
                 status_quo = ?,
                 plot_arc_json = ?,
                 affinity = ?,
                 outfit_json = ?,
                 scene_json = ?,
                 narrative_stats_json = ?,
                 updated_at = CURRENT_TIMESTAMP
               WHERE session_id = ?""",
            (
                snapshot.get("facts_json", "[]"),
                snapshot.get("global_plot", ""),
                snapshot.get("status_quo", ""),
                snapshot.get("plot_arc_json", "{}"),
                int(snapshot.get("affinity") or 0),
                snapshot.get("outfit_json", "[]"),
                snapshot.get("scene_json", "{}"),
                snapshot.get("narrative_stats_json") or stats_default,
                session_id,
            ),
        )
        await db.execute("DELETE FROM rpg_quests WHERE session_id = ?", (session_id,))
        try:
            quests = json.loads(snapshot.get("quests_json") or "[]")
        except (json.JSONDecodeError, TypeError):
            quests = []
        if isinstance(quests, list):
            for q in quests:
                if not isinstance(q, dict):
                    continue
                title = (q.get("title") or "").strip()
                if title:
                    await db.execute(
                        "INSERT INTO rpg_quests (session_id, title, status) VALUES (?, ?, ?)",
                        (session_id, title[:120], q.get("status", "active")),
                    )
        await db.execute("DELETE FROM action_resolutions WHERE session_id = ?", (session_id,))
        try:
            resolutions = json.loads(snapshot.get("action_resolutions_json") or "[]")
        except (json.JSONDecodeError, TypeError):
            resolutions = []
        if isinstance(resolutions, list):
            for r in resolutions:
                if not isinstance(r, dict):
                    continue
                await db.execute(
                    """INSERT INTO action_resolutions
                       (session_id, message_id, intent_text, roll, outcome, resolution_text)
                       VALUES (?, ?, ?, ?, ?, ?)""",
                    (
                        session_id,
                        r.get("message_id"),
                        r.get("intent_text", ""),
                        int(r.get("roll") or 0),
                        r.get("outcome", ""),
                        r.get("resolution_text", ""),
                    ),
                )
        await db.commit()


async def restore_session_to_message(session_id: str, anchor_message_id: int | None) -> bool:
    """Restore RPG state to snapshot at anchor (or nearest earlier message)."""
    if anchor_message_id is None:
        await _reset_persona_bound_state_only(session_id)
        return False
    snap = await get_snapshot_at_or_before(session_id, anchor_message_id)
    if not snap:
        return False
    await restore_session_from_snapshot(session_id, snap)
    return True


async def _reset_persona_bound_state_only(session_id: str) -> None:
    async with aiosqlite.connect(DB_PATH) as db:
        await _reset_persona_bound_state(db, session_id)
        await db.commit()


async def fork_session(source_session_id: str, until_message_id: int) -> str | None:
    source = await get_session(source_session_id)
    if not source:
        return None

    import uuid
    new_id = "sess_" + uuid.uuid4().hex[:8]

    snap = await get_snapshot_at_or_before(source_session_id, until_message_id)

    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            """INSERT INTO sessions
               (session_id, persona_id, title, rpg_enabled, facts_json, global_plot,
                status_quo, plot_arc_json, genre, rpg_settings_json, affinity,
                outfit_json, scene_json, narrative_stats_json)
               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
            (
                new_id,
                source["persona_id"],
                (source.get("title") or "Новый чат") + " (ветка)",
                source.get("rpg_enabled", 0),
                (snap or source).get("facts_json", "[]"),
                (snap or source).get("global_plot", ""),
                (snap or source).get("status_quo", ""),
                (snap or source).get("plot_arc_json", "{}"),
                source.get("genre", "adventure"),
                source.get("rpg_settings_json", "{}"),
                int((snap or source).get("affinity") or 0),
                (snap or source).get("outfit_json", "[]"),
                (snap or source).get("scene_json", "{}"),
                (snap or source).get(
                    "narrative_stats_json", '{"lust":0,"stamina":10,"tension":0}'
                ),
            ),
        )
        async with db.execute(
            """SELECT id, role, content, image_prompt, image_path,
                      image_prompt_alt, image_path_alt, choices_json
               FROM messages
               WHERE session_id = ? AND id <= ? ORDER BY id""",
            (source_session_id, until_message_id),
        ) as cur:
            rows = await cur.fetchall()
        id_map: dict[int, int] = {}
        for r in rows:
            cur_ins = await db.execute(
                """INSERT INTO messages
                   (session_id, role, content, image_prompt, image_path,
                    image_prompt_alt, image_path_alt, choices_json)
                   VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
                (new_id, r[1], r[2], r[3], r[4], r[5], r[6], r[7]),
            )
            id_map[int(r[0])] = int(cur_ins.lastrowid)
        if snap:
            try:
                quests = json.loads(snap.get("quests_json") or "[]")
            except (json.JSONDecodeError, TypeError):
                quests = []
            if isinstance(quests, list):
                for q in quests:
                    if isinstance(q, dict) and (q.get("title") or "").strip():
                        await db.execute(
                            "INSERT INTO rpg_quests (session_id, title, status) VALUES (?, ?, ?)",
                            (new_id, q["title"][:120], q.get("status", "active")),
                        )
            try:
                resolutions = json.loads(snap.get("action_resolutions_json") or "[]")
            except (json.JSONDecodeError, TypeError):
                resolutions = []
            if isinstance(resolutions, list):
                for res in resolutions:
                    if not isinstance(res, dict):
                        continue
                    old_mid = res.get("message_id")
                    new_mid = id_map.get(int(old_mid)) if old_mid is not None else None
                    if new_mid is None:
                        continue
                    await db.execute(
                        """INSERT INTO action_resolutions
                           (session_id, message_id, intent_text, roll, outcome, resolution_text)
                           VALUES (?, ?, ?, ?, ?, ?)""",
                        (
                            new_id,
                            new_mid,
                            res.get("intent_text", ""),
                            int(res.get("roll") or 0),
                            res.get("outcome", ""),
                            res.get("resolution_text", ""),
                        ),
                    )
            async with db.execute(
                """SELECT message_id, facts_json, global_plot, status_quo, plot_arc_json,
                          affinity, outfit_json, scene_json, narrative_stats_json,
                          quests_json, action_resolutions_json
                   FROM session_state_snapshots
                   WHERE session_id = ? AND message_id <= ?""",
                (source_session_id, until_message_id),
            ) as snap_cur:
                snap_rows = await snap_cur.fetchall()
            for srow in snap_rows:
                new_mid = id_map.get(int(srow[0]))
                if new_mid is None:
                    continue
                res_json = srow[10]
                try:
                    res_list = json.loads(res_json or "[]")
                except (json.JSONDecodeError, TypeError):
                    res_list = []
                if isinstance(res_list, list):
                    remapped = []
                    for res in res_list:
                        if not isinstance(res, dict):
                            continue
                        old_mid = res.get("message_id")
                        nm = id_map.get(int(old_mid)) if old_mid is not None else None
                        if nm is not None:
                            remapped.append({**res, "message_id": nm})
                    res_json = json.dumps(remapped, ensure_ascii=False)
                await db.execute(
                    """INSERT INTO session_state_snapshots
                       (message_id, session_id, facts_json, global_plot, status_quo,
                        plot_arc_json, affinity, outfit_json, scene_json,
                        narrative_stats_json, quests_json, action_resolutions_json)
                       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
                    (new_mid, new_id, srow[1], srow[2], srow[3], srow[4], srow[5],
                     srow[6], srow[7], srow[8], srow[9], res_json),
                )
        await db.commit()
    return new_id


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


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 update_message_prompt(message_id: int, image_prompt: str):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "UPDATE messages SET image_prompt = ? WHERE id = ?",
            (image_prompt, message_id),
        )
        await db.commit()


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


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


async def get_last_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 = ? ORDER BY id DESC LIMIT 1",
            (session_id,),
        ) as cursor:
            row = await cursor.fetchone()
    return int(row["id"]) if row else None


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()
    await _reset_persona_bound_state_only(session_id)


async def update_session_affinity(session_id: str, delta: int):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "UPDATE sessions SET affinity = affinity + ?, updated_at = CURRENT_TIMESTAMP WHERE session_id = ?",
            (delta, session_id),
        )
        await db.commit()


async def set_session_affinity(session_id: str, value: int):
    """Debug / admin: set absolute affinity (-30..30)."""
    clamped = max(-30, min(30, int(value)))
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "UPDATE sessions SET affinity = ?, updated_at = CURRENT_TIMESTAMP WHERE session_id = ?",
            (clamped, session_id),
        )
        await db.commit()
    return clamped


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


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


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


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


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


async def upsert_quest(session_id: str, title: str, status: str = "active"):
    async with aiosqlite.connect(DB_PATH) as db:
        async with db.execute(
            "SELECT id FROM rpg_quests WHERE session_id = ? AND title = ?",
            (session_id, title),
        ) as cur:
            row = await cur.fetchone()
        if row:
            await db.execute(
                "UPDATE rpg_quests SET status = ? WHERE id = ?",
                (status, row[0]),
            )
        else:
            await db.execute(
                "INSERT INTO rpg_quests (session_id, title, status) VALUES (?, ?, ?)",
                (session_id, title, status),
            )
        await db.commit()


async def get_quests(session_id: str) -> list:
    async with aiosqlite.connect(DB_PATH) as db:
        db.row_factory = aiosqlite.Row
        async with db.execute(
            "SELECT id, title, status FROM rpg_quests WHERE session_id = ? ORDER BY id",
            (session_id,),
        ) as cur:
            rows = await cur.fetchall()
    return [dict(r) for r in rows]


async def update_quest_status(session_id: str, title: str, status: str):
    async with aiosqlite.connect(DB_PATH) as db:
        await db.execute(
            "UPDATE rpg_quests SET status = ? WHERE session_id = ? AND title = ?",
            (status, session_id, title),
        )
        await db.commit()


async def update_quest_by_id(quest_id: int, session_id: str, status: str) -> bool:
    if status not in ("active", "done", "failed"):
        return False
    async with aiosqlite.connect(DB_PATH) as db:
        cur = await db.execute(
            "UPDATE rpg_quests SET status = ? WHERE id = ? AND session_id = ?",
            (status, quest_id, session_id),
        )
        await db.commit()
        return cur.rowcount > 0


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"]