app.py

#!/usr/bin/env python3
"""
SecureX Web v2.0 — Main Server
Flask + SocketIO + YOLOv8 multi-camera security dashboard.
"""

import os, sys, time, threading, json
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from flask import Flask, render_template, request, redirect, url_for, session, Response, jsonify
from flask_socketio import SocketIO, emit
from utils.config_loader import load_config
from utils.user_db import UserDB
from utils.event_logger import EventLogger
from core.camera_manager import CameraManager
from core.detection_engine import DetectionEngine
from alerts.telegram_alerter import TelegramAlerter

# ── Init ──────────────────────────────────────────────
config = load_config()
app = Flask(__name__)
app.secret_key = config["server"]["secret_key"]
socketio = SocketIO(app, async_mode="eventlet", cors_allowed_origins="*")

db = UserDB()
logger = EventLogger()
cam_mgr = CameraManager()
alerter = TelegramAlerter(config)

print("  Loading YOLOv8...")
detector = DetectionEngine(config)
print("  [OK] All systems ready.\n")

# ── Detection Loop (background thread) ───────────────
detection_running = False

def detection_loop():
    global detection_running
    detection_running = True
    while detection_running:
        for stream in cam_mgr.get_all():
            if not stream.alive:
                continue
            frame = stream.read()
            if frame is None:
                continue

            ann, dets, alerts = detector.process(
                frame, stream.name, stream.zone, stream.user_email
            )
            stream.set_annotated(ann)
            stream.detection_count = len(dets)

            for alert in alerts:
                print(f"  🔴 {alert.reason} — {alert.camera_name}")
                logger.log_alert(alert.camera_name, alert.zone, alert.reason,
                                 alert.detections, alert.user_email)

                # Send telegram to the camera owner
                chat_id = db.get_chat_id_for_user(alert.user_email)
                if chat_id:
                    alerter.send_alert(chat_id, alert.camera_name, alert.zone,
                                       alert.reason, alert.frame, alert.detections)

                # Push to web dashboard via socketio
                socketio.emit("alert", alert.to_dict(), namespace="/live")

        time.sleep(0.02)


# ── Auth Routes ───────────────────────────────────────

@app.route("/")
def index():
    if "user_email" in session:
        return redirect(url_for("dashboard"))
    return render_template("index.html")


@app.route("/signup", methods=["GET", "POST"])
def signup():
    if request.method == "POST":
        email = request.form.get("email", "").strip().lower()
        telegram = request.form.get("telegram", "").strip()

        if not email or "@" not in email:
            return render_template("signup.html", error="Enter a valid email.")

        if db.user_exists(email):
            return render_template("signup.html", error="Email already registered. Log in instead.")

        user = db.create_user(email, telegram)

        # Try to resolve their telegram chat_id
        if telegram:
            chat_id = alerter.resolve_chat_id(telegram)
            if chat_id:
                db.set_telegram(email, telegram, chat_id)

        session["user_email"] = email
        return redirect(url_for("dashboard"))

    return render_template("signup.html")


@app.route("/login", methods=["GET", "POST"])
def login():
    if request.method == "POST":
        email = request.form.get("email", "").strip().lower()
        if not email:
            return render_template("login.html", error="Enter your email.")

        user = db.get_user(email)
        if not user:
            return render_template("login.html", error="No account found. Sign up first.")

        session["user_email"] = email
        return redirect(url_for("dashboard"))

    return render_template("login.html")


@app.route("/logout")
def logout():
    session.pop("user_email", None)
    return redirect(url_for("index"))


# ── Dashboard ─────────────────────────────────────────

@app.route("/dashboard")
def dashboard():
    if "user_email" not in session:
        return redirect(url_for("login"))
    email = session["user_email"]
    user = db.get_user(email)
    cameras = cam_mgr.get_status(email)
    alerts = logger.get_recent(20)
    return render_template("dashboard.html", user=user, cameras=cameras, alerts=alerts)


# ── Camera API ────────────────────────────────────────

@app.route("/api/cameras", methods=["GET"])
def api_cameras():
    if "user_email" not in session:
        return jsonify({"error": "Not logged in"}), 401
    return jsonify(cam_mgr.get_status(session["user_email"]))


@app.route("/api/cameras/add", methods=["POST"])
def api_add_camera():
    if "user_email" not in session:
        return jsonify({"error": "Not logged in"}), 401

    email = session["user_email"]
    data = request.json or request.form
    name = data.get("name", "My Camera")
    source = data.get("source", "0")
    zone = data.get("zone", "default")

    result = cam_mgr.add_camera(name, source, zone, email)
    if result["alive"]:
        db.add_camera(email, {"name": name, "source": str(source), "zone": zone, "cam_id": result["cam_id"]})
        logger.log_system(f"Camera added: {name}", email)
    return jsonify(result)


@app.route("/api/cameras/remove", methods=["POST"])
def api_remove_camera():
    if "user_email" not in session:
        return jsonify({"error": "Not logged in"}), 401

    data = request.json or request.form
    cam_id = data.get("cam_id")
    if cam_mgr.remove_camera(cam_id):
        db.remove_camera(session["user_email"], cam_id)
        return jsonify({"ok": True})
    return jsonify({"error": "Camera not found"}), 404


# ── Video Stream (MJPEG) ─────────────────────────────

@app.route("/video/<cam_id>")
def video_feed(cam_id):
    """MJPEG stream endpoint for a single camera."""
    def generate():
        while True:
            stream = cam_mgr.get_stream(cam_id)
            if stream is None:
                break
            jpeg = stream.get_jpeg(quality=65)
            if jpeg:
                yield (b'--frame\r\n'
                       b'Content-Type: image/jpeg\r\n\r\n' + jpeg + b'\r\n')
            time.sleep(0.05)  # ~20fps

    return Response(generate(), mimetype='multipart/x-mixed-replace; boundary=frame')


# ── Telegram Setup ────────────────────────────────────

@app.route("/api/telegram/setup", methods=["POST"])
def api_telegram_setup():
    """User provides telegram username, we try to resolve their chat_id."""
    if "user_email" not in session:
        return jsonify({"error": "Not logged in"}), 401

    data = request.json or request.form
    username = data.get("telegram_username", "").strip()
    if not username:
        return jsonify({"error": "Provide a telegram username"}), 400

    email = session["user_email"]
    db.set_telegram(email, username)

    # Try resolving chat_id
    chat_id = alerter.resolve_chat_id(username)
    if chat_id:
        db.set_telegram(email, username, chat_id)
        return jsonify({"ok": True, "chat_id": chat_id,
                        "message": "Connected! You'll receive alerts on Telegram."})
    else:
        return jsonify({"ok": False,
                        "message": f"Couldn't find your chat. Send any message to the bot first, then try again."})


@app.route("/api/alerts", methods=["GET"])
def api_alerts():
    if "user_email" not in session:
        return jsonify({"error": "Not logged in"}), 401
    return jsonify(logger.get_recent(30))


# ── SocketIO Events ───────────────────────────────────

@socketio.on("connect", namespace="/live")
def on_connect():
    print(f"  [WS] Client connected")


@socketio.on("request_frames", namespace="/live")
def on_request_frames():
    """Client requests current frames for their cameras."""
    email = session.get("user_email", "")
    streams = cam_mgr.get_user_streams(email)
    frames = {}
    for s in streams:
        b64 = s.get_base64(quality=50)
        if b64:
            frames[s.cam_id] = {"image": b64, "name": s.name,
                                "fps": round(s.fps, 1), "dets": s.detection_count}
    emit("frames", frames)


# ── Startup ───────────────────────────────────────────

def start_detection_thread():
    t = threading.Thread(target=detection_loop, daemon=True, name="detector")
    t.start()
    print("  [OK] Detection loop started")


if __name__ == "__main__":
    print("\n  ╔═══════════════════════════════════╗")
    print("  ║     SecureX Web v2.0              ║")
    print("  ╚═══════════════════════════════════╝\n")

    start_detection_thread()
    logger.log_system("Server started")

    host = config["server"]["host"]
    port = config["server"]["port"]
    print(f"  🌐 Dashboard: http://localhost:{port}\n")

    socketio.run(app, host=host, port=port, debug=False, use_reloader=False)