komp_ac/client/src/ui/handlers/render.rs

// src/ui/handlers/render.rs

use crate::components::{
    render_background,
    render_buffer_list,
    render_command_line,
    render_status_line,
    intro::intro::render_intro,
    handlers::sidebar::{self, calculate_sidebar_layout},
    form::form::render_form,
    auth::{login::render_login, register::render_register},
};
use crate::config::colors::themes::Theme;
use ratatui::layout::{Constraint, Direction, Layout};
use ratatui::Frame;
use crate::state::pages::form::FormState;
use crate::state::pages::auth::AuthState;
use crate::state::pages::auth::LoginState;
use crate::state::pages::auth::RegisterState;
use crate::state::pages::intro::IntroState;
use crate::state::app::buffer::BufferState;
use crate::state::app::state::AppState;
use crate::state::pages::admin::AdminState;

pub fn render_ui(
    f: &mut Frame,
    form_state: &mut FormState,
    auth_state: &mut AuthState,
    login_state: &LoginState,
    register_state: &RegisterState,
    intro_state: &IntroState,
    admin_state: &mut AdminState,
    buffer_state: &BufferState,
    theme: &Theme,
    is_edit_mode: bool,
    is_highlight_mode: bool,
    highlight_anchor: Option<(usize, usize)>,
    total_count: u64,
    current_position: u64,
    current_dir: &str,
    command_input: &str,
    command_mode: bool,
    command_message: &str,
    current_fps: f64,
    app_state: &AppState,
) {
    render_background(f, f.area(), theme);

    // Adjust layout based on whether buffer list is shown
    let constraints = if app_state.ui.show_buffer_list {
        vec![
            Constraint::Length(1),   // Buffer list
            Constraint::Min(1),      // Main content
            Constraint::Length(1),   // Status line
            Constraint::Length(1),   // Command line
        ]
    } else {
        vec![
            Constraint::Min(1),      // Main content
            Constraint::Length(1),   // Status line (no buffer list)
            Constraint::Length(1),   // Command line
        ]
    };

    let root = Layout::default()
        .direction(Direction::Vertical)
        .constraints(constraints)
        .split(f.area());

    let mut buffer_list_area = None;
    let main_content_area;
    let status_line_area;
    let command_line_area;

    // Assign areas based on layout
    if app_state.ui.show_buffer_list {
        buffer_list_area = Some(root[0]);
        main_content_area = root[1];
        status_line_area = root[2];
        command_line_area = root[3];
    } else {
        main_content_area = root[0];
        status_line_area = root[1];
        command_line_area = root[2];
    }

    if app_state.ui.show_intro {
        render_intro(f, intro_state, main_content_area, theme);
    } else if app_state.ui.show_register {
        render_register(
            f,
            main_content_area,
            theme,
            register_state,
            app_state,
            register_state.current_field < 4,
            is_highlight_mode,
            highlight_anchor,
        );
    } else if app_state.ui.show_login {
        render_login(
            f,
            main_content_area,
            theme,
            login_state,
            app_state,
            login_state.current_field < 2,
            is_highlight_mode,
            highlight_anchor,
        );
    } else if app_state.ui.show_admin {
        crate::components::admin::admin_panel::render_admin_panel(
            f,
            auth_state,
            admin_state,
            main_content_area,
            theme,
            &app_state.profile_tree,
            &app_state.selected_profile,
        );
    } else if app_state.ui.show_form {
        let (sidebar_area, form_area) = calculate_sidebar_layout(
            app_state.ui.show_sidebar,
            main_content_area
        );

        if let Some(sidebar_rect) = sidebar_area {
            sidebar::render_sidebar(
                f,
                sidebar_rect,
                theme,
                &app_state.profile_tree,
                &app_state.selected_profile
            );
        }

        // This change makes the form stay stationary when toggling sidebar
        let available_width = form_area.width;
        let form_constraint = if available_width >= 80 {
            // Use main_content_area for centering when enough space
            Layout::default()
                .direction(Direction::Horizontal)
                .constraints([
                    Constraint::Min(0),
                    Constraint::Length(80),
                    Constraint::Min(0),
                ])
                .split(main_content_area)[1]
        } else {
            // Use form_area (post sidebar) when limited space
            Layout::default()
                .direction(Direction::Horizontal)
                .constraints([
                    Constraint::Min(0),
                    Constraint::Length(80.min(available_width)),
                    Constraint::Min(0),
                ])
                .split(form_area)[1]
        };

        // Convert fields to &[&str] and values to &[&String]
        let fields: Vec<&str> = form_state.fields.iter().map(|s| s.as_str()).collect();
        let values: Vec<&String> = form_state.values.iter().collect();

        render_form(
            f,
            form_constraint,
            form_state,
            &fields,
            &form_state.current_field,
            &values,
            theme,
            is_edit_mode,
            is_highlight_mode,
            highlight_anchor,
            total_count,
            current_position,
        );
    }

    // Render buffer list if enabled and area is available
    if let Some(area) = buffer_list_area {
        if app_state.ui.show_buffer_list {
            render_buffer_list(f, area, theme, buffer_state);
        }
    }
    render_status_line(f, status_line_area, current_dir, theme, is_edit_mode, current_fps);
    render_command_line(f, command_line_area, command_input, command_mode, theme, command_message);
}