"""RTAI Control Plane MVP: authenticated enrollment, lightweight check-ins, master dashboard.

MVP only: does not replace antivirus or offer remote control. Deploy behind HTTPS and
restrict the application listener to localhost. Single-process SQLite storage.
"""
from __future__ import annotations

import hashlib
import hmac
import os
import secrets
import sqlite3
import threading
import time
from contextlib import contextmanager
from datetime import datetime, timezone
from pathlib import Path
from typing import Any

from fastapi import Cookie, Depends, FastAPI, Header, HTTPException, Request, Response
from fastapi.responses import FileResponse
from pydantic import BaseModel, Field

BASE = Path(__file__).resolve().parent
DB_PATH = Path(os.environ.get("RTAI_DB_PATH", str(BASE / "data" / "rtai.db")))
ADMIN_PASSWORD = os.environ.get("RTAI_ADMIN_PASSWORD", "")
ENV = os.environ.get("RTAI_ENV", "development")
ONLINE_SECONDS = 150
SESSION_SECONDS = 8 * 60 * 60

app = FastAPI(title="RTAI API", version="0.1.0", docs_url=None, redoc_url=None, openapi_url=None)
_sessions: dict[str, tuple[float, str]] = {}
_auth_failures: dict[str, list[float]] = {}
_guard = threading.Lock()


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


def digest(secret: str) -> str:
    return hashlib.sha256(secret.encode("utf-8")).hexdigest()


@contextmanager
def db():
    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
    con = sqlite3.connect(DB_PATH, timeout=10)
    con.row_factory = sqlite3.Row
    con.execute("PRAGMA busy_timeout=10000")
    try:
        yield con
        con.commit()
    except Exception:
        con.rollback()
        raise
    finally:
        con.close()


@app.on_event("startup")
def setup():
    if len(ADMIN_PASSWORD) < 16:
        raise RuntimeError("Defina RTAI_ADMIN_PASSWORD com pelo menos 16 caracteres")
    with db() as con:
        con.execute("PRAGMA journal_mode=WAL")
        con.executescript("""
        CREATE TABLE IF NOT EXISTS enrollments (
            id TEXT PRIMARY KEY, customer TEXT NOT NULL, code_hash TEXT NOT NULL UNIQUE,
            expires_at INTEGER NOT NULL, used_at INTEGER
        );
        CREATE TABLE IF NOT EXISTS devices (
            id TEXT PRIMARY KEY, customer TEXT NOT NULL,
            token_hash TEXT NOT NULL UNIQUE, hostname TEXT NOT NULL,
            os TEXT NOT NULL, agent_version TEXT NOT NULL, last_seen INTEGER NOT NULL,
            rt_protection INTEGER, av_enabled INTEGER, signatures TEXT,
            signatures_date TEXT, enrolled_at INTEGER NOT NULL, revoked_at INTEGER
        );
        CREATE TABLE IF NOT EXISTS events (
            id INTEGER PRIMARY KEY AUTOINCREMENT, device_id TEXT NOT NULL,
            event_type TEXT NOT NULL, description TEXT NOT NULL, created_at INTEGER NOT NULL
        );
        CREATE INDEX IF NOT EXISTS idx_events_created ON events(created_at DESC);
        CREATE TABLE IF NOT EXISTS indicators (
            sha256 TEXT PRIMARY KEY, source TEXT NOT NULL,
            added_at INTEGER NOT NULL, revoked_at INTEGER
        );
        """)


def utc_timestamp(epoch: int | None) -> str | None:
    return datetime.fromtimestamp(epoch, timezone.utc).isoformat() if epoch is not None else None


def check_admin(session: str | None = Cookie(default=None, alias="rtai_session")) -> tuple[str, str]:
    if not session:
        raise HTTPException(401, "Sessão necessária")
    with _guard:
        record = _sessions.get(digest(session))
    if not record or record[0] < time.time():
        raise HTTPException(401, "Sessão expirada")
    return session, record[1]


def require_csrf(request: Request, x_rtai_csrf: str | None = Header(default=None)):
    _session, csrf = check_admin(request.cookies.get("rtai_session"))
    if not x_rtai_csrf or not hmac.compare_digest(x_rtai_csrf, csrf):
        raise HTTPException(403, "Proteção CSRF")
    return True


def check_agent(authorization: str | None = Header(default=None)) -> sqlite3.Row:
    if not authorization or not authorization.startswith("Bearer "):
        raise HTTPException(401, "Token do dispositivo necessário")
    token = authorization[7:]
    if len(token) < 30 or len(token) > 200:
        raise HTTPException(401, "Token inválido")
    with db() as con:
        row = con.execute("SELECT * FROM devices WHERE token_hash = ? AND revoked_at IS NULL", (digest(token),)).fetchone()
    if row is None:
        raise HTTPException(401, "Dispositivo não autorizado")
    return row


class LoginRequest(BaseModel):
    password: str


class EnrollmentRequest(BaseModel):
    customer: str = Field(min_length=2, max_length=100)


class DeviceEnrollRequest(BaseModel):
    code: str = Field(min_length=30, max_length=100)
    hostname: str = Field(min_length=1, max_length=100)
    os: str = Field(min_length=1, max_length=120)
    agent_version: str = Field(min_length=1, max_length=30)


class IndicatorRequest(BaseModel):
    sha256: str = Field(pattern=r"^[A-Fa-f0-9]{64}$")
    source: str = Field(min_length=2, max_length=100)


class CheckinRequest(BaseModel):
    hostname: str = Field(min_length=1, max_length=100)
    os: str = Field(min_length=1, max_length=120)
    agent_version: str = Field(min_length=1, max_length=30)
    rt_protection: bool | None = None
    av_enabled: bool | None = None
    signatures: str | None = Field(default=None, max_length=100)
    signatures_date: str | None = Field(default=None, max_length=100)


@app.middleware("http")
async def security_headers(request: Request, call_next):
    response = await call_next(request)
    response.headers["X-Content-Type-Options"] = "nosniff"
    response.headers["X-Frame-Options"] = "DENY"
    response.headers["Referrer-Policy"] = "no-referrer"
    response.headers["Content-Security-Policy"] = "default-src 'self'; connect-src 'self'; img-src 'self'; script-src 'self'; style-src 'self'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'"
    if request.url.path.startswith("/api/"):
        response.headers["Cache-Control"] = "no-store"
    if ENV == "production":
        response.headers["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains"
    return response


@app.get("/")
def dashboard():
    return FileResponse(BASE / "static" / "index.html")


@app.get("/static/{filename}")
def public_static(filename: str):
    if filename not in {"app.js", "style.css"}:
        raise HTTPException(404)
    return FileResponse(BASE / "static" / filename)


@app.get("/healthz")
def health():
    return {"status": "ok", "product": "RTAI"}


@app.post("/api/admin/login")
def admin_login(payload: LoginRequest, request: Request, response: Response):
    ip = request.client.host if request.client else "unknown"
    current = time.time()
    with _guard:
        recent = [t for t in _auth_failures.get(ip, []) if current - t < 900]
        _auth_failures[ip] = recent
        limited = len(recent) >= 5
    if limited:
        raise HTTPException(429, "Muitas tentativas. Tente mais tarde")
    if not hmac.compare_digest(digest(payload.password), digest(ADMIN_PASSWORD)):
        with _guard:
            _auth_failures[ip].append(current)
        raise HTTPException(401, "Credenciais inválidas")
    with _guard:
        _auth_failures.pop(ip, None)
    session = secrets.token_urlsafe(48)
    csrf = secrets.token_urlsafe(32)
    with _guard:
        _sessions[digest(session)] = (current + SESSION_SECONDS, csrf)
    response.set_cookie("rtai_session", session, httponly=True,
                        secure=(ENV == "production"), samesite="strict", max_age=SESSION_SECONDS,
                        path="/")
    response.headers["Cache-Control"] = "no-store"
    return {"logged_in": True, "csrf": csrf}


@app.post("/api/admin/logout", dependencies=[Depends(require_csrf)])
def admin_logout(response: Response, session=Depends(check_admin)):
    with _guard:
        _sessions.pop(digest(session[0]), None)
    response.delete_cookie("rtai_session", path="/")
    return {"logged_out": True}


@app.get("/api/admin/me")
def admin_me(session=Depends(check_admin)):
    return {"logged_in": True, "csrf": session[1]}


@app.get("/api/admin/devices")
def admin_devices(_=Depends(check_admin)):
    t = now()
    with db() as con:
        rows = con.execute("""SELECT id, customer, hostname, os, agent_version,
            last_seen, rt_protection, av_enabled, signatures, signatures_date, enrolled_at
            FROM devices WHERE revoked_at IS NULL ORDER BY customer, hostname""").fetchall()
    result = []
    for row in rows:
        obj = dict(row)
        obj["online"] = obj["last_seen"] >= t - ONLINE_SECONDS
        obj["last_seen"] = utc_timestamp(obj["last_seen"])
        obj["enrolled_at"] = utc_timestamp(obj["enrolled_at"])
        obj["rt_protection"] = None if obj["rt_protection"] is None else bool(obj["rt_protection"])
        obj["av_enabled"] = None if obj["av_enabled"] is None else bool(obj["av_enabled"])
        result.append(obj)
    return {"devices": result, "online_window_seconds": ONLINE_SECONDS}


@app.get("/api/admin/events")
def admin_events(_=Depends(check_admin)):
    with db() as con:
        rows = con.execute("""SELECT e.id, e.device_id, d.customer, d.hostname,
            e.event_type, e.description, e.created_at FROM events e
            JOIN devices d ON e.device_id=d.id ORDER BY e.id DESC LIMIT 50""").fetchall()
    return {"events": [{**dict(row), "created_at": utc_timestamp(row["created_at"])} for row in rows]}


@app.post("/api/admin/enrollments", dependencies=[Depends(require_csrf)])
def new_enrollment(payload: EnrollmentRequest, _=Depends(check_admin)):
    code = secrets.token_urlsafe(32)
    expires_at = now() + 15 * 60
    with db() as con:
        con.execute("""INSERT INTO enrollments (id, customer, code_hash, expires_at)
            VALUES (?, ?, ?, ?)""", (secrets.token_hex(16), payload.customer.strip(), digest(code), expires_at))
    return {"code": code, "expires_at": utc_timestamp(expires_at)}


@app.post("/api/agent/enroll")
def agent_enroll(payload: DeviceEnrollRequest):
    timestamp = now()
    device_id = secrets.token_hex(16)
    token = secrets.token_urlsafe(48)
    with db() as con:
        # The UPDATE is atomic: exactly one client may consume a code.
        enrollment = con.execute("""SELECT customer FROM enrollments WHERE code_hash=?
            AND used_at IS NULL AND expires_at>?""", (digest(payload.code), timestamp)).fetchone()
        if not enrollment:
            raise HTTPException(401, "Código inválido, expirado ou já utilizado")
        updated = con.execute("""UPDATE enrollments SET used_at=? WHERE code_hash=?
            AND used_at IS NULL AND expires_at>?""", (timestamp, digest(payload.code), timestamp)).rowcount
        if updated != 1:
            raise HTTPException(401, "Código já utilizado")
        con.execute("""INSERT INTO devices
            (id, customer, token_hash, hostname, os, agent_version, last_seen, enrolled_at)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
            (device_id, enrollment["customer"], digest(token), payload.hostname,
             payload.os, payload.agent_version, timestamp, timestamp))
    return {"device_id": device_id, "token": token, "interval_seconds": 60}


@app.post("/api/agent/checkin")
def agent_checkin(payload: CheckinRequest, device=Depends(check_agent)):
    with db() as con:
        prior = con.execute("SELECT rt_protection FROM devices WHERE id=?", (device["id"],)).fetchone()
        con.execute("""UPDATE devices SET hostname=?, os=?, agent_version=?, last_seen=?,
            rt_protection=?, av_enabled=?, signatures=?, signatures_date=? WHERE id=?""",
            (payload.hostname, payload.os, payload.agent_version, now(),
             payload.rt_protection, payload.av_enabled, payload.signatures,
             payload.signatures_date, device["id"]))
        if payload.rt_protection is False and prior["rt_protection"] != 0:
            con.execute("INSERT INTO events (device_id,event_type,description,created_at) VALUES (?,?,?,?)",
                        (device["id"], "security_warning", "Proteção em tempo real do Defender desativada", now()))
        elif payload.rt_protection is True and prior["rt_protection"] == 0:
            con.execute("INSERT INTO events (device_id,event_type,description,created_at) VALUES (?,?,?,?)",
                        (device["id"], "security_restored", "Proteção em tempo real do Defender restabelecida", now()))
    return {"ok": True, "interval_seconds": 60, "server_time": utc_timestamp(now())}


@app.post("/api/admin/devices/{device_id}/revoke", dependencies=[Depends(require_csrf)])
def revoke_device(device_id: str, _=Depends(check_admin)):
    with db() as con:
        updated = con.execute("UPDATE devices SET revoked_at=? WHERE id=? AND revoked_at IS NULL", (now(), device_id)).rowcount
    if not updated:
        raise HTTPException(404, "Dispositivo não encontrado")
    return {"revoked": True}


@app.get("/api/admin/indicators")
def admin_indicators(_=Depends(check_admin)):
    with db() as con:
        rows = con.execute("""SELECT sha256, source, added_at FROM indicators
            WHERE revoked_at IS NULL ORDER BY added_at DESC LIMIT 1000""").fetchall()
    return {"indicators": [{**dict(row), "added_at": utc_timestamp(row["added_at"])} for row in rows]}


@app.post("/api/admin/indicators", dependencies=[Depends(require_csrf)])
def admin_new_indicator(payload: IndicatorRequest, _=Depends(check_admin)):
    with db() as con:
        size = con.execute("SELECT COUNT(*) FROM indicators WHERE revoked_at IS NULL").fetchone()[0]
        exists = con.execute("SELECT sha256 FROM indicators WHERE sha256=? AND revoked_at IS NULL", (payload.sha256.lower(),)).fetchone()
        if size >= 5000 and not exists:
            raise HTTPException(409, "Limite do MVP: 5.000 indicadores ativos")
        con.execute("""INSERT INTO indicators (sha256, source, added_at, revoked_at)
            VALUES (?, ?, ?, NULL)
            ON CONFLICT(sha256) DO UPDATE SET source=excluded.source, added_at=excluded.added_at, revoked_at=NULL""",
            (payload.sha256.lower(), payload.source.strip(), now()))
    return {"saved": True}


@app.delete("/api/admin/indicators/{sha256}", dependencies=[Depends(require_csrf)])
def admin_remove_indicator(sha256: str, _=Depends(check_admin)):
    if len(sha256) != 64 or any(ch not in "0123456789abcdefABCDEF" for ch in sha256):
        raise HTTPException(422, "SHA-256 inválido")
    with db() as con:
        updated = con.execute("UPDATE indicators SET revoked_at=? WHERE sha256=? AND revoked_at IS NULL",
                              (now(), sha256.lower())).rowcount
    if updated == 0:
        raise HTTPException(404, "Indicador não encontrado")
    return {"removed": True}


@app.get("/api/agent/indicators")
def agent_indicators(device=Depends(check_agent)):
    # Data only: never send arbitrary code or executable commands to the agent.
    with db() as con:
        rows = con.execute("SELECT sha256 FROM indicators WHERE revoked_at IS NULL ORDER BY sha256 LIMIT 5000").fetchall()
    entries = [row["sha256"] for row in rows]
    version = hashlib.sha256("\n".join(entries).encode("ascii")).hexdigest()
    return {"schema": 1, "version": version, "sha256": entries,
            "note": "Feed informativo; scanning e bloqueios ainda não implementados no MVP"}
