"""Settings management routes."""

from __future__ import annotations

import contextlib
import os
import re
import subprocess
import sys
import threading
from pathlib import Path

from flask import Blueprint, Response, jsonify, request

from utils.database import (
    delete_setting,
    get_all_settings,
    get_correlations,
    get_setting,
    set_setting,
)
from utils.logging import get_logger
from utils.responses import api_error, api_success
from utils.validation import validate_latitude, validate_longitude

logger = get_logger("intercept.settings")

settings_bp = Blueprint("settings", __name__, url_prefix="/settings")
_env_lock = threading.Lock()


def _get_env_file_path() -> Path:
    """Return the project .env path."""
    return Path(__file__).resolve().parent.parent / ".env"


def _write_env_value(key: str, value: str, env_path: Path | None = None) -> None:
    """Create or update a single key in the project .env file."""
    path = env_path or _get_env_file_path()
    path.parent.mkdir(parents=True, exist_ok=True)

    with _env_lock:
        lines = (
            path.read_text().splitlines()
            if path.exists()
            else [
                "# INTERCEPT environment configuration",
                "",
            ]
        )

        pattern = re.compile(rf"^\s*{re.escape(key)}=")
        updated = False
        new_lines: list[str] = []
        for line in lines:
            if pattern.match(line):
                if not updated:
                    new_lines.append(f"{key}={value}")
                    updated = True
                continue
            new_lines.append(line)

        if not updated:
            if new_lines and new_lines[-1] != "":
                new_lines.append("")
            new_lines.append(f"{key}={value}")

        path.write_text("\n".join(new_lines).rstrip("\n") + "\n")

        sudo_uid = os.environ.get("INTERCEPT_SUDO_UID")
        sudo_gid = os.environ.get("INTERCEPT_SUDO_GID")
        if os.geteuid() == 0 and sudo_uid and sudo_gid:
            with contextlib.suppress(OSError, ValueError):
                os.chown(path, int(sudo_uid), int(sudo_gid))


def _apply_runtime_observer_defaults(lat: float, lon: float) -> None:
    """Update in-process defaults so refreshed pages use the saved location."""
    lat_str = str(lat)
    lon_str = str(lon)
    os.environ["INTERCEPT_DEFAULT_LAT"] = lat_str
    os.environ["INTERCEPT_DEFAULT_LON"] = lon_str

    import config

    config.DEFAULT_LATITUDE = lat
    config.DEFAULT_LONGITUDE = lon

    with contextlib.suppress(Exception):
        import app as app_module

        app_module.DEFAULT_LATITUDE = lat
        app_module.DEFAULT_LONGITUDE = lon

    with contextlib.suppress(Exception):
        from routes import adsb as adsb_routes

        adsb_routes.DEFAULT_LATITUDE = lat
        adsb_routes.DEFAULT_LONGITUDE = lon

    with contextlib.suppress(Exception):
        from routes import ais as ais_routes

        ais_routes.DEFAULT_LATITUDE = lat
        ais_routes.DEFAULT_LONGITUDE = lon


@settings_bp.route("", methods=["GET"])
def get_settings() -> Response:
    """Get all settings."""
    try:
        settings = get_all_settings()
        return api_success(data={"settings": settings})
    except Exception as e:
        logger.error(f"Error getting settings: {e}")
        return api_error(str(e), 500)


@settings_bp.route("", methods=["POST"])
def save_settings() -> Response:
    """Save one or more settings."""
    data = request.json or {}

    if not data:
        return api_error("No settings provided", 400)

    try:
        saved = []
        for key, value in data.items():
            # Validate key (alphanumeric, underscores, dots, hyphens)
            if not key or not all(c.isalnum() or c in "_.-" for c in key):
                continue

            set_setting(key, value)
            saved.append(key)

        return api_success(data={"saved": saved})
    except Exception as e:
        logger.error(f"Error saving settings: {e}")
        return api_error(str(e), 500)


@settings_bp.route("/<key>", methods=["GET"])
def get_single_setting(key: str) -> Response:
    """Get a single setting by key."""
    try:
        value = get_setting(key)
        if value is None:
            return jsonify({"status": "not_found", "key": key}), 404

        return api_success(data={"key": key, "value": value})
    except Exception as e:
        logger.error(f"Error getting setting {key}: {e}")
        return api_error(str(e), 500)


@settings_bp.route("/<key>", methods=["PUT"])
def update_single_setting(key: str) -> Response:
    """Update a single setting."""
    data = request.json or {}
    value = data.get("value")

    if value is None and "value" not in data:
        return api_error("Value is required", 400)

    try:
        set_setting(key, value)
        return api_success(data={"key": key, "value": value})
    except Exception as e:
        logger.error(f"Error updating setting {key}: {e}")
        return api_error(str(e), 500)


@settings_bp.route("/<key>", methods=["DELETE"])
def delete_single_setting(key: str) -> Response:
    """Delete a setting."""
    try:
        deleted = delete_setting(key)
        if deleted:
            return api_success(data={"key": key, "deleted": True})
        else:
            return jsonify({"status": "not_found", "key": key}), 404
    except Exception as e:
        logger.error(f"Error deleting setting {key}: {e}")
        return api_error(str(e), 500)


@settings_bp.route("/observer-location", methods=["POST"])
def save_observer_location() -> Response:
    """Persist observer location to .env and refresh in-process defaults."""
    data = request.json or {}

    try:
        lat = validate_latitude(data.get("lat"))
        lon = validate_longitude(data.get("lon"))
    except ValueError as exc:
        return api_error(str(exc), 400)

    try:
        _write_env_value("INTERCEPT_DEFAULT_LAT", str(lat))
        _write_env_value("INTERCEPT_DEFAULT_LON", str(lon))
        _apply_runtime_observer_defaults(lat, lon)
        return api_success(
            data={
                "lat": lat,
                "lon": lon,
                "saved": ["INTERCEPT_DEFAULT_LAT", "INTERCEPT_DEFAULT_LON"],
            },
            message="Observer location saved to .env",
        )
    except Exception as exc:
        logger.error(f"Error saving observer location to .env: {exc}")
        return api_error(str(exc), 500)


# =============================================================================
# Device Correlation Endpoints
# =============================================================================


@settings_bp.route("/correlations", methods=["GET"])
def get_device_correlations() -> Response:
    """Get device correlations between WiFi and Bluetooth."""
    min_confidence = request.args.get("min_confidence", 0.5, type=float)

    try:
        correlations = get_correlations(min_confidence)
        return api_success(data={"correlations": correlations})
    except Exception as e:
        logger.error(f"Error getting correlations: {e}")
        return api_error(str(e), 500)


# =============================================================================
# RTL-SDR DVB Driver Management
# =============================================================================

DVB_MODULES = ["dvb_usb_rtl28xxu", "rtl2832_sdr", "rtl2832", "rtl2830", "r820t"]
BLACKLIST_FILE = "/etc/modprobe.d/blacklist-rtlsdr.conf"


@settings_bp.route("/rtlsdr/driver-status", methods=["GET"])
def check_dvb_driver_status() -> Response:
    """Check if DVB kernel drivers are loaded and blocking RTL-SDR devices."""
    if sys.platform != "linux":
        return jsonify(
            {
                "status": "success",
                "platform": sys.platform,
                "issue_detected": False,
                "message": "DVB driver conflict only affects Linux systems",
            }
        )

    # Check which DVB modules are currently loaded
    loaded_modules = []
    try:
        result = subprocess.run(["lsmod"], capture_output=True, text=True, timeout=5)
        lsmod_output = result.stdout
        for mod in DVB_MODULES:
            if mod in lsmod_output:
                loaded_modules.append(mod)
    except Exception as e:
        logger.warning(f"Could not check loaded modules: {e}")

    # Check if blacklist file exists
    blacklist_exists = os.path.exists(BLACKLIST_FILE)

    # Check blacklist file contents
    blacklist_contents = []
    if blacklist_exists:
        try:
            with open(BLACKLIST_FILE) as f:
                blacklist_contents = [line.strip() for line in f if line.strip() and not line.startswith("#")]
        except Exception:
            pass

    issue_detected = len(loaded_modules) > 0

    return jsonify(
        {
            "status": "success",
            "platform": "linux",
            "issue_detected": issue_detected,
            "loaded_modules": loaded_modules,
            "blacklist_file_exists": blacklist_exists,
            "blacklist_contents": blacklist_contents,
            "message": "DVB drivers are claiming RTL-SDR devices"
            if issue_detected
            else "No DVB driver conflict detected",
        }
    )


@settings_bp.route("/rtlsdr/blacklist-drivers", methods=["POST"])
def blacklist_dvb_drivers() -> Response:
    """Blacklist DVB kernel drivers to prevent them from claiming RTL-SDR devices."""
    if sys.platform != "linux":
        return api_error("This feature is only available on Linux", 400)

    # Check if we have permission (need to be running as root or with sudo)
    if os.geteuid() != 0:
        return api_error(
            "Root privileges required. Run the app with sudo or manually run: sudo modprobe -r dvb_usb_rtl28xxu rtl2832_sdr rtl2832 r820t",
            403,
        )

    errors = []
    successes = []

    # Create blacklist file if it doesn't exist
    if not os.path.exists(BLACKLIST_FILE):
        try:
            blacklist_content = """# RTL-SDR blacklist - prevents DVB drivers from claiming RTL-SDR devices
# Created by INTERCEPT
blacklist dvb_usb_rtl28xxu
blacklist rtl2832
blacklist rtl2830
blacklist r820t
"""
            with open(BLACKLIST_FILE, "w") as f:
                f.write(blacklist_content)
            successes.append(f"Created {BLACKLIST_FILE}")
        except Exception as e:
            errors.append(f"Failed to create blacklist file: {e}")

    # Unload the modules
    for mod in DVB_MODULES:
        try:
            result = subprocess.run(["modprobe", "-r", mod], capture_output=True, text=True, timeout=10)
            if result.returncode == 0:
                successes.append(f"Unloaded module: {mod}")
            # returncode != 0 is OK - module might not be loaded
        except Exception as e:
            logger.warning(f"Could not unload {mod}: {e}")

    if errors:
        return jsonify(
            {
                "status": "partial",
                "message": "Some operations failed. Please unplug and replug your RTL-SDR device.",
                "successes": successes,
                "errors": errors,
            }
        )

    return jsonify(
        {
            "status": "success",
            "message": "DVB drivers blacklisted. Please unplug and replug your RTL-SDR device.",
            "successes": successes,
        }
    )