"""BankStatementDesk application. Run behind an HTTPS reverse proxy."""
import base64
import hashlib
import hmac
import json
import mimetypes
import os
import re
import secrets
import smtplib
import sqlite3
import time
from contextlib import closing
from datetime import datetime, timezone
from email.message import EmailMessage
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import urlencode, urlsplit, parse_qs, unquote, quote
from urllib.request import Request, urlopen

ROOT = Path(__file__).resolve().parent / "site"
DATA = Path(os.environ.get("DATA_DIR", "./data")).resolve()
ORIGIN = os.environ.get("SITE_ORIGIN", "https://bankstatementdesk.com").rstrip("/")
TOOLS = {value for value in re.findall(r'path: "([^"]+)"', (ROOT / "tools-data.mjs").read_text())}
LIMIT = 10 * 1024 * 1024
KINDS = {"xlsx", "csv", "qbo", "ofx", "txt", "zip", "json"}

def database():
    db = sqlite3.connect(DATA / "workspace.sqlite3", timeout=15)
    db.row_factory = sqlite3.Row
    db.execute("PRAGMA foreign_keys=ON")
    return db

def initialize():
    os.umask(0o077)
    DATA.mkdir(parents=True, exist_ok=True)
    with closing(database()) as db:
        db.executescript("""
        PRAGMA journal_mode=WAL;
        CREATE TABLE IF NOT EXISTS users(id INTEGER PRIMARY KEY, email TEXT UNIQUE NOT NULL, google TEXT UNIQUE, name TEXT NOT NULL, retention INTEGER DEFAULT 90);
        CREATE TABLE IF NOT EXISTS sessions(token TEXT PRIMARY KEY, uid INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE, expires INTEGER NOT NULL);
        CREATE TABLE IF NOT EXISTS codes(email TEXT PRIMARY KEY, digest TEXT NOT NULL, expires INTEGER NOT NULL, attempts INTEGER DEFAULT 0);
        CREATE TABLE IF NOT EXISTS oauth(state TEXT PRIMARY KEY, nonce TEXT NOT NULL, verifier TEXT NOT NULL, expires INTEGER NOT NULL);
        CREATE TABLE IF NOT EXISTS rate (bucket TEXT PRIMARY KEY, hits INTEGER NOT NULL, expires INTEGER NOT NULL);
        CREATE TABLE IF NOT EXISTS files(id TEXT PRIMARY KEY, uid INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE, name TEXT NOT NULL, kind TEXT NOT NULL, size INTEGER NOT NULL, tool TEXT NOT NULL, rows INTEGER, created INTEGER NOT NULL, expires INTEGER, body BLOB NOT NULL);
        CREATE INDEX IF NOT EXISTS files_owner ON files(uid, created);
        """)
    return os.environ["APP_SECRET"].encode()

def stamp(epoch):
    return datetime.fromtimestamp(epoch, timezone.utc).isoformat() if epoch else None

def digest(value):
    return hashlib.sha256(value.encode()).hexdigest()

def otp_digest(email, code):
    return hmac.digest(SECRET, (email + ":" + code).encode(), "sha256").hex()

def send_code(email, code):
    msg = EmailMessage()
    msg["From"] = os.environ["SMTP_FROM"]
    msg["To"] = email
    msg["Subject"] = "Your BankStatementDesk sign-in code"
    msg.set_content(f"Your BankStatementDesk code is {code}. It expires in 10 minutes. If you did not request this, you can ignore this email.")
    host = os.environ["SMTP_HOST"]
    port = int(os.environ.get("SMTP_PORT", "587"))
    smtp_class = smtplib.SMTP_SSL if port == 465 else smtplib.SMTP
    import ssl
    context = ssl.create_default_context()
    kwargs = {"context": context} if port == 465 else {}
    with smtp_class(host, port, timeout=12, **kwargs) as smtp:
        if port != 465:
            smtp.starttls(context=context)
        smtp.login(os.environ["SMTP_USER"], os.environ["SMTP_PASSWORD"])
        smtp.send_message(msg)

class Rejected(Exception):
    def __init__(self, message, status=400):
        self.message, self.status = message, status

class App(BaseHTTPRequestHandler):
    def log_message(self, *_):
        pass

    def reply(self, status, body=b"", mime="application/json", extra=()):
        self.send_response(status)
        self.send_header("Content-Type", mime)
        self.send_header("Content-Length", str(len(body)))
        self.send_header("Cache-Control", "no-store")
        self.send_header("X-Content-Type-Options", "nosniff")
        self.send_header("X-Frame-Options", "DENY")
        self.send_header("Referrer-Policy", "no-referrer")
        self.send_header("Content-Security-Policy", "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; worker-src 'self' blob:; object-src 'none'; frame-ancestors 'none'; base-uri 'none'; form-action 'self'; connect-src 'self'")
        for name, value in extra:
            self.send_header(name, value)
        self.end_headers()
        if self.command != "HEAD":
            self.wfile.write(body)

    def json(self, data, status=200, extra=()):
        self.reply(status, json.dumps(data).encode(), extra=extra)

    def redirect(self, path, extra=()):
        self.reply(303, extra=(("Location", path), *extra))

    def cookie_value(self, name):
        from http.cookies import SimpleCookie
        cookie = SimpleCookie(self.headers.get("Cookie", ""))
        return cookie[name].value if name in cookie else ""

    def cookie(self, name, value, age):
        secure = "; Secure" if ORIGIN.startswith("https://") else ""
        return ("Set-Cookie", f"{name}={value}; Path=/; HttpOnly; SameSite=Lax; Max-Age={age}{secure}")

    def clean(self, db):
        now = int(time.time())
        for table in ("files", "sessions", "codes", "oauth", "rate"):
            db.execute(f"DELETE FROM {table} WHERE expires<=?", (now,))

    def user(self, db):
        return db.execute("SELECT users.* FROM users JOIN sessions ON uid=users.id WHERE token=? AND expires>?", (digest(self.cookie_value("epe_session")), time.time())).fetchone()

    def login(self, db, uid):
        token = secrets.token_urlsafe(32)
        db.execute("DELETE FROM sessions WHERE token=?", (digest(self.cookie_value("epe_session")),))
        db.execute("INSERT INTO sessions VALUES(?,?,?)", (digest(token), uid, int(time.time())+604800))
        db.commit()
        return self.cookie("epe_session", token, 604800)

    def limited(self, db, bucket, limit, seconds):
        now = int(time.time())
        db.execute("INSERT INTO rate VALUES(?,1,?) ON CONFLICT(bucket) DO UPDATE SET hits=hits+1", (bucket, now+seconds))
        count = db.execute("SELECT hits FROM rate WHERE bucket=?", (bucket,)).fetchone()[0]
        db.commit()
        if count > limit:
            raise Rejected("Please try again later.", 429)

    def input(self, maximum):
        try:
            size = int(self.headers.get("Content-Length", "0"))
        except ValueError:
            raise Rejected("Invalid request length.")
        if size < 0 or size > maximum:
            raise Rejected("Request is too large.", 413)
        return self.rfile.read(size)

    def google(self, db, path, query):
        client = os.environ.get("GOOGLE_CLIENT_ID")
        secret = os.environ.get("GOOGLE_CLIENT_SECRET")
        if not client or not secret:
            raise Rejected("Google sign-in is awaiting configuration.", 503)
        callback = ORIGIN + "/auth/google/callback"
        now = int(time.time())
        if path == "/auth/google":
            state, verifier = secrets.token_urlsafe(32), secrets.token_urlsafe(48)
            challenge = base64.urlsafe_b64encode(hashlib.sha256(verifier.encode()).digest()).decode().rstrip("=")
            destination = query.get("next", [""])[0]
            if destination not in TOOLS:
                destination = "/dashboard/"
            db.execute("INSERT INTO oauth VALUES(?,?,?,?)", (digest(state), destination, verifier, now+600))
            db.commit()
            params = urlencode(dict(client_id=client, redirect_uri=callback, response_type="code", scope="openid email profile", state=state, code_challenge=challenge, code_challenge_method="S256"))
            return self.redirect("https://accounts.google.com/o/oauth2/v2/auth?" + params, (self.cookie("epe_oauth", state, 600),))
        state, code = query.get("state", [""])[0], query.get("code", [""])[0]
        cookie = self.cookie_value("epe_oauth")
        if not state or not code or not hmac.compare_digest(state, cookie):
            return self.redirect("/login/?error=google")
        attempt = db.execute("DELETE FROM oauth WHERE state=? AND expires>? RETURNING verifier,nonce", (digest(state), now)).fetchone()
        db.commit()
        if not attempt:
            return self.redirect("/login/?error=google")
        try:
            form = urlencode(dict(code=code, client_id=client, client_secret=secret, redirect_uri=callback, grant_type="authorization_code", code_verifier=attempt["verifier"])).encode()
            with urlopen(Request("https://oauth2.googleapis.com/token", data=form), timeout=12) as res:
                token = json.load(res)["access_token"]
            with urlopen(Request("https://openidconnect.googleapis.com/v1/userinfo", headers={"Authorization": "Bearer "+token}), timeout=12) as res:
                info = json.load(res)
            if info.get("email_verified") is not True or not info.get("sub") or not info.get("email"):
                raise ValueError()
        except (OSError, ValueError, KeyError):
            return self.redirect("/login/?error=google")
        email = info["email"].lower()
        db.execute("BEGIN IMMEDIATE")
        existing = db.execute("SELECT id FROM users WHERE google=?", (info["sub"],)).fetchone()
        if existing:
            uid = existing["id"]
        else:
            result = db.execute("INSERT OR IGNORE INTO users(email,google,name) VALUES(?,?,?)", (email, info["sub"], str(info.get("name") or email.split("@")[0])[:120]))
            if not result.rowcount:
                db.rollback()
                return self.redirect("/login/?error=existing")
            uid = result.lastrowid
        destination = attempt["nonce"] if attempt["nonce"] in TOOLS else "/dashboard/"
        return self.redirect(destination, (self.login(db, uid), self.cookie("epe_oauth", "", 0)))

    def api(self, db, path, user):
        action = path.removeprefix("/api/")
        post = self.command == "POST"
        if action == "session" and not post:
            return self.json(dict(id=user["id"], email=user["email"], name=user["name"], provider="google" if user["google"] else "email", verified=True) if user else None)
        if action in {"code", "verify"} and post:
            data = json.loads(self.input(4096))
            email = str(data.get("email", "")).strip().lower()
            if len(email)>254 or not re.fullmatch(r"[^@\s,;<>]+@[^@\s,;<>]+\.[^@\s,;<>]+", email):
                raise Rejected("Enter a valid email address.")
            ip = self.headers.get("X-Forwarded-For", self.client_address[0]).split(",")[-1].strip()
            self.limited(db, action+":"+ip, 15 if action=="verify" else 8, 600)
            if action == "code":
                self.limited(db, "email:"+email, 3, 600)
                code = f"{secrets.randbelow(1000000):06d}"
                db.execute("INSERT OR REPLACE INTO codes VALUES(?,?,?,0)", (email, otp_digest(email, code), int(time.time())+600))
                db.commit()
                try:
                    send_code(email, code)
                except (KeyError, OSError, smtplib.SMTPException):
                    raise Rejected("Email delivery is unavailable. Please try again later.", 503)
                return self.json({"sent":True})
            db.execute("BEGIN IMMEDIATE")
            row = db.execute("SELECT * FROM codes WHERE email=? AND expires>?", (email, time.time())).fetchone()
            if not row or row["attempts"]>=5 or not hmac.compare_digest(row["digest"], otp_digest(email, str(data.get("code","")))):
                db.execute("UPDATE codes SET attempts=attempts+1 WHERE email=?", (email,))
                db.commit()
                raise Rejected("Invalid or expired code. Request a new one if needed.")
            db.execute("DELETE FROM codes WHERE email=?", (email,))
            db.execute("INSERT OR IGNORE INTO users(email,name) VALUES(?,?)", (email,email.split("@")[0]))
            uid = db.execute("SELECT id FROM users WHERE email=?", (email,)).fetchone()[0]
            return self.json({"verified":True}, extra=(self.login(db, uid),))
        if not user:
            raise Rejected("Please sign in.",401)
        uid = user["id"]
        if not post:
            if action=="files":
                rows=db.execute("SELECT id,name,kind,size,tool,rows,created,expires FROM files WHERE uid=? ORDER BY created DESC",(uid,))
                return self.json([{**dict(r),"created":stamp(r["created"]),"expires":stamp(r["expires"])} for r in rows])
            if action=="settings":
                return self.json({"retentionDays":user["retention"]})
            if action.startswith("file/"):
                row=db.execute("SELECT name,body FROM files WHERE id=? AND uid=?",(action[5:],uid)).fetchone()
                if not row:
                    raise Rejected("File not found.",404)
                return self.reply(200,row["body"],"application/octet-stream",(("Content-Disposition","attachment; filename*=UTF-8''"+quote(row["name"],safe="")),))
        if post:
            if action=="logout":
                db.execute("DELETE FROM sessions WHERE token=?",(digest(self.cookie_value("epe_session")),))
                db.commit()
                return self.json({},extra=(self.cookie("epe_session","",0),))
            if action=="account-delete":
                db.execute("DELETE FROM users WHERE id=?",(uid,))
                db.commit()
                return self.json({},extra=(self.cookie("epe_session","",0),))
            if action=="files-delete-all":
                db.execute("DELETE FROM files WHERE uid=?", (uid,))
            elif action=="settings":
                days=json.loads(self.input(2048)).get("retentionDays")
                if type(days) is not int or days not in (0,30,90,365):
                    raise Rejected("Invalid retention setting.")
                db.execute("UPDATE users SET retention=? WHERE id=?",(days,uid))
            elif action.startswith("delete/"):
                db.execute("DELETE FROM files WHERE id=? AND uid=?",(action[7:],uid))
            elif action=="files":
                body=self.input(LIMIT)
                name=unquote(self.headers.get("X-File-Name",""))[:200]
                name=re.sub(r"[\x00-\x1f/\\]", "_", name)
                kind=self.headers.get("X-File-Kind","")
                if not name or kind not in KINDS or not body:
                    raise Rejected("Invalid export.")
                raw=self.headers.get("X-File-Rows","")
                row_count=int(raw) if raw.isascii() and raw.isdigit() and len(raw)<10 else None
                db.execute("BEGIN IMMEDIATE")
                count,total=db.execute("SELECT count(*),coalesce(sum(size),0) FROM files WHERE uid=?",(uid,)).fetchone()
                if count>=50 or total+len(body)>100*1024*1024:
                    raise Rejected("Storage limit reached.",413)
                fid=secrets.token_hex(16)
                now=int(time.time())
                expires=now+user["retention"]*86400 if user["retention"] else None
                db.execute("INSERT INTO files VALUES(?,?,?,?,?,?,?,?,?,?)",(fid,uid,name,kind,len(body),unquote(self.headers.get("X-File-Tool",""))[:80],row_count,now,expires,body))
                db.commit()
                return self.json({"id":fid},201)
            else:
                raise Rejected("Not found.",404)
            db.commit()
            return self.json({})
        raise Rejected("Not found.",404)

    def handle_request(self):
        path=unquote(urlsplit(self.path).path)
        if self.command=="POST" and (not path.startswith("/api/") or self.headers.get("Origin")!=ORIGIN):
            raise Rejected("Request origin denied.",403)
        with closing(database()) as db:
            if path.startswith(("/auth/","/api/","/dashboard")):
                self.clean(db)
                db.commit()
            user=self.user(db)
            if path in ("/auth/google","/auth/google/callback") and self.command=="GET":
                return self.google(db,path,parse_qs(urlsplit(self.path).query))
            if path.startswith("/api/"):
                return self.api(db,path,user)
            canonical = path.rstrip("/") + "/"
            if canonical in {p.removeprefix("/dashboard/tools") for p in TOOLS}:
                return self.redirect("/dashboard/tools"+canonical)
            if path=="/dashboard" or path.startswith("/dashboard/") or path.lstrip("/") in {"statement-ui.mjs","statement-model.mjs","statement-export.mjs","workspace.js","accounting-export.mjs","analysis-tools.mjs","remediation-tools.mjs"}:
                if not user:
                    return self.redirect("/login/?"+urlencode({"next":path}))
            candidate=(ROOT/path.lstrip("/")).resolve()
            if not candidate.is_relative_to(ROOT) or any(p.startswith(".") for p in candidate.relative_to(ROOT).parts):
                raise Rejected("Not found.",404)
            if candidate.is_dir():
                candidate=candidate/"index.html"
            if not candidate.is_file():
                raise Rejected("Not found.",404)
            mime="text/javascript" if candidate.suffix==".mjs" else mimetypes.guess_type(candidate.name)[0]
            self.reply(200,candidate.read_bytes(),mime or "application/octet-stream")

    def do_GET(self):
        try:
            self.handle_request()
        except Rejected as err:
            self.json({"error":err.message},err.status)
        except (ValueError, AttributeError, TypeError):
            self.json({"error":"Invalid request."},400)
        except (OSError, sqlite3.Error):
            self.json({"error":"The service is temporarily unavailable."},503)

    do_HEAD = do_GET
    do_POST = do_GET

if __name__=="__main__":
    SECRET=initialize()
    ThreadingHTTPServer(("0.0.0.0",8080),App).serve_forever()
