Console

pub struct Terminal {
    pub lines:         [TermLine; 128],  // Ring buffer
    pub line_count:    usize,            // Total lines written
    pub input:         [u8; 80],         // Current input buffer
    pub input_len:     usize,
    pub cursor_vis:    bool,
    pub scroll_offset: usize,            // Lines scrolled up
    
    hist_cmds:  [[u8; 80]; 16],          // Command history
    hist_lens:  [usize; 16],
    hist_count: usize,
}

pub struct TermLine {
    pub buf:   [u8; 92],      // 92 columns
    pub len:   usize,
    pub color: LineColor,
}

pub enum LineColor {
    Normal,   // White text
    Success,  // Green (operations succeeded)
    Warning,  // Yellow (attention)
    Error,    // Red (errors)
    Info,     // Cyan (system info)
    Prompt,   // Gold (command prompt)
    Header,   // Bright blue (section headers)
}

impl Terminal {
    /// Access line by logical index (0 = oldest available)
    pub fn line_at(&self, li: usize) -> &TermLine {
        &self.lines[li % TERM_ROWS]
    }
    
    /// Calculate oldest logical index
    fn oldest_logical(&self) -> usize {
        if self.line_count <= TERM_ROWS {
            0
        } else {
            self.line_count - TERM_ROWS
        }
    }
    
    /// Visible range for rendering
    pub fn visible_range(&self, max_visible: usize) -> (usize, usize) {
        let oldest = self.oldest_logical();
        let total_available = self.line_count - oldest;
        let count = total_available.min(max_visible);
        let bottom_start = self.line_count.saturating_sub(count);
        let start = bottom_start.saturating_sub(self.scroll_offset).max(oldest);
        (start, count)
    }
}

impl Terminal {
    pub fn type_char(&mut self, c: u8) {
        if self.input_len < INPUT_MAX - 1 && c >= 32 && c < 127 {
            self.input[self.input_len] = c;
            self.input_len += 1;
        }
    }
    
    pub fn backspace(&mut self) {
        if self.input_len > 0 {
            self.input_len -= 1;
        }
    }
}

impl Terminal {
    pub fn enter(
        &mut self,
        hw: &HardwareInfo,
        pci: &PciBus
    ) {
        // 1. Echo command line with prompt
        let mut echo = [0u8; 90];
        echo[..8].copy_from_slice(b"PORTIX> ");
        echo[8..8 + self.input_len].copy_from_slice(&self.input[..self.input_len]);
        self.write_bytes(&echo, LineColor::Prompt);
        
        // 2. Add to history
        if self.input_len > 0 {
            let slot = self.hist_count % 16;
            self.hist_cmds[slot] = self.input;
            self.hist_lens[slot] = self.input_len;
            self.hist_count += 1;
        }
        
        // 3. Parse command and arguments
        let (cmd, args) = parse_input(&self.input);
        
        // 4. Dispatch to handler
        self.dispatch(cmd, args, hw, pci);
        
        // 5. Clear input buffer
        self.clear_input();
    }
}

b"clear" | b"cls" | b"limpiar"  // Clear screen
b"echo" | b"print"              // Print text
b"history" | b"historial"       // Show command history

b"calc" | b"math" | b"="  // Arithmetic (+, -, *, /)
b"hex"                    // Decimal to hex
b"dec"                    // Hex to decimal
b"bin"                    // Decimal to binary
b"rgb"                    // RGB components to 0xRRGGBB

b"beep"              // PC speaker beep (adjustable Hz)
b"colors" | b"palette"  // Terminal color demo
b"ascii" | b"art"    // ASCII art logo
b"banner"            // Large text banner
b"progress"          // Progress bar animation
b"matrix"            // Matrix-style scrolling text
b"scrolltest"        // Generate 50 lines for scroll testing

impl Terminal {
    /// Maximum scroll offset for current view
    pub fn max_scroll(&self, max_visible: usize) -> usize {
        let available = self.line_count.saturating_sub(self.oldest_logical());
        available.saturating_sub(max_visible)
    }
    
    /// Scroll up (toward older lines)
    pub fn scroll_up(&mut self, lines: usize, max_visible: usize) {
        let max = self.max_scroll(max_visible);
        self.scroll_offset = (self.scroll_offset + lines).min(max);
    }
    
    /// Scroll down (toward newer lines)
    pub fn scroll_down(&mut self, lines: usize) {
        self.scroll_offset = self.scroll_offset.saturating_sub(lines);
    }
    
    /// Jump to bottom (most recent output)
    pub fn scroll_to_bottom(&mut self) {
        self.scroll_offset = 0;
    }
    
    /// Check if at bottom
    pub fn at_bottom(&self) -> bool {
        self.scroll_offset == 0
    }
}

const TAB_NAMES: [&str; 5] = [
    "TERMINAL",    // Shell interface
    "FILES",       // File browser
    "SYSTEM",      // Hardware info
    "TASKS",       // Process list (future)
    "SETTINGS",    // Configuration (future)
];

impl Layout {
    pub fn tab_hit(&self, mx: i32, my: i32) -> i32 {
        let x = mx as usize;
        let y = my as usize;
        
        if y < self.tab_y || y >= self.tab_y + self.tab_h {
            return -1;
        }
        
        let idx = x / self.tab_w;
        if idx < 5 { idx as i32 } else { -1 }
    }
}

impl Console {
    pub fn write_at(
        &mut self,
        s: &str,
        x: usize,
        y: usize,
        color: Color
    ) {
        let (ox, oy, om) = (self.cursor_x, self.cursor_y, self.margin_x);
        self.cursor_x = x;
        self.cursor_y = y;
        self.margin_x = x;
        self.write(s, color);
        self.cursor_x = ox;
        self.cursor_y = oy;
        self.margin_x = om;
    }
}

impl Terminal {
    fn cmd_history(&mut self) {
        if self.hist_count == 0 {
            self.write_line("(sin historial de comandos)", LineColor::Normal);
            return;
        }
        
        let total = self.hist_count.min(16);
        let start = if self.hist_count > 16 {
            self.hist_count - 16
        } else {
            0
        };
        
        for i in 0..total {
            let slot = (start + i) % 16;
            let cmd = &self.hist_cmds[slot][..self.hist_lens[slot]];
            self.write_line(&format!("  {}  {}", start + i + 1, cmd), LineColor::Normal);
        }
    }
}