// src/app.rs
use crate::config::Config;
use crate::error::Result;
use crate::executor;
use crate::menu::{Action, InteractionMode, MenuItem, MenuItemKind, MenuRoot};
use crate::network;
use crossterm::event::{Event as CrosstermEvent, KeyCode, KeyEventKind};
use tokio::sync::mpsc::UnboundedSender;

#[derive(Debug)]
pub enum Event {
    Crossterm(CrosstermEvent),
    MenuLoaded(Result<MenuRoot>),
    ActionCompleted,
    Error(String),
    StructuredCommand(executor::StructuredCommand), // для structured сессии
    StructuredOutput(String),                        // строка вывода от скрипта
    StructuredFinished(i32),                          // код завершения
}

pub struct App {
    pub config: Config,
    pub menu: Option<MenuRoot>,
    pub error: Option<String>,

    // Навигация: стек индексов к текущей категории
    pub breadcrumbs: Vec<usize>,
    pub selected_index: usize, // индекс в текущем списке

    // Состояние popup'а
    pub popup: Option<Popup>,

    // Канал для отправки событий самому себе (из асинхронных задач)
    pub event_tx: UnboundedSender<Event>,
}

pub enum Popup {
    Confirming { action: Action, item_title: String },
    ExecutingBashTerminal { child: tokio::process::Child },
    ExecutingStructured {
        reply_tx: tokio::sync::mpsc::UnboundedSender<String>,
        log_buffer: Vec<String>,
        current_command: Option<executor::StructuredCommand>,
        input_buffer: String,
    },
    Downloading { progress: f32, message: String },
    Message { text: String, level: MessageLevel },
}

#[derive(Debug, Clone, Copy)]
pub enum MessageLevel {
    Info,
    Warn,
    Error,
}

impl App {
    pub fn new(config: Config, event_tx: UnboundedSender<Event>) -> Self {
        Self {
            config,
            menu: None,
            error: None,
            breadcrumbs: Vec::new(),
            selected_index: 0,
            popup: None,
            event_tx,
        }
    }

    pub async fn load_menu(&mut self) {
        let server_url = self.config.server_url.clone();
        let timeout = self.config.timeout_sec;
        let tx = self.event_tx.clone();

        tokio::spawn(async move {
            let result = network::fetch_menu(&server_url, timeout).await;
            let _ = tx.send(Event::MenuLoaded(result));
        });
    }

    /// Возвращает текущий список пунктов меню (категория или корень)
    pub fn current_items(&self) -> Vec<&MenuItem> {
        if self.breadcrumbs.is_empty() {
            self.menu
                .as_ref()
                .map(|root| root.menu.iter().collect())
                .unwrap_or_default()
        } else {
            let mut items = &self.menu.as_ref().unwrap().menu;
            for &idx in &self.breadcrumbs {
                if let MenuItemKind::Category { children } = &items[idx].kind {
                    items = children;
                } else {
                    return vec![];
                }
            }
            items.iter().collect()
        }
    }

    /// Получить выбранный пункт
    pub fn selected_item(&self) -> Option<&MenuItem> {
        let items = self.current_items();
        items.get(self.selected_index).copied()
    }

    /// Обработка событий
    pub async fn handle_event(&mut self, event: Event) -> Result<bool> {
        match event {
            Event::Crossterm(evt) => self.handle_crossterm_event(evt).await,
            Event::MenuLoaded(Ok(menu)) => {
                self.menu = Some(menu);
                self.error = None;
                Ok(false)
            }
            Event::MenuLoaded(Err(e)) => {
                self.error = Some(format!("Ошибка загрузки меню: {}", e));
                Ok(false)
            }
            Event::Error(msg) => {
                self.error = Some(msg);
                Ok(false)
            }
            Event::ActionCompleted => {
                self.popup = None;
                Ok(false)
            }
            Event::StructuredCommand(cmd) => {
                if let Some(Popup::ExecutingStructured { current_command, .. }) = &mut self.popup {
                    *current_command = Some(cmd);
                }
                Ok(false)
            }
            Event::StructuredOutput(line) => {
                if let Some(Popup::ExecutingStructured { log_buffer, .. }) = &mut self.popup {
                    log_buffer.push(line);
                }
                Ok(false)
            }
            Event::StructuredFinished(exit_code) => {
                self.popup = Some(Popup::Message {
                    text: format!("Скрипт завершился с кодом {}", exit_code),
                    level: if exit_code == 0 { MessageLevel::Info } else { MessageLevel::Error },
                });
                Ok(false)
            }
        }
    }

    async fn handle_crossterm_event(&mut self, evt: CrosstermEvent) -> Result<bool> {
        match evt {
            CrosstermEvent::Key(key) if key.kind == KeyEventKind::Press => {
                // Если есть popup, передаём ему
                if let Some(popup) = &mut self.popup {
                    match popup {
                        Popup::Confirming { action, item_title } => {
                            match key.code {
                                KeyCode::Char('y') | KeyCode::Char('Y') => {
                                    let action = action.clone();
                                    self.popup = None;
                                    self.run_action(action).await?;
                                }
                                KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc => {
                                    self.popup = None;
                                }
                                _ => {}
                            }
                            return Ok(false);
                        }
                        Popup::ExecutingStructured {
                            reply_tx,
                            input_buffer,
                            current_command,
                            ..
                        } => {
                            match key.code {
                                KeyCode::Char(c) => {
                                    input_buffer.push(c);
                                }
                                KeyCode::Backspace => {
                                    input_buffer.pop();
                                }
                                KeyCode::Enter => {
                                    if let Some(cmd) = current_command.take() {
                                        let response = match &cmd {
                                            executor::StructuredCommand::Input { .. } => {
                                                input_buffer.clone()
                                            }
                                            executor::StructuredCommand::Confirm { .. } => {
                                                if input_buffer.to_lowercase() == "y" { "y".to_string() } else { "n".to_string() }
                                            }
                                            executor::StructuredCommand::Menu { .. } => {
                                                input_buffer.clone()
                                            }
                                            _ => String::new(),
                                        };
                                        let _ = reply_tx.send(response);
                                        input_buffer.clear();
                                    }
                                }
                                KeyCode::Esc => {
                                    self.popup = None;
                                }
                                _ => {}
                            }
                            return Ok(false);
                        }
                        Popup::Message { .. } => {
                            self.popup = None;
                            return Ok(false);
                        }
                        _ => {}
                    }
                }

                // Навигация по меню
                match key.code {
                    KeyCode::Char('q') => return Ok(true),
                    KeyCode::Up => {
                        let len = self.current_items().len();
                        if len > 0 {
                            self.selected_index = (self.selected_index + len - 1) % len;
                        }
                    }
                    KeyCode::Down => {
                        let len = self.current_items().len();
                        if len > 0 {
                            self.selected_index = (self.selected_index + 1) % len;
                        }
                    }
                    KeyCode::Enter => {
                        if let Some(item) = self.selected_item().cloned() {
                            self.activate_item(item).await?;
                        }
                    }
                    KeyCode::Esc => {
                        if !self.breadcrumbs.is_empty() {
                            self.breadcrumbs.pop();
                            self.selected_index = 0;
                        }
                    }
                    KeyCode::Char('r') | KeyCode::Char('R') => {
                        self.load_menu().await;
                    }
                    _ => {}
                }
            }
            _ => {}
        }
        Ok(false)
    }

    async fn activate_item(&mut self, item: MenuItem) -> Result<()> {
        match item.kind {
            MenuItemKind::Category { children: _ } => {
                // Переход в категорию
                if let Some(idx) = self
                    .current_items()
                    .iter()
                    .position(|i| i.id == item.id)
                {
                    self.breadcrumbs.push(idx);
                    self.selected_index = 0;
                }
            }
            MenuItemKind::Action { action } => {
                // Если требуется подтверждение
                if action.confirm() {
                    self.popup = Some(Popup::Confirming {
                        action,
                        item_title: item.title,
                    });
                } else {
                    self.run_action(action).await?;
                }
            }
        }
        Ok(())
    }

    async fn run_action(&mut self, action: Action) -> Result<()> {
        match action {
            Action::Bash {
                script,
                interaction,
                confirm: _,
            } => match interaction {
                InteractionMode::Terminal => {
                    // Запуск в PTY (упрощённо)
                    self.run_bash_terminal(&script).await?;
                }
                InteractionMode::Structured => {
                    self.run_bash_structured(&script).await?;
                }
            },
            Action::Download {
                url,
                filename: _,
                target_dir: _,
                confirm: _,
            } => {
                // Заглушка
                self.popup = Some(Popup::Message {
                    text: format!("Скачивание {} пока не реализовано", url),
                    level: MessageLevel::Info,
                });
            }
            Action::DownloadAndRun { .. } => {}
            Action::HttpRequest { .. } => {}
        }
        Ok(())
    }

    async fn run_bash_terminal(&mut self, script: &str) -> Result<()> {
        use tokio::process::Command;
        // В реальности здесь нужно создавать PTY через дополнительную библиотеку
        // Пока заглушка
        let child = Command::new("bash")
            .arg("-c")
            .arg(script)
            .spawn()?;
        self.popup = Some(Popup::ExecutingBashTerminal { child });
        Ok(())
    }

    async fn run_bash_structured(&mut self, script: &str) -> Result<()> {
        let (output_rx, command_rx, finished_rx, reply_tx) =
            executor::structured::spawn(script)?;

        let tx_output = self.event_tx.clone();
        tokio::spawn(async move {
            let mut rx = output_rx;
            while let Some(line) = rx.recv().await {
                if tx_output.send(Event::StructuredOutput(line)).is_err() {
                    break;
                }
            }
        });

        let tx_cmd = self.event_tx.clone();
        tokio::spawn(async move {
            let mut rx = command_rx;
            while let Some(cmd) = rx.recv().await {
                if tx_cmd.send(Event::StructuredCommand(cmd)).is_err() {
                    break;
                }
            }
        });

        let tx_finished = self.event_tx.clone();
        tokio::spawn(async move {
            let code = finished_rx.await.unwrap_or(1);
            let _ = tx_finished.send(Event::StructuredFinished(code));
        });

        self.popup = Some(Popup::ExecutingStructured {
            reply_tx,
            log_buffer: Vec::new(),
            current_command: None,
            input_buffer: String::new(),
        });

        Ok(())
    }
}

impl Action {
    fn confirm(&self) -> bool {
        match self {
            Action::Bash { confirm, .. } => *confirm,
            Action::Download { confirm, .. } => *confirm,
            Action::DownloadAndRun { confirm, .. } => *confirm,
            Action::HttpRequest { confirm, .. } => *confirm,
        }
    }
}