import time
import threading
from datetime import datetime
from pathlib import Path

import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

from core.hardware import get_temperature


# MODE = "local" oder "web"
MODE = "local"

if MODE == "local":
    DATA_DIR = Path("~/devel/projects/course_temp_logger/data").expanduser()
elif MODE == "web":
    DATA_DIR = Path("/var/www/html/temp_curve").expanduser()
else:
    raise ValueError("MODE muss 'local' oder 'web' sein")


DATA_DIR.mkdir(parents=True, exist_ok=True)
DATA_FILE = DATA_DIR / "temperature.txt"
PLOT_FILE = DATA_DIR / "temperature.png"

INTERVAL = 5  # Sekunden (Auflösung / Messintervall)

running = False
thread_started = False
lock = threading.Lock()


def set_interval(seconds: int):
    global INTERVAL
    if seconds < 1:
        seconds = 1
    INTERVAL = seconds


def generate_plot():
    times = []
    temps = []

    if DATA_FILE.exists():
        with open(DATA_FILE, "r") as f:
            for line in f:
                parts = line.strip().split()
                if len(parts) == 2:
                    times.append(parts[0])
                    temps.append(float(parts[1]))

    plt.figure()
    plt.title("Temperaturverlauf")
    plt.xlabel("Zeit")
    plt.ylabel("Temperatur (°C)")

    if temps: 
       plt.plot(temps)

       step = max(1, len(times) // 10)
       plt.xticks(range(0, len(times), step),
               times[::step],
               rotation=45)   
    else:
        plt.text(
            0.5,
            0.5,
            "Keine Messdaten",
            ha="center",
            va="center",
            transform=plt.gca().transAxes,
        )

    plt.tight_layout()
    plt.savefig(PLOT_FILE)
    plt.close()


def worker():
    global running

    while True:
        with lock:
            active = running
            interval = INTERVAL

        if active:
            temp = get_temperature()
            if temp is not None:
                now = datetime.now().strftime("%H:%M:%S")

                with open(DATA_FILE, "a") as f:
                    f.write(f"{now} {temp}\n")

                generate_plot()

            time.sleep(interval)
        else:
            time.sleep(0.2)


def ensure_thread():
    global thread_started
    if not thread_started:
        t = threading.Thread(target=worker, daemon=True)
        t.start()
        thread_started = True


def start():
    ensure_thread()
    global running
    with lock:
        running = True


def stop():
    global running
    with lock:
        running = False


def reset():
    stop()
    DATA_FILE.write_text("")
    generate_plot()