"""
NeoPixel Controller for Punch Card Display System - Phase 0 Prototype

This module provides a simple interface for controlling a NeoPixel LED grid
to display the current state of the punch card display.
"""

import time
import serial
from typing import List, Tuple, Optional
from dataclasses import dataclass

@dataclass
class Color:
    """Simple color representation with RGB values."""
    r: int
    g: int
    b: int
    
    def as_tuple(self) -> Tuple[int, int, int]:
        """Return color as an RGB tuple."""
        return (self.r, self.g, self.b)
    
    def as_hex(self) -> str:
        """Return color as a hex string."""
        return f"#{self.r:02x}{self.g:02x}{self.b:02x}"
    
    @classmethod
    def from_hex(cls, hex_color: str) -> 'Color':
        """Create a Color from a hex string."""
        hex_color = hex_color.lstrip('#')
        return cls(
            r=int(hex_color[0:2], 16),
            g=int(hex_color[2:4], 16),
            b=int(hex_color[4:6], 16)
        )

# Default colors
COLOR_ON = Color(255, 255, 255)  # White
COLOR_OFF = Color(0, 0, 0)       # Black
COLOR_ERROR = Color(255, 0, 0)   # Red

class NeoPixelController:
    """Controller for NeoPixel LED grid, with fallback to terminal simulation."""
    
    def __init__(self, 
                 rows: int = 8, 
                 columns: int = 8, 
                 hardware_enabled: bool = False,
                 port: str = "/dev/ttyUSB0",
                 baudrate: int = 115200,
                 brightness: float = 0.5):
        """Initialize the NeoPixel controller."""
        self.rows = rows
        self.columns = columns
        self.hardware_enabled = hardware_enabled
        self.port = port
        self.baudrate = baudrate
        self.brightness = max(0.0, min(1.0, brightness))
        
        # Initialize the grid buffer
        self.grid_buffer = [[COLOR_OFF for _ in range(columns)] for _ in range(rows)]
        
        # Physical hardware connection
        self.serial = None
        
        # Connect to hardware if enabled
        if self.hardware_enabled:
            self._connect_hardware()
    
    def _connect_hardware(self) -> bool:
        """Connect to the Arduino controller."""
        try:
            self.serial = serial.Serial(
                port=self.port,
                baudrate=self.baudrate,
                timeout=1
            )
            
            # Wait for Arduino to reset
            time.sleep(2)
            
            # Check for READY message
            response = self.serial.readline().decode('utf-8').strip()
            if response != "READY":
                print(f"Unexpected response from Arduino: {response}")
                self.serial.close()
                self.serial = None
                return False
            
            # Set initial brightness
            self._send_command(f"BRIGHTNESS,{self.brightness}")
            
            return True
        except Exception as e:
            print(f"Error connecting to Arduino: {e}")
            if self.serial:
                self.serial.close()
                self.serial = None
            return False
    
    def _send_command(self, command: str) -> bool:
        """Send a command to the Arduino and wait for acknowledgment."""
        if not self.serial:
            return False
        
        try:
            # Send command with newline
            self.serial.write(f"{command}\n".encode('utf-8'))
            
            # Wait for response
            response = self.serial.readline().decode('utf-8').strip()
            return response == "OK"
        except Exception as e:
            print(f"Error sending command: {e}")
            return False
    
    def set_pixel(self, row: int, col: int, color: Color) -> None:
        """Set a single pixel in the grid."""
        if 0 <= row < self.rows and 0 <= col < self.columns:
            self.grid_buffer[row][col] = color
            
            if self.hardware_enabled and self.serial:
                self._send_command(f"PIXEL,{row},{col},{color.r},{color.g},{color.b}")
    
    def update_grid(self, grid: List[List[bool]], color_on: Optional[Color] = None) -> None:
        """Update the entire grid at once from a boolean grid."""
        color_on = color_on or COLOR_ON
        
        # Update local buffer
        for row in range(min(len(grid), self.rows)):
            for col in range(min(len(grid[row]), self.columns)):
                self.grid_buffer[row][col] = color_on if grid[row][col] else COLOR_OFF
        
        # Send to hardware
        if self.hardware_enabled and self.serial:
            # Clear the grid first
            self._send_command("CLEAR")
            
            # Send each pixel
            for row in range(self.rows):
                for col in range(self.columns):
                    color = self.grid_buffer[row][col]
                    if color.r > 0 or color.g > 0 or color.b > 0:  # Only send non-black pixels
                        self._send_command(f"PIXEL,{row},{col},{color.r},{color.g},{color.b}")
            
            # Show the updated grid
            self._send_command("SHOW")
    
    def update_from_punch_card(self, punch_card, card_rows: int = 12, scale_factor: float = 1.0) -> None:
        """Update the LED grid from a punch card display.
        
        This is a specialized method that converts the punch card display 
        to an appropriate format for the LED grid.
        
        Args:
            punch_card: The PunchCardDisplay instance
            card_rows: Number of rows to capture from the punch card
            scale_factor: Scaling factor for the grid (for smaller displays)
        """
        # Create a boolean grid from the punch card
        grid = [[False for _ in range(self.columns)] for _ in range(self.rows)]
        
        # Extract the punch card state - this will need to be adapted based on
        # how the punch card state is represented in the actual implementation
        try:
            # This is an example - actual implementation will vary
            for i in range(min(card_rows, self.rows)):
                for j in range(min(80, self.columns)):
                    # Check if there's a punch hole at this position
                    # This is a placeholder - actual code will depend on PunchCardDisplay implementation
                    if hasattr(punch_card, 'card_grid') and punch_card.card_grid:
                        has_hole = bool(punch_card.card_grid[i][j])
                        row_idx = min(int(i * scale_factor), self.rows - 1)
                        col_idx = min(int(j * scale_factor), self.columns - 1)
                        grid[row_idx][col_idx] = has_hole
        except Exception as e:
            print(f"Error extracting punch card state: {e}")
        
        # Update the grid
        self.update_grid(grid)
    
    def clear(self) -> None:
        """Clear the entire grid (set all pixels to off)."""
        for row in range(self.rows):
            for col in range(self.columns):
                self.grid_buffer[row][col] = COLOR_OFF
        
        if self.hardware_enabled and self.serial:
            self._send_command("CLEAR")
    
    def test_pattern(self, pattern: str = "chase", duration: float = 5.0) -> None:
        """Display a test pattern on the LEDs.
        
        Args:
            pattern: Test pattern to display ("chase", "rainbow")
            duration: Duration to display the pattern in seconds
        """
        if self.hardware_enabled and self.serial:
            self._send_command(f"TEST,{pattern}")
        else:
            # For software simulation, implement test patterns
            print(f"Software simulation of {pattern} pattern for {duration}s")
            time.sleep(duration)
    
    def set_brightness(self, brightness: float) -> None:
        """Set the brightness of the LEDs."""
        self.brightness = max(0.0, min(1.0, brightness))
        
        if self.hardware_enabled and self.serial:
            self._send_command(f"BRIGHTNESS,{self.brightness}")
    
    def shutdown(self) -> None:
        """Safely shut down the LED controller."""
        # Turn off all LEDs
        self.clear()
        
        # Close serial connection if open
        if self.hardware_enabled and self.serial:
            self._send_command("SHUTDOWN")
            self.serial.close()
            self.serial = None

# In main.py or another appropriate entry point

from punch_card import PunchCardDisplay
from neopixel_controller import NeoPixelController

def main():
    # Initialize the punch card display
    punch_card = PunchCardDisplay()
    
    # Initialize the NeoPixel controller (disabled by default)
    neopixel_enabled = False  # Set to True when hardware is connected
    neopixel_port = "/dev/ttyUSB0"  # Change to match your system
    
    if neopixel_enabled:
        led_controller = NeoPixelController(
            rows=8,
            columns=8,
            hardware_enabled=True,
            port=neopixel_port,
            brightness=0.5
        )
    else:
        led_controller = None
    
    # Add the LED controller to the punch card display
    punch_card.led_controller = led_controller
    
    # Run the application
    try:
        # ... existing application logic ...
        
        # Make sure to update the LED controller when the punch card state changes
        # This could be implemented in the PunchCardDisplay class
        
    finally:
        # Ensure proper shutdown
        if led_controller:
            led_controller.shutdown()

if __name__ == "__main__":
    main()

# In punch_card.py, modify the PunchCardDisplay class

def _display_grid(self, holes, sync_leds=True):
    """Display the current punch card grid with holes punched."""
    # ... existing display code ...
    
    # Update LED controller if available
    if sync_leds and hasattr(self, 'led_controller') and self.led_controller:
        self.led_controller.update_from_punch_card(self)