eazygit 0.5.1

use crate::components::Component;
use crate::services::GitService;
use crate::app::{AppState, Action, reducer};
use crate::errors::ComponentError;
use crate::input::InputEvent;
use crate::ui::style;
use ratatui::Frame;
use ratatui::layout::Rect;
use ratatui::widgets::{List, ListItem};
use ratatui::style::Style;
use crossterm::event::{KeyCode, KeyEventKind};
use std::sync::Arc;

pub struct ReflogPane {
    git_service: Arc<GitService>,
}

impl ReflogPane {
    pub fn new(git_service: Arc<GitService>) -> Self {
        Self { git_service }
    }
}

impl Component for ReflogPane {
    fn handle_event(
        &mut self,
        event: InputEvent,
        state: &AppState,
    ) -> Result<Option<Action>, ComponentError> {
        match event {
            InputEvent::Key(key) if key.kind == KeyEventKind::Press => {
                match key.code {
                    KeyCode::Esc => {
                        Ok(Some(Action::FocusPrev)) // Go back to Status pane
                    }
                    KeyCode::Char('k') | KeyCode::Up => {
                        Ok(Some(Action::ReflogUp))
                    }
                    KeyCode::Char('j') | KeyCode::Down => {
                        Ok(Some(Action::ReflogDown))
                    }
                    KeyCode::Enter => {
                        // Checkout reflog entry
                        if let Some(entry) = state.reflog_entries.get(state.reflog_selected) {
                            Ok(Some(Action::CheckoutReflog(entry.short_hash.clone())))
                        } else {
                            Ok(None)
                        }
                    }
                    _ => Ok(None),
                }
            }
            _ => Ok(None),
        }
    }
    
    fn update(
        &mut self,
        action: Action,
        state: &mut AppState,
    ) -> Result<(), ComponentError> {
        match action {
            Action::RefreshReflog => {
                // Refresh reflog from git
                let path = state.repo_path.clone();
                match self.git_service.reflog(&path) {
                    Ok(entries) => {
                        *state = reducer(state.clone(), Action::SetReflog(entries));
                    }
                    Err(e) => {
                        tracing::warn!(error = %e, "reflog error");
                    }
                }
            }
            _ => {}
        }
        Ok(())
    }
    
    fn render(&mut self, frame: &mut Frame, area: Rect, state: &AppState) {
        let theme = &state.theme;
        let selection_style = style::selection(theme);

        let items: Vec<ListItem> = state.reflog_entries
            .iter()
            .enumerate()
            .map(|(i, entry)| {
                let style = if i == state.reflog_selected {
                    selection_style
                } else {
                    Style::default().fg(theme.untracked_color())
                };
                
                ListItem::new(format!("{} {} - {}", entry.short_hash, entry.action, entry.selector))
                    .style(style)
            })
            .collect();
        
        let list = List::new(items)
            .style(style::body_style(theme))
            .block(style::pane_block(theme, "Reflog", false));
        
        frame.render_widget(list, area);
    }
    
    fn name(&self) -> &'static str {
        "ReflogPane"
    }
}