обновление

src/app.rs

@@ -1,9 +1,9 @@
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 use crate::audio::AudioPlayer;
 use crate::library::{Library, SortMode};
 use crate::state::{RepeatMode, SavedState};
-use crate::track::scan_dir;
+use crate::track::{scan_dir, Track};
 
 #[derive(Clone, Copy, PartialEq)]
 pub enum Panel {
@@ -25,23 +25,33 @@ pub struct App {
     pub active_panel: Panel,
     pub input_mode: InputMode,
     pub search_buffer: String,
-    /// Исходный (неотфильтрованный) список треков — для пересборки библиотеки
-    raw_tracks: Vec<crate::track::Track>,
-    /// Директория с музыкой — чтобы сохранить в state
+    raw_tracks: Vec<Track>,
     music_dir: String,
     pub repeat: RepeatMode,
     pub shuffle: bool,
+    pub show_help: bool,
+    status_set_at: Instant,
 }
 
+const STATUS_RESET_AFTER: Duration = Duration::from_secs(2);
+
 impl App {
     pub fn new(music_dir: &str) -> Result<Self, Box<dyn std::error::Error>> {
-        let tracks = scan_dir(music_dir);
+        let tracks = match crate::state::load_cache(music_dir) {
+            Some(cached) => cached,
+            None => {
+                let scanned = scan_dir(music_dir);
+                crate::state::save_cache(music_dir, &scanned);
+                scanned
+            }
+        };
+
         let library = Library::build(tracks.clone(), SortMode::ByArtist);
 
         let mut app = Self {
             library,
             player: AudioPlayer::new()?,
-            status: "? — help".into(),
+            status: "F1 — помощь".into(),
             playing_index: None,
             active_panel: Panel::Left,
             input_mode: InputMode::Normal,
@@ -50,9 +60,10 @@ impl App {
             music_dir: music_dir.to_string(),
             repeat: RepeatMode::Off,
             shuffle: false,
+            show_help: false,
+            status_set_at: Instant::now(),
         };
 
-        // Восстанавливаем сохранённое состояние
         let saved = crate::state::load();
         if let Some(vol) = saved.volume {
             app.player.set_volume(vol);
@@ -63,20 +74,138 @@ impl App {
         if let Some(sh) = saved.shuffle {
             app.shuffle = sh;
         }
-        if saved.sort_by_filename == Some(true) {
-            app.library = Library::build(app.raw_tracks.clone(), SortMode::ByFilename);
+        if let Some(mode) = saved.sort_mode {
+            if mode != SortMode::ByArtist {
+                app.library = Library::build(app.raw_tracks.clone(), mode);
+            }
         }
 
+        app.restore_playing(&saved);
         Ok(app)
     }
 
+    fn set_status(&mut self, text: String) {
+        self.status = text;
+        self.status_set_at = Instant::now();
+    }
+
+    fn default_status(&self) -> String {
+        match self.playing_index.and_then(|i| self.library.track(i)) {
+            Some(t) => format!("▶ {} — {}", t.artist, t.title),
+            None => "F1 — помощь".into(),
+        }
+    }
+
+    pub fn tick_status(&mut self) {
+        if self.input_mode == InputMode::Search {
+            return;
+        }
+        if self.status_set_at.elapsed() < STATUS_RESET_AFTER {
+            return;
+        }
+        let default = self.default_status();
+        if self.status != default {
+            self.status = default;
+        }
+    }
+
+    fn restore_playing(&mut self, saved: &SavedState) {
+        let Some(path_str) = &saved.last_playing_path else {
+            return;
+        };
+
+        let target_path = std::path::PathBuf::from(path_str);
+        let Some(idx) = self
+            .library
+            .all_tracks
+            .iter()
+            .position(|t| t.path == target_path)
+        else {
+            return;
+        };
+
+        let start_pos = saved.last_playing_pos_secs.map(Duration::from_secs);
+
+        if let Some(track) = self.library.track(idx).cloned() {
+            if self.player.play(&track.path, start_pos).is_ok() {
+                self.playing_index = Some(idx);
+                self.library.sync_with_playing(idx);
+                self.player.toggle_pause();
+                self.set_status(format!("Восстановлен: {} — {}", track.artist, track.title));
+            }
+        }
+    }
+
+    pub fn toggle_help(&mut self) {
+        self.show_help = !self.show_help;
+    }
+
+    pub fn next_track(&mut self) {
+        let total = self.library.all_tracks.len();
+        if total == 0 {
+            self.set_status("Библиотека пуста".into());
+            return;
+        }
+
+        let next = match self.playing_index {
+            Some(i) if i + 1 < total => i + 1,
+            Some(_) => {
+                if self.repeat == RepeatMode::Off {
+                    self.set_status("Конец плейлиста".into());
+                    return;
+                }
+                0
+            }
+            None => 0,
+        };
+
+        self.play_index(next);
+        self.library.sync_with_playing(next);
+    }
+
+    pub fn prev_track(&mut self) {
+        let total = self.library.all_tracks.len();
+        if total == 0 {
+            self.set_status("Библиотека пуста".into());
+            return;
+        }
+
+        let prev = match self.playing_index {
+            Some(0) => {
+                if self.repeat == RepeatMode::Off {
+                    self.set_status("Это первый трек".into());
+                    return;
+                }
+                total - 1
+            }
+            Some(i) => i - 1,
+            None => 0,
+        };
+
+        self.play_index(prev);
+        self.library.sync_with_playing(prev);
+    }
+
     fn persist(&self) {
+        let playing_path = self
+            .playing_index
+            .and_then(|i| self.library.track(i))
+            .map(|t| t.path.to_string_lossy().to_string());
+
+        let playing_pos = if self.playing_index.is_some() {
+            Some(self.player.position().as_secs())
+        } else {
+            None
+        };
+
         let state = SavedState {
             last_path: Some(self.music_dir.clone()),
             volume: Some(self.player.volume()),
-            sort_by_filename: Some(self.library.sort_mode == SortMode::ByFilename),
+            sort_mode: Some(self.library.sort_mode),
             repeat: Some(self.repeat),
             shuffle: Some(self.shuffle),
+            last_playing_path: playing_path,
+            last_playing_pos_secs: playing_pos,
         };
         crate::state::save(&state);
     }
@@ -85,40 +214,39 @@ impl App {
         self.persist();
     }
 
-    // ── Поиск ──────────────────────────────────────────────────
-
     pub fn start_search(&mut self) {
         self.input_mode = InputMode::Search;
         self.search_buffer.clear();
-        self.status = "Поиск: ".into();
+        self.status_set_at = Instant::now();
     }
 
     pub fn cancel_search(&mut self) {
         self.input_mode = InputMode::Normal;
         self.search_buffer.clear();
         self.rebuild_library();
-        self.status = "Поиск отменён".into();
+        self.set_status("Поиск отменён".into());
     }
 
     pub fn commit_search(&mut self) {
         self.input_mode = InputMode::Normal;
-        self.status = if self.search_buffer.is_empty() {
-            "Фильтр сброшен".into()
+        let msg = if self.search_buffer.is_empty() {
+            "Фильтр сброшен".to_string()
         } else {
             format!("Фильтр: {}", self.search_buffer)
         };
+        self.set_status(msg);
     }
 
     pub fn search_push(&mut self, c: char) {
         self.search_buffer.push(c);
         self.rebuild_library();
-        self.status = format!("Поиск: {}", self.search_buffer);
+        self.status_set_at = Instant::now();
     }
 
     pub fn search_pop(&mut self) {
         self.search_buffer.pop();
         self.rebuild_library();
-        self.status = format!("Поиск: {}", self.search_buffer);
+        self.status_set_at = Instant::now();
     }
 
     fn rebuild_library(&mut self) {
@@ -133,8 +261,6 @@ impl App {
         }
     }
 
-    // ── Навигация ──────────────────────────────────────────────
-
     pub fn up(&mut self) {
         match self.active_panel {
             Panel::Left => self.library.artist_move(-1),
@@ -154,27 +280,29 @@ impl App {
             Panel::Left => Panel::Right,
             Panel::Right => Panel::Left,
         };
-        self.status = match self.active_panel {
-            Panel::Left => "Активна: исполнители".into(),
-            Panel::Right => "Активна: альбомы/треки".into(),
+        let msg = match self.active_panel {
+            Panel::Left => "Активна: левая панель".to_string(),
+            Panel::Right => "Активна: правая панель".to_string(),
         };
+        self.set_status(msg);
     }
 
-    /// f — прыжок к играющему треку
     pub fn jump_to_playing(&mut self) {
         if let Some(i) = self.playing_index {
             self.library.sync_with_playing(i);
             self.active_panel = Panel::Right;
-            self.status = "→ к играющему треку".into();
+            self.set_status("→ к играющему треку".into());
         } else {
-            self.status = "Ничего не играет".into();
+            self.set_status("Ничего не играет".into());
         }
     }
 
-    /// g — в начало, G — в конец
     pub fn goto_start(&mut self) {
         match self.active_panel {
-            Panel::Left => self.library.artist_selected = 0,
+            Panel::Left => {
+                self.library.artist_selected = 0;
+                self.library.left_state.select(Some(0));
+            }
             Panel::Right => self.library.right_goto_start(),
         }
     }
@@ -184,24 +312,25 @@ impl App {
             Panel::Left => {
                 if !self.library.artists.is_empty() {
                     self.library.artist_selected = self.library.artists.len() - 1;
+                    self.library
+                        .left_state
+                        .select(Some(self.library.artist_selected));
                 }
             }
             Panel::Right => self.library.right_goto_end(),
         }
     }
 
-    // ── Playback ───────────────────────────────────────────────
-
     pub fn play_index(&mut self, index_in_library: usize) {
         let Some(track) = self.library.track(index_in_library).cloned() else {
             return;
         };
-        match self.player.play(&track.path) {
+        match self.player.play(&track.path, None) {
             Ok(_) => {
-                self.status = format!("▶ {} — {}", track.artist, track.title);
                 self.playing_index = Some(index_in_library);
+                self.set_status(format!("▶ {} — {}", track.artist, track.title));
             }
-            Err(e) => self.status = format!("Ошибка: {}", e),
+            Err(e) => self.set_status(format!("Ошибка: {}", e)),
         }
     }
 
@@ -209,27 +338,25 @@ impl App {
         if let Some(idx) = self.library.right_track_index() {
             self.play_index(idx);
         } else {
-            self.status = "Выделен заголовок альбома".into();
+            self.set_status("Выделен заголовок группы".into());
         }
     }
 
     pub fn stop(&mut self) {
         self.player.stop();
         self.playing_index = None;
-        self.status = "Остановлено".into();
+        self.set_status("Остановлено".into());
     }
 
     pub fn toggle_pause(&mut self) {
         self.player.toggle_pause();
     }
 
-    /// Автопереход с учётом repeat и shuffle
     pub fn maybe_advance(&mut self) {
         if self.playing_index.is_none() || !self.player.is_finished() {
             return;
         }
 
-        // Repeat One — играем тот же трек
         if self.repeat == RepeatMode::One {
             if let Some(i) = self.playing_index {
                 self.play_index(i);
@@ -243,7 +370,6 @@ impl App {
         }
 
         let next = if self.shuffle {
-            // Псевдослучайный выбор без rand-крейта
             let seed = std::time::SystemTime::now()
                 .duration_since(std::time::UNIX_EPOCH)
                 .map(|d| d.as_nanos() as usize)
@@ -256,8 +382,7 @@ impl App {
                     if self.repeat == RepeatMode::All {
                         0
                     } else {
-                        // Off — останавливаемся
-                        self.status = "Конец плейлиста".into();
+                        self.set_status("Конец плейлиста".into());
                         self.playing_index = None;
                         return;
                     }
@@ -275,37 +400,39 @@ impl App {
             RepeatMode::All => RepeatMode::One,
             RepeatMode::One => RepeatMode::Off,
         };
-        self.status = match self.repeat {
-            RepeatMode::Off => "Repeat: off".into(),
-            RepeatMode::All => "Repeat: all".into(),
-            RepeatMode::One => "Repeat: one".into(),
+        let msg = match self.repeat {
+            RepeatMode::Off => "Repeat: off".to_string(),
+            RepeatMode::All => "Repeat: all".to_string(),
+            RepeatMode::One => "Repeat: one".to_string(),
         };
+        self.set_status(msg);
     }
 
     pub fn toggle_shuffle(&mut self) {
         self.shuffle = !self.shuffle;
-        self.status = if self.shuffle {
-            "Shuffle: on".into()
+        let msg = if self.shuffle {
+            "Shuffle: on".to_string()
         } else {
-            "Shuffle: off".into()
+            "Shuffle: off".to_string()
         };
+        self.set_status(msg);
     }
 
-    // ── Громкость, перемотка ───────────────────────────────────
-
     pub fn volume_up(&mut self) {
         self.player.change_volume(0.05);
-        self.status = format!("Громкость: {}%", (self.player.volume() * 100.0) as u32);
+        let msg = format!("Громкость: {}%", (self.player.volume() * 100.0) as u32);
+        self.set_status(msg);
     }
 
     pub fn volume_down(&mut self) {
         self.player.change_volume(-0.05);
-        self.status = format!("Громкость: {}%", (self.player.volume() * 100.0) as u32);
+        let msg = format!("Громкость: {}%", (self.player.volume() * 100.0) as u32);
+        self.set_status(msg);
     }
 
     pub fn seek(&mut self, delta_secs: i64) {
         if self.playing_index.is_none() {
-            self.status = "Ничего не воспроизводится".into();
+            self.set_status("Ничего не воспроизводится".into());
             return;
         }
         let total = self
@@ -317,22 +444,22 @@ impl App {
         match self.player.seek_by(delta_secs, total) {
             Ok(new_pos) => {
                 let sign = if delta_secs >= 0 { "+" } else { "" };
-                self.status = format!(
+                let msg = format!(
                     "Перемотка {}{}с → {:02}:{:02}",
                     sign,
                     delta_secs,
                     new_pos.as_secs() / 60,
                     new_pos.as_secs() % 60,
                 );
+                self.set_status(msg);
             }
-            Err(_) => self.status = "Перемотка недоступна".into(),
+            Err(_) => self.set_status("Перемотка недоступна".into()),
         }
     }
 
-    /// Перемотка по цифрам 1–9 (10%..90%)
     pub fn seek_percent(&mut self, percent: u8) {
         if self.playing_index.is_none() {
-            self.status = "Ничего не воспроизводится".into();
+            self.set_status("Ничего не воспроизводится".into());
             return;
         }
         let total = match self
@@ -342,21 +469,22 @@ impl App {
         {
             Some(d) if !d.is_zero() => d,
             _ => {
-                self.status = "Длительность неизвестна".into();
+                self.set_status("Длительность неизвестна".into());
                 return;
             }
         };
         let target = total.mul_f32(percent as f32 / 100.0);
         match self.player.seek_to(target) {
             Ok(_) => {
-                self.status = format!(
+                let msg = format!(
                     "→ {}% ({:02}:{:02})",
                     percent,
                     target.as_secs() / 60,
                     target.as_secs() % 60,
                 );
+                self.set_status(msg);
             }
-            Err(_) => self.status = "Перемотка недоступна".into(),
+            Err(_) => self.set_status("Перемотка недоступна".into()),
         }
     }
 
@@ -369,7 +497,8 @@ impl App {
 
     pub fn toggle_sort(&mut self) {
         let new_mode = match self.library.sort_mode {
-            SortMode::ByArtist => SortMode::ByFilename,
+            SortMode::ByArtist => SortMode::ByAlbum,
+            SortMode::ByAlbum => SortMode::ByFilename,
             SortMode::ByFilename => SortMode::ByArtist,
         };
 
@@ -391,9 +520,11 @@ impl App {
             self.library.sync_with_playing(i);
         }
 
-        self.status = match new_mode {
-            SortMode::ByArtist => "Сортировка: по артисту/альбому".into(),
-            SortMode::ByFilename => "Сортировка: по имени файла".into(),
+        let msg = match new_mode {
+            SortMode::ByArtist => "Сортировка: по артисту/альбому".to_string(),
+            SortMode::ByAlbum => "Сортировка: по альбому/артисту".to_string(),
+            SortMode::ByFilename => "Сортировка: по имени файла".to_string(),
         };
+        self.set_status(msg);
     }
 }