"""
piNail2 — Flask Web Application

Main entry point. Runs the Flask web server and initializes the PID controller.
Provides REST API endpoints and serves the single-page dashboard.

Usage:
    python3 app.py
    python3 app.py --config /path/to/config.json
"""

import sys
import os
import signal
import atexit
import logging
import argparse
import json
import time
from datetime import datetime

from flask import Flask, render_template, jsonify, request

from config import Config
from thermocouple import Thermocouple
from pid_controller import PIDController

# ---------------------------------------------------------------------------
# Logging setup
# ---------------------------------------------------------------------------
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
    handlers=[
        logging.StreamHandler(sys.stdout),
    ]
)
log = logging.getLogger("piNail2")
APP_INSTANCE_ID = str(int(time.time()))
APP_VERSION = "v2.1.0"

# ---------------------------------------------------------------------------
# Flask app
# ---------------------------------------------------------------------------
app = Flask(__name__)

# These are set in main() before the app starts
config = None       # type: Config
controller = None   # type: PIDController
tc = None           # type: Thermocouple

# ---------------------------------------------------------------------------
# Routes — Pages
# ---------------------------------------------------------------------------

@app.route("/")
def index():
    """Serve the main dashboard."""
    return render_template(
        "index.html",
        app_version=APP_VERSION,
        copyright_year=datetime.now().year,
    )


# ---------------------------------------------------------------------------
# Routes — API
# ---------------------------------------------------------------------------

@app.route("/api/status")
def api_status():
    """Return current controller state."""
    status = controller.status
    status["instance_id"] = APP_INSTANCE_ID
    status["thermocouple"] = tc.stats
    status["presets"] = config.get("presets")
    status["config"] = {
        "loop_size_ms": config.get("control", "loop_size_ms"),
        "sleep_time": config.get("control", "sleep_time"),
        "safety": config.get("safety"),
    }
    return jsonify(status)


@app.route("/api/heartbeat")
def api_heartbeat():
    """Lightweight health endpoint for frontend reconnect logic."""
    return jsonify({
        "ok": True,
        "instance_id": APP_INSTANCE_ID,
        "ts": time.time(),
        "controller_alive": controller.is_alive,
        "watchdog_ok": controller.watchdog_ok,
    })


@app.route("/api/history")
def api_history():
    """Return recent temperature history for charting."""
    since = request.args.get("since", 0, type=float)
    if since > 0:
        data = controller.get_history_since(since)
    else:
        data = controller.history
    return jsonify(data)


@app.route("/api/power", methods=["POST"])
def api_power():
    """Toggle controller on/off."""
    body = request.get_json(force=True, silent=True) or {}
    enable = body.get("enabled")

    if enable is None:
        # Toggle
        enable = not controller.status["enabled"]

    if enable:
        controller.start()
    else:
        controller.stop()

    return jsonify({"enabled": enable, "ok": True})


@app.route("/api/setpoint", methods=["POST"])
def api_setpoint():
    """Change the target temperature."""
    body = request.get_json(force=True, silent=True) or {}
    value = body.get("setpoint")
    if value is None:
        return jsonify({"error": "Missing 'setpoint' field"}), 400

    try:
        value = float(value)
    except (TypeError, ValueError):
        return jsonify({"error": "Invalid setpoint value"}), 400

    safety = config.get("safety")
    if value > safety["max_temp_f"]:
        return jsonify({"error": "Setpoint {} exceeds max {}F".format(value, safety['max_temp_f'])}), 400
    if value < safety["min_temp_f"]:
        return jsonify({"error": "Setpoint {} below min {}F".format(value, safety['min_temp_f'])}), 400

    controller.set_setpoint(value)
    return jsonify({"setpoint": value, "ok": True})


@app.route("/api/pid", methods=["POST"])
def api_pid():
    """Update PID tuning parameters."""
    body = request.get_json(force=True, silent=True) or {}

    kp = body.get("kP")
    ki = body.get("kI")
    kd = body.get("kD")
    p_on_m = body.get("proportional_on_measurement")
    p_mode = body.get("proportional_mode")

    if kp is None or ki is None or kd is None:
        return jsonify({"error": "Missing kP, kI, or kD"}), 400

    try:
        kp, ki, kd = float(kp), float(ki), float(kd)
    except (TypeError, ValueError):
        return jsonify({"error": "Invalid PID values"}), 400

    controller.set_pid_tuning(kp, ki, kd, p_on_m, p_mode)
    mode_out = "measurement" if controller.status["pid"]["proportional_on_measurement"] else "error"
    return jsonify({
        "kP": kp,
        "kI": ki,
        "kD": kd,
        "proportional_on_measurement": controller.status["pid"]["proportional_on_measurement"],
        "proportional_mode": mode_out,
        "ok": True,
    })


@app.route("/api/preset/<name>", methods=["POST"])
def api_preset(name):
    """Apply a named temperature preset."""
    presets = config.get("presets")
    if name not in presets:
        return jsonify({"error": "Unknown preset '{}'".format(name), "available": list(presets.keys())}), 404

    value = presets[name]
    controller.set_setpoint(value)
    return jsonify({"preset": name, "setpoint": value, "ok": True})


@app.route("/api/presets", methods=["GET"])
def api_presets():
    """List all presets."""
    return jsonify(config.get("presets"))


@app.route("/api/presets", methods=["POST"])
def api_presets_update():
    """Add or update a preset."""
    body = request.get_json(force=True, silent=True) or {}
    name = body.get("name")
    value = body.get("setpoint")
    if not name or value is None:
        return jsonify({"error": "Missing 'name' or 'setpoint'"}), 400
    try:
        value = float(value)
    except (TypeError, ValueError):
        return jsonify({"error": "Invalid setpoint value"}), 400

    presets = config.get("presets")
    presets[name] = value
    config.update_section("presets", presets)
    return jsonify({"ok": True, "presets": presets})


@app.route("/api/presets/<name>", methods=["DELETE"])
def api_preset_delete(name):
    """Delete a preset."""
    presets = config.get("presets")
    if name not in presets:
        return jsonify({"error": "Unknown preset '{}'".format(name)}), 404
    del presets[name]
    # Overwrite entire presets section
    config._data["presets"] = presets
    config.save()
    return jsonify({"ok": True, "presets": presets})


@app.route("/api/config", methods=["GET"])
def api_config():
    """Return full config (read-only view)."""
    return jsonify(config.data)


@app.route("/api/pid/reset", methods=["POST"])
def api_pid_reset():
    """Reset PID controller internals (clears integral windup)."""
    controller._pid.reset()
    return jsonify({"ok": True, "message": "PID reset"})


@app.route("/api/autotune", methods=["GET"])
def api_autotune_status():
    """Return current autotune state."""
    return jsonify(controller.autotune_status)


@app.route("/api/autotune/start", methods=["POST"])
def api_autotune_start():
    """Start relay-based PID autotune."""
    if not controller.status.get("enabled"):
        controller.start()
        time.sleep(0.2)
    body = request.get_json(force=True, silent=True) or {}
    setpoint = body.get("setpoint")
    hysteresis = body.get("hysteresis")
    cycles = body.get("cycles")
    controller.start_autotune(setpoint=setpoint, hysteresis=hysteresis, cycles=cycles)
    return jsonify({"ok": True, "autotune": controller.autotune_status})


@app.route("/api/autotune/stop", methods=["POST"])
def api_autotune_stop():
    """Stop PID autotune."""
    controller.stop_autotune("Autotune stopped by user")
    return jsonify({"ok": True, "autotune": controller.autotune_status})


@app.route("/api/safety/reset", methods=["POST"])
def api_safety_reset():
    """Reset safety trip (clears the safety flag so controller can be restarted)."""
    controller._safety_tripped = False
    controller._safety_reason = ""
    return jsonify({"ok": True})


# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------

def shutdown_handler(*args):
    """Handle SIGTERM/SIGINT gracefully."""
    log.info("Shutdown signal received")
    if controller:
        controller.cleanup()
    sys.exit(0)


def main():
    global config, controller, tc

    parser = argparse.ArgumentParser(description="piNail2 — E-Nail Temperature Controller")
    parser.add_argument("--config", default="config.json", help="Path to config file")
    args = parser.parse_args()

    # Load config
    config = Config(args.config)
    log.info("Configuration loaded from %s", args.config)

    # Initialize thermocouple
    gpio_cfg = config.get("gpio")
    safety_cfg = config.get("safety")
    tc = Thermocouple(
        clk=gpio_cfg["clk"],
        cs=gpio_cfg["cs"],
        do=gpio_cfg["do"],
        spike_threshold=safety_cfg["spike_threshold_f"]
    )

    # Initialize PID controller
    controller = PIDController(config, tc)

    # Register cleanup
    signal.signal(signal.SIGTERM, shutdown_handler)
    signal.signal(signal.SIGINT, shutdown_handler)
    atexit.register(controller.cleanup)

    # Start Flask
    web_cfg = config.get("web")
    log.info("Starting web server on %s:%d", web_cfg["host"], web_cfg["port"])
    app.run(
        host=web_cfg["host"],
        port=web_cfg["port"],
        debug=False,
        threaded=True
    )


if __name__ == "__main__":
    main()