"""
Manages the RGB LCD display with the current state of the microwaves and cloud connectivity.

The display switches content every x seconds between microwaves, external screens, 
and cloud connectivity state using a background thread.
"""

import threading
import time

SCREEN_SWITCH_INTERVAL = 5  # seconds
DEFAULT_BRIGHTNESS = 0.3  # Constant brightness (range 0.0 to 1.0)


class RGBLCDManager:
    def __init__(self, rgb_lcd, interval=SCREEN_SWITCH_INTERVAL, brightness=DEFAULT_BRIGHTNESS, auto_start=True):
        self.rgb_lcd = rgb_lcd
        self.interval = interval
        self.brightness = max(0.0, min(1.0, float(brightness)))

        # Internal state store
        self._microwave_count = "N/A"
        self._external_screen_count = "N/A"
        self._cloud_alert = None

        # Screen rotation sequence
        self.screens = [
            self.display_microwave_state,
            self.display_external_screens,
            self.display_cloud_connectivity,
        ]
        self.current_screen_idx = 0

        # Threading controls
        self._thread = None
        self._running = False
        self._stop_event = threading.Event()

        if auto_start:
            self.start()

    # --- SETTER METHODS ---

    def set_brightness(self, brightness):
        """Dynamically adjust backlight brightness (0.0 to 1.0)."""
        self.brightness = max(0.0, min(1.0, float(brightness)))

    def set_microwave_count(self, count):
        """Set the number of connected microwaves."""
        self._microwave_count = count

    def set_external_screen_count(self, count):
        """Set the number of connected external screens."""
        self._external_screen_count = count

    def set_cloud_alert(self, status: bool):
        """Set cloud connectivity status."""
        self._cloud_alert = status

    def set_data(self, microwave_count=None, external_screen_count=None, cloud_alert=None):
        """Convenience method to update all state variables at once."""
        if microwave_count is not None:
            self.set_microwave_count(microwave_count)
        if external_screen_count is not None:
            self.set_external_screen_count(external_screen_count)
        if cloud_alert is not None:
            self.set_cloud_alert(cloud_alert)

    # --- DISPLAY RENDERERS ---

    def display_microwave_state(self):
        """Display the number of connected microwaves."""
        text = f"Microwaves:\nConnected: {self._microwave_count}"
        self.rgb_lcd.setText(text)
        self.rgb_lcd.setRGB(255, 255, 255, brightness=self.brightness)

    def display_external_screens(self):
        """Display the number of connected external screens."""
        text = f"Screens:\nConnected: {self._external_screen_count}"
        self.rgb_lcd.setText(text)
        self.rgb_lcd.setRGB(255, 255, 255, brightness=self.brightness)

    def display_cloud_connectivity(self):
        """Display cloud connectivity status with brightness-scaled backlight color."""
        status_str = None
    
        # Base RGB colors
        if self._cloud_alert is True:
            rgb = (255, 0, 0)      # Red
            status_str = "Disconnected"
        elif self._cloud_alert is False:
            rgb = (0, 255, 0)      # Green
            status_str = "Connected"
        else:
            rgb = (255, 165, 0)    # Orange
            status_str = "N/A"

        self.rgb_lcd.setRGB(rgb[0], rgb[1], rgb[2], brightness=self.brightness)
        self.rgb_lcd.setText(f"Cloud Status:\n{status_str}")

    # --- BACKGROUND THREAD LOGIC ---

    def _display_loop(self):
        """Background loop that switches screens at regular intervals."""
        while not self._stop_event.is_set():
            try:
                self.screens[self.current_screen_idx]()
                self.current_screen_idx = (self.current_screen_idx + 1) % len(self.screens)
            except Exception as e:
                print(f"[RGBLCDManager] Error updating LCD: {e}")

            sleep_ticks = int(self.interval * 10)
            for _ in range(sleep_ticks):
                if self._stop_event.is_set():
                    break
                time.sleep(0.1)

    def start(self):
        """Start the display background thread."""
        if not self._running:
            self._running = True
            self._stop_event.clear()
            self._thread = threading.Thread(target=self._display_loop, daemon=True)
            self._thread.start()

    def stop(self):
        """Stop the display loop and turn off the LCD backlight."""
        if self._running:
            self._stop_event.set()
            if self._thread and self._thread.is_alive():
                self._thread.join(timeout=2.0)
            self._running = False

        try:
            self.rgb_lcd.setText("Bye !")
            self.rgb_lcd.setRGB(0, 0, 0)
        except Exception as e:
            print(f"[RGBLCDManager] Error clearing LCD: {e}")