from __future__ import annotations

import hashlib
import os
import re
import secrets
import sqlite3
import threading
import time
from pathlib import Path

from Hatenatools import TMB

ROOT = Path(__file__).resolve().parent.parent
DATABASE_DIR = ROOT / "database"
CREATORS_DIR = DATABASE_DIR / "Creators"
COMMENTS_DIR = DATABASE_DIR / "Comments"
DEFAULT_DB_PATH = DATABASE_DIR / "reximemo.sqlite3"
USERNAME_RE = re.compile(r"^[A-Za-z0-9_.-]{3,24}$")


def _now() -> int:
    return int(time.time())


def _row(row):
    return dict(row) if row is not None else None


class DatabaseBackend:
    """Small SQLite backend for RexiMemo: Open Source Edition.

    The OSE deliberately does not contain production session, device, FSID-proof,
    migration, experiment, passkey, Discord or moderation-state tables. Login
    state is just an IP -> account mapping and bans are just blocked IP rows.
    """

    def __init__(self, db_path: str | os.PathLike[str] | None = None):
        DATABASE_DIR.mkdir(parents=True, exist_ok=True)
        CREATORS_DIR.mkdir(parents=True, exist_ok=True)
        COMMENTS_DIR.mkdir(parents=True, exist_ok=True)
        self.db_path = Path(db_path or os.environ.get("REXIMEMO_DB", DEFAULT_DB_PATH))
        self.conn = sqlite3.connect(self.db_path, check_same_thread=False)
        self.conn.row_factory = sqlite3.Row
        self.conn.execute("PRAGMA foreign_keys=ON")
        self.conn.execute("PRAGMA journal_mode=WAL")
        self.lock = threading.RLock()
        self._schema()
        self._seed()

    def _schema(self):
        with self.lock, self.conn:
            self.conn.executescript(
                """
                CREATE TABLE IF NOT EXISTS accounts(
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    username TEXT NOT NULL UNIQUE COLLATE NOCASE,
                    password_sha256 TEXT NOT NULL,
                    is_admin INTEGER NOT NULL DEFAULT 0 CHECK(is_admin IN (0,1)),
                    created_at INTEGER NOT NULL
                );

                CREATE TABLE IF NOT EXISTS ip_logins(
                    ip TEXT PRIMARY KEY,
                    account_id INTEGER NOT NULL REFERENCES accounts(id) ON DELETE CASCADE,
                    last_seen INTEGER NOT NULL
                );

                CREATE TABLE IF NOT EXISTS ip_bans(
                    ip TEXT PRIMARY KEY,
                    reason TEXT NOT NULL DEFAULT '',
                    created_at INTEGER NOT NULL
                );

                CREATE TABLE IF NOT EXISTS creator_rooms(
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    public_id TEXT NOT NULL UNIQUE,
                    account_id INTEGER UNIQUE REFERENCES accounts(id) ON DELETE SET NULL,
                    owner_ip TEXT UNIQUE,
                    fsid TEXT NOT NULL DEFAULT '',
                    display_name TEXT NOT NULL,
                    created_at INTEGER NOT NULL
                );

                CREATE TABLE IF NOT EXISTS channels(
                    id INTEGER PRIMARY KEY,
                    title TEXT NOT NULL,
                    description TEXT NOT NULL DEFAULT ''
                );

                CREATE TABLE IF NOT EXISTS flipnotes(
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    public_id TEXT NOT NULL UNIQUE,
                    creator_room_id INTEGER NOT NULL REFERENCES creator_rooms(id) ON DELETE CASCADE,
                    creator_fsid TEXT NOT NULL,
                    filename TEXT NOT NULL,
                    title TEXT NOT NULL DEFAULT '',
                    channel_id INTEGER REFERENCES channels(id) ON DELETE SET NULL,
                    views INTEGER NOT NULL DEFAULT 0,
                    downloads INTEGER NOT NULL DEFAULT 0,
                    stars INTEGER NOT NULL DEFAULT 0,
                    posted_at INTEGER NOT NULL,
                    deleted INTEGER NOT NULL DEFAULT 0 CHECK(deleted IN (0,1)),
                    UNIQUE(creator_fsid, filename)
                );
                CREATE INDEX IF NOT EXISTS idx_flipnotes_posted ON flipnotes(deleted, posted_at DESC);
                CREATE INDEX IF NOT EXISTS idx_flipnotes_room ON flipnotes(creator_room_id, deleted, posted_at DESC);

                CREATE TABLE IF NOT EXISTS comments(
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    public_id TEXT NOT NULL UNIQUE,
                    flipnote_id INTEGER NOT NULL REFERENCES flipnotes(id) ON DELETE CASCADE,
                    creator_room_id INTEGER NOT NULL REFERENCES creator_rooms(id) ON DELETE CASCADE,
                    type TEXT NOT NULL CHECK(type IN ('text','memo')),
                    text_content TEXT,
                    memo_filename TEXT,
                    posted_at INTEGER NOT NULL,
                    deleted INTEGER NOT NULL DEFAULT 0 CHECK(deleted IN (0,1))
                );
                CREATE INDEX IF NOT EXISTS idx_comments_flipnote ON comments(flipnote_id, deleted, posted_at ASC);
                """
            )

    @staticmethod
    def _password_hash(password: str) -> str:
        # Deliberately simple for the OSE reference build. The README warns that
        # this is not production authentication and should be replaced.
        return hashlib.sha256(str(password).encode("utf-8")).hexdigest()

    def _seed(self):
        with self.lock, self.conn:
            self.conn.execute(
                "INSERT OR IGNORE INTO channels(id,title,description) VALUES(1,'General','Public Flipnotes')"
            )
            if not self._one("SELECT id FROM accounts WHERE username=?", ("reximemo",)):
                self.conn.execute(
                    "INSERT INTO accounts(username,password_sha256,is_admin,created_at) VALUES(?,?,1,?)",
                    ("reximemo", self._password_hash("alpine"), _now()),
                )

    def close(self):
        with self.lock:
            self.conn.close()

    def _one(self, sql, args=()):
        return _row(self.conn.execute(sql, args).fetchone())

    def _all(self, sql, args=()):
        return [_row(row) for row in self.conn.execute(sql, args).fetchall()]

    @staticmethod
    def _public_id(prefix: str) -> str:
        return prefix + secrets.token_urlsafe(8).replace("-", "").replace("_", "")[:11]

    # Accounts and the intentionally tiny IP login system -----------------
    def create_account(self, username: str, password: str) -> int:
        username = str(username or "").strip()
        if not USERNAME_RE.fullmatch(username):
            raise ValueError("Use 3-24 letters, numbers, dots, dashes or underscores.")
        if len(str(password or "")) < 4:
            raise ValueError("Password must be at least 4 characters.")
        with self.lock, self.conn:
            try:
                cur = self.conn.execute(
                    "INSERT INTO accounts(username,password_sha256,is_admin,created_at) VALUES(?,?,0,?)",
                    (username, self._password_hash(password), _now()),
                )
            except sqlite3.IntegrityError as exc:
                raise ValueError("That username is already in use.") from exc
            return int(cur.lastrowid)

    def verify_account(self, username: str, password: str):
        return self._one(
            "SELECT * FROM accounts WHERE username=? AND password_sha256=?",
            (str(username or "").strip(), self._password_hash(password)),
        )

    def get_account(self, account_id: int):
        return self._one("SELECT * FROM accounts WHERE id=?", (int(account_id),))

    def get_account_by_username(self, username: str):
        return self._one("SELECT * FROM accounts WHERE username=?", (str(username or "").strip(),))

    def login_ip(self, ip: str, account_id: int) -> None:
        ip = str(ip or "").strip()
        if not ip:
            raise ValueError("Missing client IP.")
        with self.lock, self.conn:
            self.conn.execute(
                "INSERT INTO ip_logins(ip,account_id,last_seen) VALUES(?,?,?) "
                "ON CONFLICT(ip) DO UPDATE SET account_id=excluded.account_id,last_seen=excluded.last_seen",
                (ip, int(account_id), _now()),
            )

    def logout_ip(self, ip: str) -> None:
        with self.lock, self.conn:
            self.conn.execute("DELETE FROM ip_logins WHERE ip=?", (str(ip or ""),))

    def account_for_ip(self, ip: str):
        ip = str(ip or "").strip()
        if not ip:
            return None
        with self.lock, self.conn:
            row = self._one(
                "SELECT a.* FROM ip_logins l JOIN accounts a ON a.id=l.account_id WHERE l.ip=?",
                (ip,),
            )
            if row:
                self.conn.execute("UPDATE ip_logins SET last_seen=? WHERE ip=?", (_now(), ip))
            return row

    # IP bans --------------------------------------------------------------
    def is_ip_banned(self, ip: str) -> bool:
        return bool(self._one("SELECT ip FROM ip_bans WHERE ip=?", (str(ip or ""),)))

    def ban_ip(self, ip: str, reason: str = "") -> None:
        ip = str(ip or "").strip()
        if not ip:
            raise ValueError("IP is required.")
        with self.lock, self.conn:
            self.conn.execute(
                "INSERT INTO ip_bans(ip,reason,created_at) VALUES(?,?,?) "
                "ON CONFLICT(ip) DO UPDATE SET reason=excluded.reason,created_at=excluded.created_at",
                (ip, str(reason or "")[:200], _now()),
            )
            self.conn.execute("DELETE FROM ip_logins WHERE ip=?", (ip,))

    def unban_ip(self, ip: str) -> None:
        with self.lock, self.conn:
            self.conn.execute("DELETE FROM ip_bans WHERE ip=?", (str(ip or ""),))

    def list_bans(self):
        return self._all("SELECT * FROM ip_bans ORDER BY created_at DESC")

    # Creator rooms --------------------------------------------------------
    @staticmethod
    def _guest_name(ip: str) -> str:
        suffix = hashlib.sha1(str(ip or "guest").encode("utf-8")).hexdigest()[:6].upper()
        return "Guest-" + suffix

    def get_creator_room(self, room_id: int):
        return self._one("SELECT * FROM creator_rooms WHERE id=?", (int(room_id),))

    def get_creator_room_by_public_id(self, public_id: str):
        return self._one("SELECT * FROM creator_rooms WHERE public_id=?", (str(public_id),))

    def get_creator_room_by_fsid(self, fsid: str):
        return self._one("SELECT * FROM creator_rooms WHERE fsid=? ORDER BY id LIMIT 1", (str(fsid or "").upper(),))

    def room_for_account(self, account_id: int):
        return self._one("SELECT * FROM creator_rooms WHERE account_id=?", (int(account_id),))

    def room_for_ip(self, ip: str):
        return self._one("SELECT * FROM creator_rooms WHERE owner_ip=?", (str(ip or ""),))

    def get_or_create_creator(self, ip: str, account_id: int | None = None, *, fsid: str = "", display_name: str = ""):
        fsid = str(fsid or "").upper()[:16]
        if account_id:
            room = self.room_for_account(int(account_id))
            account = self.get_account(int(account_id))
            name = (account or {}).get("username") or str(display_name or "Creator")
            if room:
                if fsid and not room.get("fsid"):
                    with self.lock, self.conn:
                        self.conn.execute("UPDATE creator_rooms SET fsid=? WHERE id=?", (fsid, int(room["id"])))
                    room["fsid"] = fsid
                return room
            with self.lock, self.conn:
                cur = self.conn.execute(
                    "INSERT INTO creator_rooms(public_id,account_id,owner_ip,fsid,display_name,created_at) VALUES(?,?,?,?,?,?)",
                    (self._public_id("r_"), int(account_id), None, fsid, name[:64], _now()),
                )
                return self.get_creator_room(cur.lastrowid)

        ip = str(ip or "").strip()
        room = self.room_for_ip(ip) if ip else None
        if room:
            updates = []
            args = []
            if fsid and not room.get("fsid"):
                updates.append("fsid=?"); args.append(fsid)
            if display_name and room.get("display_name", "").startswith("Guest-"):
                updates.append("display_name=?"); args.append(str(display_name)[:64])
            if updates:
                args.append(int(room["id"]))
                with self.lock, self.conn:
                    self.conn.execute("UPDATE creator_rooms SET %s WHERE id=?" % ",".join(updates), args)
                room = self.get_creator_room(room["id"])
            return room
        name = str(display_name or "").strip()[:64] or self._guest_name(ip)
        with self.lock, self.conn:
            cur = self.conn.execute(
                "INSERT INTO creator_rooms(public_id,account_id,owner_ip,fsid,display_name,created_at) VALUES(?,?,?,?,?,?)",
                (self._public_id("r_"), None, ip or None, fsid, name, _now()),
            )
            return self.get_creator_room(cur.lastrowid)

    def list_creator_flipnotes(self, room_id: int, limit=50, offset=0):
        return self.list_flipnotes(room_id=int(room_id), limit=limit, offset=offset)

    # Channels -------------------------------------------------------------
    def get_channel(self, channel_id: int):
        return self._one("SELECT * FROM channels WHERE id=?", (int(channel_id),))

    def list_channels(self):
        return self._all("SELECT * FROM channels ORDER BY id")

    # Flipnotes ------------------------------------------------------------
    def FlipnotePath(self, creator_fsid: str, filename: str) -> Path:
        return CREATORS_DIR / str(creator_fsid).upper() / (str(filename) + ".ppm")

    def CreatorExists(self, creator_fsid: str) -> bool:
        return bool(self.get_creator_room_by_fsid(creator_fsid) or (CREATORS_DIR / str(creator_fsid).upper()).exists())

    def FlipnoteExists(self, creator_fsid: str, filename: str) -> bool:
        return bool(self.get_flipnote(creator_fsid, filename)) and self.FlipnotePath(creator_fsid, filename).is_file()

    def AddFlipnote(self, content, Channel="1", AccountID=None, ip_address=""):
        data = bytes(content or b"")
        tmb = TMB().Read(data)
        if not tmb:
            return False
        fsid = str(getattr(tmb, "EditorAuthorID", "") or "").upper()
        current_name = str(getattr(tmb, "CurrentFilename", "") or "")
        filename = Path(current_name).stem if current_name else ""
        if not fsid or not filename:
            return False
        if self.get_flipnote(fsid, filename):
            return False
        display_name = str(getattr(tmb, "Username", "") or getattr(tmb, "EditorAuthorName", "") or "Creator")
        room = self.get_or_create_creator(ip_address, AccountID, fsid=fsid, display_name=display_name)
        channel_id = int(Channel) if str(Channel or "").isdigit() else 1
        if not self.get_channel(channel_id):
            channel_id = 1
        now = _now()
        with self.lock, self.conn:
            cur = self.conn.execute(
                "INSERT INTO flipnotes(public_id,creator_room_id,creator_fsid,filename,title,channel_id,posted_at) "
                "VALUES(?,?,?,?,?,?,?)",
                (self._public_id("f_"), int(room["id"]), fsid, filename, "Flipnote by " + room["display_name"], channel_id, now),
            )
            path = self.FlipnotePath(fsid, filename)
            path.parent.mkdir(parents=True, exist_ok=True)
            path.write_bytes(data)
            return fsid, filename, int(cur.lastrowid)

    def get_flipnote(self, creator_fsid: str, filename: str):
        return self._one(
            "SELECT f.*,r.public_id AS creator_public_id,r.display_name AS creator_name,r.account_id,r.owner_ip "
            "FROM flipnotes f JOIN creator_rooms r ON r.id=f.creator_room_id "
            "WHERE f.creator_fsid=? AND f.filename=? AND f.deleted=0",
            (str(creator_fsid).upper(), str(filename)),
        )

    def get_flipnote_by_id(self, flipnote_id: int):
        return self._one(
            "SELECT f.*,r.public_id AS creator_public_id,r.display_name AS creator_name,r.account_id,r.owner_ip "
            "FROM flipnotes f JOIN creator_rooms r ON r.id=f.creator_room_id WHERE f.id=? AND f.deleted=0",
            (int(flipnote_id),),
        )

    def get_flipnote_by_public_id(self, public_id: str):
        return self._one(
            "SELECT f.*,r.public_id AS creator_public_id,r.display_name AS creator_name,r.account_id,r.owner_ip "
            "FROM flipnotes f JOIN creator_rooms r ON r.id=f.creator_room_id WHERE f.public_id=? AND f.deleted=0",
            (str(public_id),),
        )

    def GetFlipnote(self, CreatorID, filename, Store=False):
        return self.get_flipnote(CreatorID, filename) or False

    def GetFlipnotePPM(self, CreatorID, filename):
        return self.FlipnotePath(CreatorID, filename).read_bytes()

    def GetFlipnoteTMB(self, CreatorID, filename):
        with self.FlipnotePath(CreatorID, filename).open("rb") as f:
            return f.read(0x6A0)

    def list_flipnotes(self, *, sort="new", page=1, per_page=50, limit=None, offset=None, channel_id=None, room_id=None):
        if limit is None:
            limit = per_page
        if offset is None:
            offset = max(0, int(page) - 1) * int(per_page)
        order = {
            "new": "f.posted_at DESC, f.id DESC",
            "popular": "f.views DESC, f.stars DESC, f.posted_at DESC",
            "top": "f.stars DESC, f.views DESC, f.posted_at DESC",
        }.get(sort, "f.posted_at DESC, f.id DESC")
        where = ["f.deleted=0"]
        args = []
        if channel_id is not None:
            where.append("f.channel_id=?"); args.append(int(channel_id))
        if room_id is not None:
            where.append("f.creator_room_id=?"); args.append(int(room_id))
        args.extend((int(limit), int(offset)))
        return self._all(
            "SELECT f.*,r.public_id AS creator_public_id,r.display_name AS creator_name,r.account_id,r.owner_ip "
            "FROM flipnotes f JOIN creator_rooms r ON r.id=f.creator_room_id "
            "WHERE %s ORDER BY %s LIMIT ? OFFSET ?" % (" AND ".join(where), order), args,
        )

    def count_flipnotes(self, *, channel_id=None, room_id=None):
        where = ["deleted=0"]
        args = []
        if channel_id is not None:
            where.append("channel_id=?"); args.append(int(channel_id))
        if room_id is not None:
            where.append("creator_room_id=?"); args.append(int(room_id))
        row = self._one("SELECT COUNT(*) AS n FROM flipnotes WHERE " + " AND ".join(where), args)
        return int(row["n"] if row else 0)

    @property
    def Newest(self):
        return [(r["creator_fsid"], r["filename"]) for r in self.list_flipnotes(limit=5000)]

    @property
    def Views(self):
        row = self._one("SELECT COALESCE(SUM(views),0) AS n FROM flipnotes WHERE deleted=0")
        return int(row["n"])

    @property
    def Stars(self):
        row = self._one("SELECT COALESCE(SUM(stars),0) AS n FROM flipnotes WHERE deleted=0")
        return int(row["n"])

    def AddView(self, CreatorID, filename, AccountID=None):
        with self.lock, self.conn:
            cur = self.conn.execute(
                "UPDATE flipnotes SET views=views+1 WHERE creator_fsid=? AND filename=? AND deleted=0",
                (str(CreatorID).upper(), str(filename)),
            )
            return cur.rowcount > 0

    def AddDownload(self, CreatorID, filename):
        with self.lock, self.conn:
            cur = self.conn.execute(
                "UPDATE flipnotes SET downloads=downloads+1 WHERE creator_fsid=? AND filename=? AND deleted=0",
                (str(CreatorID).upper(), str(filename)),
            )
            return cur.rowcount > 0

    def AddStar(self, CreatorID, filename, amount=1, color="yellow"):
        try:
            amount = max(1, min(65535, int(amount)))
        except Exception:
            return False
        with self.lock, self.conn:
            cur = self.conn.execute(
                "UPDATE flipnotes SET stars=stars+? WHERE creator_fsid=? AND filename=? AND deleted=0",
                (amount, str(CreatorID).upper(), str(filename)),
            )
            return cur.rowcount > 0

    def delete_flipnote(self, flipnote_id: int) -> bool:
        with self.lock, self.conn:
            cur = self.conn.execute("UPDATE flipnotes SET deleted=1 WHERE id=?", (int(flipnote_id),))
            return cur.rowcount > 0

    # Comments -------------------------------------------------------------
    def add_text_comment(self, flipnote_id: int, text: str, *, ip_address="", account_id=None):
        text = " ".join(str(text or "").split())[:500]
        if not text:
            raise ValueError("Comment is empty.")
        room = self.get_or_create_creator(ip_address, account_id)
        with self.lock, self.conn:
            cur = self.conn.execute(
                "INSERT INTO comments(public_id,flipnote_id,creator_room_id,type,text_content,posted_at) VALUES(?,?,?,?,?,?)",
                (self._public_id("m_"), int(flipnote_id), int(room["id"]), "text", text, _now()),
            )
            return int(cur.lastrowid)

    def add_memo_comment(self, flipnote_id: int, ppm: bytes, *, ip_address="", account_id=None):
        data = bytes(ppm or b"")
        tmb = TMB().Read(data)
        if not tmb:
            raise ValueError("Invalid mini Flipnote.")
        room = self.get_or_create_creator(
            ip_address,
            account_id,
            fsid=str(getattr(tmb, "EditorAuthorID", "") or ""),
            display_name=str(getattr(tmb, "Username", "") or ""),
        )
        with self.lock, self.conn:
            cur = self.conn.execute(
                "INSERT INTO comments(public_id,flipnote_id,creator_room_id,type,memo_filename,posted_at) VALUES(?,?,?,?,?,?)",
                (self._public_id("m_"), int(flipnote_id), int(room["id"]), "memo", "pending", _now()),
            )
            cid = int(cur.lastrowid)
            name = f"{cid}.ppm"
            (COMMENTS_DIR / name).write_bytes(data)
            self.conn.execute("UPDATE comments SET memo_filename=? WHERE id=?", (name, cid))
            return cid

    def get_comment(self, comment_id: int):
        return self._one(
            "SELECT c.*,r.public_id AS creator_public_id,r.display_name AS creator_name "
            "FROM comments c JOIN creator_rooms r ON r.id=c.creator_room_id WHERE c.id=? AND c.deleted=0",
            (int(comment_id),),
        )

    def list_comments(self, flipnote_id: int, limit=100, offset=0):
        return self._all(
            "SELECT c.*,r.public_id AS creator_public_id,r.display_name AS creator_name "
            "FROM comments c JOIN creator_rooms r ON r.id=c.creator_room_id "
            "WHERE c.flipnote_id=? AND c.deleted=0 ORDER BY c.posted_at ASC,c.id ASC LIMIT ? OFFSET ?",
            (int(flipnote_id), int(limit), int(offset)),
        )

    def count_comments(self, flipnote_id: int):
        row = self._one("SELECT COUNT(*) AS n FROM comments WHERE flipnote_id=? AND deleted=0", (int(flipnote_id),))
        return int(row["n"] if row else 0)

    def comment_ppm(self, comment_id: int):
        row = self.get_comment(comment_id)
        if not row or row["type"] != "memo" or not row.get("memo_filename"):
            return None
        path = COMMENTS_DIR / row["memo_filename"]
        return path.read_bytes() if path.is_file() else None

    # Minimal admin helpers ------------------------------------------------
    def recent_ip_logins(self, limit=50):
        return self._all(
            "SELECT l.ip,l.last_seen,a.id AS account_id,a.username FROM ip_logins l "
            "JOIN accounts a ON a.id=l.account_id ORDER BY l.last_seen DESC LIMIT ?",
            (int(limit),),
        )


Database = DatabaseBackend()