import os, sqlite3, secrets, time
from functools import wraps
from datetime import datetime
from flask import (Flask, request, jsonify, session, redirect, render_template,
                   send_from_directory, g, flash, abort)
from werkzeug.security import generate_password_hash, check_password_hash
from openai import OpenAI

BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DATA_DIR = os.environ.get("DATA_DIR", os.path.join(BASE_DIR, "data"))
os.makedirs(DATA_DIR, exist_ok=True)
DB = os.path.join(DATA_DIR, "app.db")

app = Flask(__name__, static_folder="static")
_kf = os.path.join(DATA_DIR, "secret.key")
if not os.path.exists(_kf):
    open(_kf, "w").write(secrets.token_hex(32))
app.secret_key = open(_kf).read().strip()
app.config.update(SESSION_COOKIE_HTTPONLY=True, SESSION_COOKIE_SAMESITE="Lax")

DEFAULT_PERSONA = (
    "You are {name}, a warm, playful, caring AI companion in a chat app. "
    "Reply in short, natural messages (1-3 sentences), match the user's language, "
    "use an occasional emoji, ask a gentle follow-up question and remember what the user "
    "told you earlier in the chat. Never claim to be human if sincerely asked; you are an AI "
    "companion. Keep things warm and respectful."
)
MODES = {
    "exclusive": "Mode: Exclusive Chat. Be affectionate, flirty-but-tasteful and personal.",
    "support": "Mode: Emotional Support. Be calm, validating and kind. Listen first; gently suggest real friends or a professional if the user seems to be struggling.",
    "surprise": "Mode: Surprise me. Bring up a fun, unexpected topic, game or question.",
}
DEFAULTS = {"base_url": "https://api.apinex.bond/v1", "model": "free/gpt-6-luna",
            "name": "Faura", "persona": DEFAULT_PERSONA, "rate_limit": "20", "max_history": "20"}

# ---------- db ----------
def db():
    if "db" not in g:
        g.db = sqlite3.connect(DB)
        g.db.row_factory = sqlite3.Row
    return g.db

@app.teardown_appcontext
def _close(e):
    d = g.pop("db", None)
    if d: d.close()

def init_db():
    c = sqlite3.connect(DB)
    c.executescript("""CREATE TABLE IF NOT EXISTS settings(k TEXT PRIMARY KEY, v TEXT);
    CREATE TABLE IF NOT EXISTS messages(id INTEGER PRIMARY KEY AUTOINCREMENT, sid TEXT, role TEXT, content TEXT, ts INTEGER);
    CREATE INDEX IF NOT EXISTS m_sid ON messages(sid);""")
    c.commit(); c.close()
init_db()

def get(k):
    r = db().execute("SELECT v FROM settings WHERE k=?", (k,)).fetchone()
    return r["v"] if r else DEFAULTS.get(k, "")

def put(k, v):
    db().execute("INSERT INTO settings(k,v) VALUES(?,?) ON CONFLICT(k) DO UPDATE SET v=excluded.v", (k, v))
    db().commit()

def installed():
    return bool(get("admin_user"))

@app.template_filter("dt")
def _dt(ts):
    return datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M")

@app.before_request
def _gate():
    if request.endpoint in ("static", "install"):
        return
    if not installed():
        return redirect("/install")

# ---------- csrf / auth ----------
def csrf():
    if "csrf" not in session:
        session["csrf"] = secrets.token_hex(16)
    return session["csrf"]
app.jinja_env.globals["csrf"] = csrf

def admin_only(f):
    @wraps(f)
    def w(*a, **k):
        if not session.get("admin"):
            return redirect("/admin")
        if request.method == "POST" and request.form.get("_t") != session.get("csrf"):
            abort(400)
        return f(*a, **k)
    return w

def ip():
    return (request.headers.get("X-Forwarded-For", request.remote_addr) or "").split(",")[0].strip()

HITS, FAILS = {}, {}

def mask(k):
    return ("•" * 8 + k[-4:]) if k else ""

# ---------- installer ----------
@app.route("/install", methods=["GET", "POST"])
def install():
    if installed():
        return redirect("/admin")
    if request.method == "POST":
        u, p = request.form.get("user", "").strip(), request.form.get("password", "")
        if len(u) < 3 or len(p) < 8:
            flash("Username needs 3+ characters and password 8+ characters.", "err")
        else:
            put("admin_user", u)
            put("admin_hash", generate_password_hash(p))
            for k in ("api_key", "base_url", "model", "name"):
                v = request.form.get(k, "").strip()
                if v: put(k, v)
            flash("Installed. Log in below.", "ok")
            return redirect("/admin")
    return render_template("install.html", d=DEFAULTS)

# ---------- public ----------
@app.get("/")
def index():
    return send_from_directory("static", "index.html")

@app.get("/api/config")
def config():
    return jsonify(name=get("name"))

@app.post("/api/chat")
def chat():
    now = time.time()
    q = [t for t in HITS.get(ip(), []) if now - t < 60]
    if len(q) >= int(get("rate_limit") or 20):
        return jsonify(error="Too many messages. Slow down a little."), 429
    HITS[ip()] = q + [now]
    key = get("api_key")
    if not key:
        return jsonify(error="Chat isn't set up yet."), 503
    data = request.get_json(silent=True) or {}
    n = int(get("max_history") or 20)
    hist = [{"role": m["role"], "content": str(m["content"])[:2000]}
            for m in data.get("messages", [])[-n:] if m.get("role") in ("user", "assistant")]
    if not hist or hist[-1]["role"] != "user":
        return jsonify(error="Empty message."), 400
    system = get("persona").replace("{name}", get("name")) + "\n" + MODES.get(data.get("mode"), MODES["exclusive"])
    try:
        res = OpenAI(api_key=key, base_url=get("base_url"), timeout=60).chat.completions.create(
            model=get("model"), messages=[{"role": "system", "content": system}, *hist])
        reply = res.choices[0].message.content or ""
    except Exception as e:
        app.logger.exception(e)
        return jsonify(error="The AI service didn't respond. Try again."), 502
    sid = request.cookies.get("sid") or secrets.token_hex(8)
    t = int(now)
    db().executemany("INSERT INTO messages(sid,role,content,ts) VALUES(?,?,?,?)",
                     [(sid, "user", hist[-1]["content"], t), (sid, "assistant", reply, t)])
    db().commit()
    r = jsonify(reply=reply)
    r.set_cookie("sid", sid, max_age=31536000, httponly=True, samesite="Lax")
    return r

# ---------- admin ----------
@app.route("/admin", methods=["GET", "POST"])
def admin():
    if request.method == "POST" and not session.get("admin"):
        f = [t for t in FAILS.get(ip(), []) if time.time() - t < 600]
        if len(f) >= 5:
            flash("Too many attempts. Wait 10 minutes.", "err")
        elif (request.form.get("user") == get("admin_user")
              and check_password_hash(get("admin_hash"), request.form.get("password", ""))):
            session["admin"] = True
            return redirect("/admin")
        else:
            FAILS[ip()] = f + [time.time()]
            flash("Wrong username or password.", "err")
    if not session.get("admin"):
        return render_template("login.html")
    c = db()
    day = int(time.time()) - 86400
    stats = dict(
        msgs=c.execute("SELECT COUNT(*) FROM messages").fetchone()[0],
        convs=c.execute("SELECT COUNT(DISTINCT sid) FROM messages").fetchone()[0],
        today=c.execute("SELECT COUNT(*) FROM messages WHERE ts>?", (day,)).fetchone()[0])
    convs = c.execute("SELECT sid, COUNT(*) n, MAX(ts) last FROM messages GROUP BY sid ORDER BY last DESC LIMIT 50").fetchall()
    s = {k: get(k) for k in DEFAULTS}
    return render_template("admin.html", s=s, key=mask(get("api_key")), stats=stats, convs=convs)

@app.post("/admin/settings")
@admin_only
def settings():
    for k in ("base_url", "model", "name", "persona", "rate_limit", "max_history"):
        v = request.form.get(k, "").strip()
        if v: put(k, v)
    if request.form.get("api_key", "").strip():
        put("api_key", request.form["api_key"].strip())
    flash("Settings saved.", "ok")
    return redirect("/admin")

@app.post("/admin/test")
@admin_only
def test():
    try:
        r = OpenAI(api_key=get("api_key"), base_url=get("base_url"), timeout=30).chat.completions.create(
            model=get("model"), messages=[{"role": "user", "content": "Say hi in 5 words."}])
        flash("API works. Reply: " + (r.choices[0].message.content or "")[:120], "ok")
    except Exception as e:
        flash("API test failed: " + str(e)[:300], "err")
    return redirect("/admin")

@app.post("/admin/password")
@admin_only
def password():
    if not check_password_hash(get("admin_hash"), request.form.get("old", "")):
        flash("Current password is wrong.", "err")
    elif len(request.form.get("new", "")) < 8:
        flash("New password needs 8+ characters.", "err")
    else:
        put("admin_hash", generate_password_hash(request.form["new"]))
        flash("Password changed.", "ok")
    return redirect("/admin")

@app.post("/admin/clear")
@admin_only
def clear():
    db().execute("DELETE FROM messages"); db().commit()
    flash("All conversations deleted.", "ok")
    return redirect("/admin")

@app.get("/admin/chat/<sid>")
def conv(sid):
    if not session.get("admin"):
        return redirect("/admin")
    rows = db().execute("SELECT role, content, ts FROM messages WHERE sid=? ORDER BY id", (sid,)).fetchall()
    return render_template("conv.html", rows=rows, sid=sid)

@app.get("/admin/logout")
def logout():
    session.clear()
    return redirect("/admin")

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 5000)))
