use crate::models::{
    AppState, DownloadEntry, FileDisplayData, FocusedPane, SearchEntry,
    SearchStatus,
};
use crate::ui::panes::{
    ResultsPaneParams, render_downloads_pane, render_results_pane,
    render_searches_pane,
};
use crate::ui::{
    border_style, border_type, format_shortcuts_styled, render_download_stats,
};
use color_eyre::Result;
use ratatui::{
    DefaultTerminal, Frame,
    crossterm::event::{
        self, Event, KeyCode, KeyEvent, KeyEventKind, MouseButton, MouseEvent,
        MouseEventKind, poll,
    },
    layout::{Constraint, Layout},
    widgets::{Block, Borders, Paragraph},
};
use soulseek_rs::{Client, DownloadStatus};
use std::{
    sync::{
        Arc,
        atomic::AtomicBool,
        mpsc::{self},
    },
    thread,
    time::{Duration, Instant},
};

pub struct MainTui {
    client: Arc<Client>,
    state: AppState,
    download_dir: String,
    #[allow(dead_code)]
    max_concurrent_downloads: usize,
    search_timeout: Duration,
    #[allow(dead_code)]
    spinner_state: usize,
}

impl MainTui {
    pub fn new(
        client: Arc<Client>,
        download_dir: String,
        max_concurrent_downloads: usize,
        search_timeout: Duration,
    ) -> Self {
        Self {
            client,
            state: AppState::new(),
            download_dir,
            max_concurrent_downloads,
            search_timeout,
            spinner_state: 0,
        }
    }

    pub fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
        while !self.state.should_exit {
            terminal.draw(|frame| self.render(frame))?;

            // Poll for search results updates
            self.update_search_results();

            // Poll for download updates
            self.update_downloads();

            // Update spinner
            self.spinner_state = (self.spinner_state + 1) % 10;

            // Poll for input events
            if poll(Duration::from_millis(100))? {
                match event::read()? {
                    Event::Key(key) if key.kind == KeyEventKind::Press => {
                        self.handle_key_event(key)?;
                    }
                    Event::Mouse(mouse) => {
                        self.handle_mouse_event(mouse)?;
                    }
                    _ => {}
                }
            }
        }

        // Disable mouse capture before exiting
        use ratatui::crossterm::{event::DisableMouseCapture, execute};
        let _ = execute!(std::io::stdout(), DisableMouseCapture);

        // Restore terminal state
        ratatui::restore();

        soulseek_rs::utils::logger::disable_buffering();
        Ok(())
    }

    fn render(&mut self, frame: &mut Frame) {
        // Create layout based on whether command bar is active
        let main_chunks = if self.state.command_bar_active {
            Layout::vertical([
                Constraint::Length(3), // Status bar
                Constraint::Fill(1),   // Main content
                Constraint::Length(3), // Command bar
                Constraint::Length(3), // Shortcuts
            ])
            .split(frame.area())
        } else {
            Layout::vertical([
                Constraint::Length(3), // Status bar
                Constraint::Fill(1),   // Main content
                Constraint::Length(3), // Shortcuts
            ])
            .split(frame.area())
        };

        // Render status bar
        render_download_stats(
            frame,
            main_chunks[0],
            &self.state.downloads,
            self.state.active_downloads_count,
        );

        // Split main content area
        let content_chunks = Layout::horizontal([
            Constraint::Percentage(30), // Searches pane
            Constraint::Percentage(70), // Results + Downloads
        ])
        .split(main_chunks[1]);

        // Store searches pane area
        self.state.searches_pane_area = Some(content_chunks[0]);

        // Render Searches pane (left)
        render_searches_pane(
            frame,
            content_chunks[0],
            &self.state.searches,
            &mut self.state.searches_table_state,
            self.state.focused_pane == FocusedPane::Searches,
        );

        // Split right side into Results (top) and Downloads (bottom)
        let right_chunks = Layout::vertical([
            Constraint::Percentage(60), // Results
            Constraint::Percentage(40), // Downloads
        ])
        .split(content_chunks[1]);

        // Store results and downloads pane areas
        self.state.results_pane_area = Some(right_chunks[0]);
        self.state.downloads_pane_area = Some(right_chunks[1]);

        // Render Results pane
        let results_items = if self.state.results_filter_query.is_empty() {
            &self.state.results_items
        } else {
            &self.state.results_filtered_items
        };

        let active_search_query = self
            .state
            .selected_search_index
            .and_then(|idx| self.state.searches.get(idx))
            .map(|search| search.query.as_str());

        render_results_pane(
            frame,
            right_chunks[0],
            ResultsPaneParams {
                items: results_items,
                table_state: &mut self.state.results_table_state,
                selected_indices: &self.state.results_selected_indices,
                filter_query: &self.state.results_filter_query,
                is_filtering: self.state.results_is_filtering,
                focused: self.state.focused_pane == FocusedPane::Results,
                active_search_query,
            },
        );

        // Render Downloads pane
        render_downloads_pane(
            frame,
            right_chunks[1],
            &self.state.downloads,
            &mut self.state.downloads_table_state,
            self.state.focused_pane == FocusedPane::Downloads,
        );

        // Render command bar if active (vim-style, above shortcuts)
        if self.state.command_bar_active {
            self.render_command_bar(frame, main_chunks[2]);
            self.render_shortcuts(frame, main_chunks[3]);
        } else {
            self.render_shortcuts(frame, main_chunks[2]);
        }
    }

    fn render_shortcuts(&self, frame: &mut Frame, area: ratatui::layout::Rect) {
        let shortcuts = match self.state.focused_pane {
            FocusedPane::Searches => vec![
                ("s", "search"),
                ("1-3", "focus pane"),
                ("↑↓", "navigate"),
                ("Enter", "view results"),
                ("d", "remove search"),
                ("C", "clear all"),
                ("q", "quit"),
            ],
            FocusedPane::Results if self.state.results_is_filtering => vec![
                ("Type", "filter"),
                ("Esc", "clear filter"),
                ("1-3", "focus pane"),
                ("q", "quit"),
            ],
            FocusedPane::Results => vec![
                ("Space", "select"),
                ("/", "filter"),
                ("a/A", "select all/none"),
                ("Enter", "download"),
                ("1-3", "focus pane"),
                ("↑↓", "navigate"),
                ("q", "quit"),
            ],
            FocusedPane::Downloads => {
                vec![("1-3", "focus pane"), ("↑↓", "navigate"), ("q", "quit")]
            }
        };

        let shortcuts_line = format_shortcuts_styled(&shortcuts);
        let shortcuts_widget = Paragraph::new(shortcuts_line).block(
            Block::default()
                .borders(Borders::ALL)
                .border_type(border_type(false))
                .title("Shortcuts"),
        );

        frame.render_widget(shortcuts_widget, area);
    }

    fn render_command_bar(
        &self,
        frame: &mut Frame,
        area: ratatui::layout::Rect,
    ) {
        // Vim-style command bar with ":" prefix
        let command_text = format!("search: {}", self.state.command_bar_input);

        let paragraph = Paragraph::new(command_text).block(
            Block::default()
                .borders(Borders::ALL)
                .border_style(border_style(true))
                .border_type(border_type(true)),
        );

        frame.render_widget(paragraph, area);
    }

    fn handle_key_event(&mut self, key: KeyEvent) -> Result<()> {
        // Command bar takes priority
        if self.state.command_bar_active {
            return self.handle_command_bar_input(key);
        }

        // Filter mode in Results pane
        if self.state.results_is_filtering
            && self.state.focused_pane == FocusedPane::Results
        {
            return self.handle_filter_input(key);
        }

        // Global shortcuts
        match key.code {
            KeyCode::Char('q') => {
                self.state.should_exit = true;
                return Ok(());
            }
            KeyCode::Char('1') => {
                self.state.focused_pane = FocusedPane::Searches;
                return Ok(());
            }
            KeyCode::Char('2') => {
                self.state.focused_pane = FocusedPane::Results;
                return Ok(());
            }
            KeyCode::Char('3') => {
                self.state.focused_pane = FocusedPane::Downloads;
                return Ok(());
            }
            KeyCode::Char('s') => {
                self.state.command_bar_active = true;
                self.state.command_bar_input.clear();
                return Ok(());
            }
            _ => {}
        }

        // Pane-specific shortcuts
        match self.state.focused_pane {
            FocusedPane::Searches => self.handle_searches_input(key),
            FocusedPane::Results => self.handle_results_input(key),
            FocusedPane::Downloads => self.handle_downloads_input(key),
        }
    }

    fn handle_command_bar_input(&mut self, key: KeyEvent) -> Result<()> {
        match key.code {
            KeyCode::Enter => {
                let query = self.state.command_bar_input.trim().to_string();
                if !query.is_empty() {
                    self.start_search(query);
                }
                self.state.command_bar_active = false;
                self.state.command_bar_input.clear();
            }
            KeyCode::Esc => {
                self.state.command_bar_active = false;
                self.state.command_bar_input.clear();
            }
            KeyCode::Char(c) => {
                self.state.command_bar_input.push(c);
            }
            KeyCode::Backspace => {
                self.state.command_bar_input.pop();
            }
            _ => {}
        }
        Ok(())
    }

    fn handle_filter_input(&mut self, key: KeyEvent) -> Result<()> {
        match key.code {
            KeyCode::Esc => {
                self.state.results_is_filtering = false;
                self.state.results_filter_query.clear();
                self.state.results_filtered_items =
                    self.state.results_items.clone();
                self.state.results_filtered_indices =
                    (0..self.state.results_items.len()).collect();
            }
            KeyCode::Char(c) => {
                self.state.results_filter_query.push(c);
                self.apply_filter();
            }
            KeyCode::Backspace => {
                self.state.results_filter_query.pop();
                self.apply_filter();
            }
            _ => {}
        }
        Ok(())
    }

    fn handle_searches_input(&mut self, key: KeyEvent) -> Result<()> {
        match key.code {
            KeyCode::Up | KeyCode::Char('k') => {
                if !self.state.searches.is_empty() {
                    let current =
                        self.state.searches_table_state.selected().unwrap_or(0);
                    let new = if current == 0 {
                        self.state.searches.len() - 1
                    } else {
                        current - 1
                    };
                    self.state.searches_table_state.select(Some(new));
                }
            }
            KeyCode::Down | KeyCode::Char('j') => {
                if !self.state.searches.is_empty() {
                    let current =
                        self.state.searches_table_state.selected().unwrap_or(0);
                    let new = (current + 1) % self.state.searches.len();
                    self.state.searches_table_state.select(Some(new));
                }
            }
            KeyCode::Enter => {
                if let Some(selected) =
                    self.state.searches_table_state.selected()
                {
                    self.state.selected_search_index = Some(selected);
                    if let Some(search) = self.state.searches.get(selected) {
                        self.state.results_items = search.results.clone();
                        self.state.results_filtered_items =
                            search.results.clone();
                        self.state.results_filtered_indices =
                            (0..search.results.len()).collect();
                        self.state.results_selected_indices.clear();
                        self.state.results_table_state.select(Some(0));
                        self.state.focused_pane = FocusedPane::Results;
                    }
                }
            }
            KeyCode::Char('d') => {
                if let Some(selected) =
                    self.state.searches_table_state.selected()
                {
                    self.remove_search_at_index(selected);
                }
            }
            KeyCode::Char('C') => {
                self.clear_all_searches();
            }
            _ => {}
        }
        Ok(())
    }

    fn handle_results_input(&mut self, key: KeyEvent) -> Result<()> {
        let items_count = if self.state.results_filter_query.is_empty() {
            self.state.results_items.len()
        } else {
            self.state.results_filtered_items.len()
        };

        match key.code {
            KeyCode::Up | KeyCode::Char('k') => {
                if items_count > 0 {
                    let current =
                        self.state.results_table_state.selected().unwrap_or(0);
                    let new = if current == 0 {
                        items_count - 1
                    } else {
                        current - 1
                    };
                    self.state.results_table_state.select(Some(new));
                }
            }
            KeyCode::Down | KeyCode::Char('j') => {
                if items_count > 0 {
                    let current =
                        self.state.results_table_state.selected().unwrap_or(0);
                    let new = (current + 1) % items_count;
                    self.state.results_table_state.select(Some(new));
                }
            }
            KeyCode::Char(' ') => {
                if let Some(current) = self.state.results_table_state.selected()
                {
                    let actual_index =
                        if self.state.results_filter_query.is_empty() {
                            current
                        } else {
                            self.state.results_filtered_indices[current]
                        };

                    if self
                        .state
                        .results_selected_indices
                        .contains(&actual_index)
                    {
                        self.state
                            .results_selected_indices
                            .remove(&actual_index);
                    } else {
                        self.state
                            .results_selected_indices
                            .insert(actual_index);
                    }
                }
            }
            KeyCode::Char('/') => {
                self.state.results_is_filtering = true;
                self.state.results_filter_query.clear();
            }
            KeyCode::Char('a') => {
                let indices: Vec<usize> =
                    if self.state.results_filter_query.is_empty() {
                        (0..self.state.results_items.len()).collect()
                    } else {
                        self.state.results_filtered_indices.clone()
                    };
                self.state.results_selected_indices.extend(indices);
            }
            KeyCode::Char('A') => {
                self.state.results_selected_indices.clear();
            }
            KeyCode::Enter => {
                self.queue_selected_downloads();
            }
            _ => {}
        }
        Ok(())
    }

    fn handle_downloads_input(&mut self, key: KeyEvent) -> Result<()> {
        match key.code {
            KeyCode::Up | KeyCode::Char('k') => {
                if !self.state.downloads.is_empty() {
                    let current = self
                        .state
                        .downloads_table_state
                        .selected()
                        .unwrap_or(0);
                    let new = if current == 0 {
                        self.state.downloads.len() - 1
                    } else {
                        current - 1
                    };
                    self.state.downloads_table_state.select(Some(new));
                }
            }
            KeyCode::Down | KeyCode::Char('j') => {
                if !self.state.downloads.is_empty() {
                    let current = self
                        .state
                        .downloads_table_state
                        .selected()
                        .unwrap_or(0);
                    let new = (current + 1) % self.state.downloads.len();
                    self.state.downloads_table_state.select(Some(new));
                }
            }
            _ => {}
        }
        Ok(())
    }

    fn handle_mouse_event(&mut self, mouse: MouseEvent) -> Result<()> {
        if let MouseEventKind::Down(MouseButton::Left) = mouse.kind {
            let (col, row) = (mouse.column, mouse.row);

            // Check if click is within searches pane
            if let Some(area) = self.state.searches_pane_area
                && col >= area.x
                && col < area.x + area.width
                && row >= area.y
                && row < area.y + area.height
            {
                self.state.focused_pane = FocusedPane::Searches;
                return Ok(());
            }

            // Check if click is within results pane
            if let Some(area) = self.state.results_pane_area
                && col >= area.x
                && col < area.x + area.width
                && row >= area.y
                && row < area.y + area.height
            {
                self.state.focused_pane = FocusedPane::Results;
                return Ok(());
            }

            // Check if click is within downloads pane
            if let Some(area) = self.state.downloads_pane_area
                && col >= area.x
                && col < area.x + area.width
                && row >= area.y
                && row < area.y + area.height
            {
                self.state.focused_pane = FocusedPane::Downloads;
                return Ok(());
            }
        }

        Ok(())
    }

    fn remove_search_at_index(&mut self, index: usize) {
        if index >= self.state.searches.len() {
            return;
        }

        // Cancel the search if it's active
        if let Some(search) = self.state.searches.get(index) {
            search
                .cancel_flag
                .store(true, std::sync::atomic::Ordering::Relaxed);
        }

        // Check if we're removing the currently active search
        let was_active_search = self.state.selected_search_index == Some(index);

        // Remove the search
        self.state.searches.remove(index);

        // Update selected_search_index
        if let Some(current_idx) = self.state.selected_search_index {
            if current_idx == index {
                // Removed the active search - clear it
                self.state.selected_search_index = None;
            } else if current_idx > index {
                // Active search was after removed one - decrement index
                self.state.selected_search_index = Some(current_idx - 1);
            }
            // If current_idx < index, no change needed
        }

        // If we removed the active search, clear results pane
        if was_active_search {
            self.clear_results_pane();
        }

        // Update table selection
        if self.state.searches.is_empty() {
            self.state.searches_table_state.select(None);
        } else {
            let new_selection = if index >= self.state.searches.len() {
                self.state.searches.len() - 1
            } else {
                index
            };
            self.state.searches_table_state.select(Some(new_selection));
        }
    }

    fn clear_all_searches(&mut self) {
        // Cancel all active searches
        for search in &self.state.searches {
            search
                .cancel_flag
                .store(true, std::sync::atomic::Ordering::Relaxed);
        }

        // Clear searches
        self.state.searches.clear();
        self.state.searches_table_state.select(None);
        self.state.selected_search_index = None;

        // Clear results pane
        self.clear_results_pane();
    }

    fn clear_results_pane(&mut self) {
        self.state.results_items.clear();
        self.state.results_filtered_items.clear();
        self.state.results_filtered_indices.clear();
        self.state.results_selected_indices.clear();
        self.state.results_table_state.select(None);
        self.state.results_filter_query.clear();
        self.state.results_is_filtering = false;
    }

    fn apply_filter(&mut self) {
        let query = self.state.results_filter_query.to_lowercase();
        if query.is_empty() {
            self.state.results_filtered_items =
                self.state.results_items.clone();
            self.state.results_filtered_indices =
                (0..self.state.results_items.len()).collect();
        } else {
            self.state.results_filtered_items.clear();
            self.state.results_filtered_indices.clear();

            for (idx, item) in self.state.results_items.iter().enumerate() {
                if item.filename.to_lowercase().contains(&query)
                    || item.username.to_lowercase().contains(&query)
                {
                    self.state.results_filtered_items.push(item.clone());
                    self.state.results_filtered_indices.push(idx);
                }
            }
        }

        if !self.state.results_filtered_items.is_empty() {
            self.state.results_table_state.select(Some(0));
        }
    }

    fn start_search(&mut self, query: String) {
        let cancel_flag = Arc::new(AtomicBool::new(false));
        let search_entry = SearchEntry {
            query: query.clone(),
            status: SearchStatus::Active,
            results: Vec::new(),
            start_time: Instant::now(),
            cancel_flag: cancel_flag.clone(),
        };

        self.state.searches.push(search_entry);
        let search_index = self.state.searches.len() - 1;
        self.state.searches_table_state.select(Some(search_index));

        // Make this search the active one
        self.state.selected_search_index = Some(search_index);

        // Initialize results display (empty at first)
        self.state.results_items.clear();
        self.state.results_filtered_items.clear();
        self.state.results_filtered_indices.clear();
        self.state.results_selected_indices.clear();
        self.state.results_table_state.select(Some(0));

        // Switch focus to Results pane
        self.state.focused_pane = FocusedPane::Results;

        // Start search in background
        let client = self.client.clone();
        let timeout = self.search_timeout;

        thread::spawn(move || {
            match client.search_with_cancel(
                &query,
                timeout,
                Some(cancel_flag.clone()),
            ) {
                Ok(_results) => {
                    // Results will be polled in update_search_results
                }
                Err(e) => {
                    eprintln!("Search failed: {}", e);
                }
            }
        });
    }

    fn update_search_results(&mut self) {
        let timeout = self.search_timeout;
        let selected_search_index = self.state.selected_search_index;

        // Collect all queries first
        let queries: Vec<(usize, String)> = self
            .state
            .searches
            .iter()
            .enumerate()
            .map(|(idx, s)| (idx, s.query.clone()))
            .collect();

        // Fetch all results in one go (single lock acquisition per query)
        // Use try_get_search_results to avoid blocking the UI thread
        let all_results: Vec<(usize, Vec<_>)> = queries
            .into_iter()
            .filter_map(|(idx, query)| {
                self.client
                    .try_get_search_results(&query)
                    .map(|results| (idx, results))
            })
            .collect();

        // Now update state without holding any client locks
        for (idx, search_results) in all_results {
            if let Some(search) = self.state.searches.get_mut(idx) {
                if !search_results.is_empty() {
                    search.results.clear();
                    for result in search_results {
                        for file in result.files {
                            search.results.push(FileDisplayData {
                                filename: file.name.clone(),
                                size: file.size,
                                username: result.username.clone(),
                                speed: result.speed,
                                slots: result.slots,
                                bitrate: file.attribs.get(&0).copied(),
                            });
                        }
                    }

                    // Update selected search if this is the active one
                    if let Some(selected_idx) = selected_search_index
                        && selected_idx == idx
                    {
                        self.state.results_items = search.results.clone();
                        self.state.results_filtered_items =
                            search.results.clone();
                        self.state.results_filtered_indices =
                            (0..search.results.len()).collect();
                    }
                }

                // Mark as completed after timeout
                if search.status == SearchStatus::Active
                    && search.start_time.elapsed() > timeout
                {
                    search.status = SearchStatus::Completed;
                }
            }
        }
    }

    fn queue_selected_downloads(&mut self) {
        let selected_files: Vec<(String, String, u64)> = self
            .state
            .results_selected_indices
            .iter()
            .filter_map(|&idx| self.state.results_items.get(idx))
            .map(|file| {
                (file.filename.clone(), file.username.clone(), file.size)
            })
            .collect();

        if selected_files.is_empty() {
            return;
        }

        if self.state.downloads_receiver_channel.is_none() {
            let (sender, receiver) = mpsc::channel();
            self.state.downloads_receiver_channel = Some(receiver);
            self.state.downloads_sender_channel = Some(sender);
        }

        let client = self.client.clone();
        let download_dir = self.download_dir.clone();
        let sender = self.state.downloads_sender_channel.clone().unwrap();

        thread::spawn(move || {
            for (filename, username, size) in selected_files.into_iter() {
                match client.download(
                    filename.clone(),
                    username.clone(),
                    size,
                    download_dir.clone(),
                ) {
                    Ok((download, rx)) => {
                        let _ = sender.send((download, rx));
                    }
                    Err(e) => {
                        eprintln!(
                            "Failed to start download for {}: {}",
                            filename, e
                        );
                    }
                }
            }
        });

        // Clear selection
        self.state.results_selected_indices.clear();
    }

    fn update_downloads(&mut self) {
        // Check for new downloads from background thread
        if let Some(ref receiver) = self.state.downloads_receiver_channel {
            while let Ok((download, download_receiver)) = receiver.try_recv() {
                self.state.downloads.push(DownloadEntry {
                    download,
                    receiver: Some(download_receiver),
                });
            }
        }

        // Update download states
        self.state.active_downloads_count = 0;
        for download_entry in &mut self.state.downloads {
            if let Some(ref receiver) = download_entry.receiver {
                while let Ok(status) = receiver.try_recv() {
                    download_entry.download.status = status;
                }
            }

            if matches!(
                download_entry.download.status,
                DownloadStatus::InProgress { .. }
            ) {
                self.state.active_downloads_count += 1;
            }
        }
    }
}

pub fn launch_main_tui(
    terminal: DefaultTerminal,
    client: Arc<Client>,
    download_dir: String,
    max_concurrent_downloads: usize,
    search_timeout: Duration,
) -> Result<()> {
    let tui = MainTui::new(
        client,
        download_dir,
        max_concurrent_downloads,
        search_timeout,
    );
    tui.run(terminal)
}