#!/usr/bin/env python3
"""Project 3 — a chatbot with per-session memory (lesson AUT-203-L03). Standard library only.

Memory rules this script enforces:
  * history is stored per session_id in SQLite; one session never sees another's messages
  * only the last WINDOW turns are sent to the model (history does not grow without bound)
  * phone numbers and card-like digit runs are masked BEFORE storing
  * each stored message is capped in length; sessions older than RETENTION_DAYS can be purged
  * a user can ask to forget their session

Model: any OpenAI-compatible chat endpoint, configured by environment (see lesson AUT-201-L06):
  LLM_BASE_URL (default http://127.0.0.1:8787/v1, the Barg Sabz mock model), LLM_MODEL, LLM_API_KEY

    python chat_memory.py chat  --session C-01 "سلام، اسمم سارا است"
    python chat_memory.py show  --session C-01
    python chat_memory.py forget --session C-01
    python chat_memory.py purge --older-than-days 30
"""
import argparse
import json
import os
import re
import sqlite3
import sys
import time
import urllib.error
import urllib.request

DB = os.environ.get("CHAT_DB", "chat_memory.sqlite3")
WINDOW_TURNS = int(os.environ.get("CHAT_WINDOW_TURNS", "4"))  # one turn = user message + assistant reply
MAX_CHARS = 1000
SYSTEM = ("تو دستیار پشتیبانی کتاب‌فروشی برگ سبز هستی. کوتاه و مؤدب جواب بده. "
          "درباره سفارش‌ها، تخفیف یا بازپرداخت هیچ تعهدی نده؛ بگو کارمند پیگیری می‌کند.")

PHONE = re.compile(r"(?:\+98|0)?9[0-9۰-۹]{9}|[0-9۰-۹]{4}[- ]?[0-9۰-۹]{4}[- ]?[0-9۰-۹]{4}[- ]?[0-9۰-۹]{4}")


def mask(text):
    return PHONE.sub("[حذف‌شده]", text)[:MAX_CHARS]


def db():
    con = sqlite3.connect(DB)
    con.execute("""CREATE TABLE IF NOT EXISTS messages(
        id INTEGER PRIMARY KEY, session_id TEXT NOT NULL, role TEXT NOT NULL,
        content TEXT NOT NULL, created_at REAL NOT NULL)""")
    con.execute("CREATE INDEX IF NOT EXISTS ix_session ON messages(session_id, id)")
    return con


def history(con, session_id):
    rows = con.execute("SELECT role, content FROM messages WHERE session_id=? ORDER BY id DESC LIMIT ?",
                       (session_id, WINDOW_TURNS * 2)).fetchall()
    return [{"role": r, "content": c} for r, c in reversed(rows)]


def call_model(messages):
    base = os.environ.get("LLM_BASE_URL", "http://127.0.0.1:8787/v1").rstrip("/")
    headers = {"Content-Type": "application/json"}
    key = os.environ.get("LLM_API_KEY", "local-demo-token" if "127.0.0.1:8787" in base else "")
    if key:
        headers["Authorization"] = f"Bearer {key}"
    body = {"model": os.environ.get("LLM_MODEL", "mock-model"), "messages": messages}
    req = urllib.request.Request(base + "/chat/completions", method="POST", headers=headers,
                                 data=json.dumps(body, ensure_ascii=False).encode("utf-8"))
    with urllib.request.urlopen(req, timeout=60) as r:
        return json.load(r)["choices"][0]["message"]["content"]


def chat(session_id, text):
    con = db()
    user_msg = mask(text)
    messages = [{"role": "system", "content": SYSTEM}] + history(con, session_id) + [{"role": "user", "content": user_msg}]
    try:
        reply = call_model(messages)
    except (urllib.error.URLError, TimeoutError) as e:
        print(f"model unavailable ({e.__class__.__name__}); nothing stored", file=sys.stderr)
        sys.exit(1)
    now = time.time()
    with con:  # store both sides only after a successful reply
        con.execute("INSERT INTO messages(session_id, role, content, created_at) VALUES(?,?,?,?)", (session_id, "user", user_msg, now))
        con.execute("INSERT INTO messages(session_id, role, content, created_at) VALUES(?,?,?,?)", (session_id, "assistant", mask(reply), now))
    print(reply)
    print(f"(sent to model: {len(messages)} messages; window = last {WINDOW_TURNS} turns)", file=sys.stderr)


def show(session_id):
    for r, c in db().execute("SELECT role, content FROM messages WHERE session_id=? ORDER BY id", (session_id,)):
        print(f"{r}: {c}")


def forget(session_id):
    con = db()
    with con:
        n = con.execute("DELETE FROM messages WHERE session_id=?", (session_id,)).rowcount
    print(f"deleted {n} messages for session {session_id}")


def purge(days):
    con = db()
    with con:
        n = con.execute("DELETE FROM messages WHERE created_at < ?", (time.time() - days * 86400,)).rowcount
    print(f"purged {n} messages older than {days} days")


if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    sub = ap.add_subparsers(dest="cmd", required=True)
    c = sub.add_parser("chat"); c.add_argument("--session", required=True); c.add_argument("text")
    s = sub.add_parser("show"); s.add_argument("--session", required=True)
    f = sub.add_parser("forget"); f.add_argument("--session", required=True)
    p = sub.add_parser("purge"); p.add_argument("--older-than-days", type=int, required=True)
    a = ap.parse_args()
    if a.cmd == "chat":
        chat(a.session, a.text)
    elif a.cmd == "show":
        show(a.session)
    elif a.cmd == "forget":
        forget(a.session)
    else:
        purge(a.older_than_days)
