import machine
import time
from machine import I2C, Pin
from ds1307 import DS1307
from ssd1306 import SSD1306_I2C
from writer import Writer
import freesansbold24
import network  # Pour la gestion du Wi-Fi
from rotary_irq_rp2 import RotaryIRQ

# Initialisation de l'I2C
i2c = I2C(0, scl=Pin(1), sda=Pin(0), freq=400000)

# Initialisation de l'écran OLED
oled = SSD1306_I2C(128, 64, i2c)

# Initialisation du module RTC DS1307
rtc = DS1307(i2c)

# Writer pour les grandes polices
wri_large = Writer(oled, freesansbold24)

# Configuration de l'encodeur rotatif avec la bibliothèque Rotary
rotary = RotaryIRQ(pin_num_clk=2, pin_num_dt=3, min_val=0, max_val=59, reverse=False, range_mode=RotaryIRQ.RANGE_WRAP)

# Détection du bouton poussoir de l'encodeur
sw = Pin(4, Pin.IN, Pin.PULL_UP)

# Variables de menu
menu_active = False
menu_options = ["1 - Heure", "2 - Wi-Fi", "3 - Contraste", "4 - Langue"]
menu_index = 0
setting_mode = None

# Configuration correcte du rotary pour le menu
rotary.set(min_val=0, max_val=len(menu_options) - 1)

# Variables pour le réglage Wi-Fi
wifi_networks = []
selected_network_index = 0
wifi_password = ""
password_input_mode = False  # Active ou désactive l'entrée du mot de passe

# Variables pour le réglage de l'heure
adjusting_hour = True  # True pour régler l'heure, False pour régler les minutes
current_hour = 0
current_minute = 0

# Scanning Wi-Fi
def scan_wifi_networks():
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    networks = wlan.scan()  # Retourne une liste de tuples (ssid, ... , ... , ...)
    return [network[0].decode('utf-8') for network in networks]

def display_wifi_menu():
    global selected_network_index, wifi_networks

    oled.fill(0)
    oled.text("Selection Wi-Fi", 0, 0)
    
    # Afficher les réseaux Wi-Fi scannés
    for i, network in enumerate(wifi_networks):
        prefix = ">" if i == selected_network_index else " "
        oled.text(f"{prefix} {network}", 0, 10 + i * 10)

    oled.show()

def enter_wifi_password():
    global wifi_password, password_input_mode

    oled.fill(0)
    oled.text(f"Mot de passe:", 0, 0)
    oled.text(f"{wifi_password}", 0, 20)
    oled.show()

# Clavier virtuel pour entrer le mot de passe
def virtual_keyboard():
    charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
    return charset

# Fonction pour afficher l'heure actuelle sur l'écran OLED
def display_time():
    # Lecture de l'heure actuelle
    now = rtc.datetime()
    hour = now[4]
    minute = now[5]

    # Formatage de l'heure
    time_str = f'{hour:02d}:{minute:02d}'

    # Effacer l'écran
    oled.fill(0)

    # Afficher l'heure centrée
    wri_large.set_textpos(oled, 15, 10)
    wri_large.printstring(time_str)

    # Mettre à jour l'écran
    oled.show()

# Fonction pour afficher le menu principal
def display_menu():
    oled.fill(0)
    oled.text("Parametres", 0, 0)
    
    for i, option in enumerate(menu_options):
        prefix = ">" if i == menu_index else " "
        oled.text(f"{prefix} {option}", 0, 10 + i * 10)
    
    oled.show()

# Affichage de l'interface pour le réglage de l'heure
def display_time_setting():
    global adjusting_hour, current_hour, current_minute

    oled.fill(0)
    oled.text("Reglage de l'heure", 0, 0)

    if adjusting_hour:
        oled.text(f"-Heure: [{current_hour:02d}]", 10, 20)  # Mettre en surbrillance l'heure
        oled.text(f"-Minutes: {current_minute:02d}", 10, 40)
    else:
        oled.text(f"-Heure: {current_hour:02d}", 10, 20)
        oled.text(f"-Minutes: [{current_minute:02d}]", 10, 40)  # Mettre en surbrillance les minutes

    oled.show()

# Fonction pour enregistrer l'heure dans le module RTC
def save_time():
    now = list(rtc.datetime())
    now[4] = current_hour
    now[5] = current_minute
    rtc.datetime(tuple(now))

# Fonction pour ajuster les réglages
def adjust_setting():
    global setting_mode, selected_network_index, wifi_networks, adjusting_hour, current_hour, current_minute

    selected_option = menu_options[menu_index]

    if selected_option == menu_options[1]:
        # Entrer dans le mode de réglage du Wi-Fi
        setting_mode = "wifi"
        wifi_networks = scan_wifi_networks()  # Scanner les réseaux Wi-Fi
        selected_network_index = 0
        if len(wifi_networks) > 0:
            rotary.set(min_val=0, max_val=len(wifi_networks) - 1)  # L'encodeur permet de naviguer entre les réseaux
        display_wifi_menu()
    
    elif selected_option == menu_options[0]:
        # Entrer dans le mode de réglage de l'heure
        setting_mode = "time"
        adjusting_hour = True  # Commencer par régler les heures
        current_hour = rtc.datetime()[4]
        current_minute = rtc.datetime()[5]
        rotary.set(min_val=0, max_val=23)  # L'encodeur rotatif est configuré pour régler les heures
        display_time_setting()

# Connexion au Wi-Fi
def connect_to_wifi(ssid, password):
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.connect(ssid, password)
    print(f"{password}")

    oled.fill(0)
    oled.text(f"Connexion à", 0, 10)
    oled.text(f"{ssid}...", 0, 30)
    oled.show()

    # Attendre la connexion
    timeout = 10  # 10 secondes de tentative
    while timeout > 0:
        if wlan.isconnected():
            oled.fill(0)
            oled.text(f"Connecté à", 0, 10)
            oled.text(f"{ssid}", 0, 30)
            oled.show()
            time.sleep(2)
            return True
        time.sleep(1)
        timeout -= 1
    
    oled.fill(0)
    oled.text(f"Echec de", 0, 10)
    oled.text(f"connexion", 0, 30)
    oled.show()
    time.sleep(2)
    return False

# Interruption pour le bouton de l'encodeur
def sw_pressed(pin):
    global menu_active, menu_index, setting_mode, adjusting_hour, password_input_mode, wifi_password
    
    time.sleep_ms(50)  # Anti-rebond
    rotary.set(value=0, min_val=0, max_val=len(menu_options) - 1)
    if sw.value() == 0:
        if setting_mode == "time":
            # Basculer entre réglage de l'heure et des minutes
            if adjusting_hour:
                adjusting_hour = False
                rotary.set(min_val=0, max_val=59)  # Réglage des minutes
            else:
                save_time()  # Sauvegarder l'heure et quitter le réglage
                setting_mode = None
                menu_active = False  # Retour à l'affichage de l'heure
        elif setting_mode == "wifi":
            if password_input_mode:
                # Basculer vers la connexion Wi-Fi une fois le mot de passe entré
                connect_to_wifi(wifi_networks[selected_network_index], wifi_password)
                setting_mode = None
                password_input_mode = False
                menu_active = False  # Retour à l'affichage de l'heure
            else:
                # Activer l'entrée du mot de passe
                password_input_mode = True
                wifi_password = ""
                rotary.set(min_val=0, max_val=len(virtual_keyboard()) - 1)  # Encodeur pour parcourir les caractères
                enter_wifi_password()
        elif menu_active:
            adjust_setting()
        else:
            menu_active = True
            menu_index = 0
            display_menu()

sw = Pin(4, Pin.IN, Pin.PULL_UP)
sw.irq(trigger=Pin.IRQ_FALLING, handler=sw_pressed)

# Boucle principale
last_val = rotary.value()  # Dernière valeur lue de l'encodeur
while True:
    if setting_mode == "time":
        val = rotary.value()
        if adjusting_hour:
            if val != current_hour:
                current_hour = val
                display_time_setting()
        else:
            if val != current_minute:
                current_minute = val
                display_time_setting()

    elif setting_mode == "wifi":
        if password_input_mode:
            # Entrer le mot de passe Wi-Fi caractère par caractère
            val = rotary.value()
            if len(wifi_password) < 32:  # Limite de taille du mot de passe
                char = virtual_keyboard()[val]
                wifi_password += char
                enter_wifi_password()
        else:
            # Navigation dans la liste des réseaux Wi-Fi
            val = rotary.value()
            if val != last_val:
                selected_network_index = val  # L'index du réseau correspond à la valeur de l'encodeur
                last_val = val
                display_wifi_menu()

    elif menu_active:
        # Lire la valeur de l'encodeur rotatif pour le menu
        val = rotary.value()
        print(rotary.value())
        if val != last_val:
            menu_index = val  # L'index du menu correspond à la valeur de l'encodeur
            last_val = val
            display_menu()

    else:
        # Afficher l'heure si le menu n'est pas actif
        display_time()

    time.sleep(0.01)