import network, socket, time, machine, onewire, ds18x20, json
from secrets import secrets

# --- 1. POWER STABILIZATION ---
led = machine.Pin("LED", machine.Pin.OUT)
led.off()
time.sleep(5)  # Give the 5V adapter 5 seconds to settle

# --- 2. HEATER FIRST, FORCED OFF ---
HEATER_PIN = 15
heater_pin = machine.Pin(HEATER_PIN, machine.Pin.OUT)
heater_pin.low()

# --- 3. SETTINGS ---
termostat = 18.5
HYST = 0.3                 # heater ON below (termostat - HYST), OFF at termostat
READ_INTERVAL_MS = 1000    # how often the control loop reads the sensor
WIFI_RETRY_MS = 3000      # how often to retry WiFi when disconnected

SENSOR_MAP = {
    'fierbator': '28833c949704036c',
}

# Shared state: updated by the control loop, served by HTTP
state = {"fierbator": None, "heater": "oprit", "termostat": termostat}

# --- 4. WIFI (non-blocking after startup) ---
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.config(pm=0xa11140)

def start_wifi():
    print("Connecting WiFi...")
    try:
        wlan.connect(secrets['ssid'], secrets['password'])
    except OSError:
        pass

start_wifi()
t0 = time.ticks_ms()
while not wlan.isconnected() and time.ticks_diff(time.ticks_ms(), t0) < 15000:
    led.toggle()
    time.sleep(0.5)
led.on() if wlan.isconnected() else led.off()
print("WiFi ready" if wlan.isconnected() else "WiFi not yet connected, continuing anyway")

last_wifi_try = time.ticks_ms()
wifi_fail_count = 0

def wifi_step():
    """Called every loop. Never blocks; retries in the background."""
    global last_wifi_try, wifi_fail_count
    if wlan.isconnected():
        wifi_fail_count = 0
        return
    now = time.ticks_ms()
    if time.ticks_diff(now, last_wifi_try) < WIFI_RETRY_MS:
        return
    last_wifi_try = now
    wifi_fail_count += 1
    if wifi_fail_count % 3 == 0:  # every ~30s, hard reset the radio
        wlan.active(False)
        time.sleep_ms(200)
        wlan.active(True)
        wlan.config(pm=0xa11140)
    start_wifi()

# --- 5. SENSOR + THERMOSTAT (runs on its own, no HTTP needed) ---
ds_sensor = ds18x20.DS18X20(onewire.OneWire(machine.Pin(22)))

converting = False
t_convert = 0
t_last_read = time.ticks_add(time.ticks_ms(), -READ_INTERVAL_MS)

def heater_off():
    heater_pin.low()
    state["heater"] = "oprit"

def heater_on():
    heater_pin.high()
    state["heater"] = "pornit"

def control_step():
    """Non-blocking: start a conversion, come back 750 ms later to read it."""
    global converting, t_convert, t_last_read
    now = time.ticks_ms()

    if not converting:
        if time.ticks_diff(now, t_last_read) >= READ_INTERVAL_MS:
            try:
                ds_sensor.convert_temp()
                converting = True
                t_convert = now
            except Exception:
                state.pop("fierbator", None)
                state["error"] = "Sensor Bus Busy"
                heater_off()
                t_last_read = now
        return

    if time.ticks_diff(now, t_convert) < 750:
        return

    converting = False
    t_last_read = now
    try:
        roms = ds_sensor.scan()
        found = {''.join(['%02x' % b for b in rom]): rom for rom in roms}
        state.pop("error", None)
        state["termostat"] = termostat

        for name, hex_id in SENSOR_MAP.items():
            if hex_id not in found:
                state[name] = "offline"
                heater_off()
                continue

            t = ds_sensor.read_temp(found[hex_id])
            if t is None or t == 85.0:  # 85.0 = DS18B20 power-on/failed read
                state[name] = "eroare citire"
                heater_off()
                continue

            temp_val = int(t * 10) / 10.0
            state[name] = temp_val

            if temp_val < termostat - HYST:
                heater_on()
            elif temp_val >= termostat:
                heater_off()
            # in between: keep current state (hysteresis)
    except Exception:
        state.pop("fierbator", None)
        state["error"] = "Sensor Bus Busy"
        heater_off()

# --- 6. SERVER (only reports state, never controls the heater) ---
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(('0.0.0.0', 80))
s.listen(5)
s.settimeout(0.1)  # short, so the control loop keeps running

def http_step():
    try:
        conn, addr = s.accept()
    except OSError:
        return
    try:
        conn.settimeout(2)
        led.off()
        request = str(conn.recv(1024))

        if "/reboot" in request:
            heater_off()
            conn.send('HTTP/1.1 200 OK\r\n\r\nRebooting...')
            conn.close()
            time.sleep(1)
            machine.reset()

        conn.send('HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n')
        conn.send(json.dumps(state))
    except Exception:
        pass
    finally:
        try:
            conn.close()
        except Exception:
            pass
        led.on() if wlan.isconnected() else led.off()

# --- 7. MAIN LOOP ---
while True:
    control_step()
    wifi_step()
    http_step()