Untitled

class LidAlertScreen(ctk.CTkToplevel):
    def __init__(self, parent, dark_mode: bool = None, language='EN'):
        super().__init__(parent)
        
        print("\n=== Initializing LidAlertScreen ===")
        
        # Get dark mode from parent if not specified
        if dark_mode is None:
            dark_mode = getattr(parent, 'dark_mode', True)
        
        # Get language from parent if available
        self.language = getattr(parent, 'language', language)
        self.dark_mode = dark_mode
        self._destroyed = False
        self.parent = parent
        
        # Initialize the reed switch
        self.reed_switch = Button(25, pull_up=True)
        self.reed_switch.when_pressed = self.handle_lid_closed
        
        # Make it fullscreen and disable all close operations
        self.overrideredirect(True)
        self.geometry(f"{self.winfo_screenwidth()}x{self.winfo_screenheight()}+0+0")
        self.protocol("WM_DELETE_WINDOW", lambda: None)
        self.attributes('-topmost', True)

        # Set background color based on dark mode
        bg_color = '#1c1c1e' if dark_mode else '#f5f5f7'
        border_color = '#2c2c2e' if dark_mode else '#e5e5e7'
        self.configure(fg_color=bg_color)

        # Create main container with padding
        self.container = ctk.CTkFrame(self, fg_color=bg_color, corner_radius=0)
        self.container.pack(fill='both', expand=True, padx=30, pady=30)

        # Add a border around the alert box
        self.border_frame = ctk.CTkFrame(self.container, fg_color=border_color, corner_radius=10)
        self.border_frame.pack(fill='both', expand=True, padx=10, pady=10)

        # Create colored alert box inside the border (using pastel red)
        pastel_red = "#FFB3B3"  # Light pastel red
        self.alert_box = ctk.CTkFrame(self.border_frame, fg_color=pastel_red, corner_radius=8)
        self.alert_box.pack(fill='both', expand=True, padx=5, pady=5)

        # Add the warning message
        message_text = TRANSLATIONS[self.language].get('lid_open_warning', 
                                                "WARNING: Lid is open!\nPlease close the lid to continue.")
        self.message_label = ctk.CTkLabel(
            self.alert_box,
            text=message_text,
            font=('Dongle', 36),
            text_color='#000000'
        )
        self.message_label.place(relx=0.5, rely=0.35, anchor='center')

        # Add warning icon
        try:
            icon_image = ctk.CTkImage(
                light_image=Image.open("icons/warning-b.png"),
                dark_image=Image.open("icons/warning-b.png"),
                size=(65, 65)
            )
            self.icon_label = ctk.CTkLabel(
                self.alert_box,
                image=icon_image,
                text=""
            )
            self.icon_label.place(relx=0.5, rely=0.55, anchor='center')
        except Exception as e:
            print(f"Error loading warning icon: {e}")
            self.icon_label = ctk.CTkLabel(
                self.alert_box,
                text="⚠️",
                font=('Dongle', 48)
            )
            self.icon_label.place(relx=0.5, rely=0.55, anchor='center')
        
        # Start monitoring thread
        self.monitor_thread = threading.Thread(target=self.monitor_lid, daemon=True)
        self.monitor_thread.start()

    def handle_lid_closed(self):
        """Handle lid closed event"""
        print("Lid closed detected")
        if not self._destroyed:
            self.after(0, self.destroy)
            self._destroyed = True

    def monitor_lid(self):
        """Monitor lid status"""
        while not self._destroyed:
            if self.reed_switch.is_pressed:  # Magnet detected (lid closed)
                print("Lid closed detected in monitoring thread")
                if not self._destroyed:
                    self.after(0, self.destroy)
                    self._destroyed = True
                break
            time.sleep(0.1)

    def cleanup(self):
        """Cleanup resources"""
        self._destroyed = True
        if hasattr(self, 'reed_switch'):
            self.reed_switch.close()

class LidMonitor:
    def __init__(self, parent):
        print("\n=== Initializing LidMonitor ===")
        self.parent = parent
        self._running = True
        self._alert_shown = False
        
        try:
            # Initialize the reed switch
            self.reed_switch = Button(25, pull_up=True)
            print("Reed switch initialized successfully")
            
            # Start monitoring in a separate thread
            self.monitor_thread = threading.Thread(target=self._monitor_lid, daemon=True)
            self.monitor_thread.start()
            print("Lid monitoring thread started")
            
        except Exception as e:
            print(f"Error initializing LidMonitor: {e}")
            self.reed_switch = None
    
    def _monitor_lid(self):
        """Monitor lid status in a separate thread"""
        print("Starting lid monitoring...")
        while self._running:
            try:
                if not self.reed_switch.is_pressed:  # Lid is open
                    if not self._alert_shown:
                        print("Lid open detected - showing alert")
                        self.parent.after(0, lambda: self._show_alert())
                        self._alert_shown = True
                else:  # Lid is closed
                    if self._alert_shown:
                        print("Lid closed detected")
                        self._alert_shown = False
                time.sleep(0.1)
                
            except Exception as e:
                print(f"Error in lid monitoring: {e}")
                time.sleep(1)
    
    def _show_alert(self):
        """Show the lid alert screen"""
        if not hasattr(self, '_lid_alert') or not self._lid_alert:
            self._lid_alert = LidAlertScreen(self.parent)
    
    def cleanup(self):
        """Clean up resources"""
        print("Cleaning up LidMonitor...")
        self._running = False
        if hasattr(self, 'reed_switch') and self.reed_switch:
            self.reed_switch.close()
        if hasattr(self, '_lid_alert') and self._lid_alert:
            self._lid_alert.cleanup()