initmain

11 files changed, 5052 insertions, 0 deletions

diff --git a/src/adaptive.rs b/src/adaptive.rs
new file mode 100644
index 0000000..ca9e0fc
--- /dev/null
+++ b/src/adaptive.rs
@@ -0,0 +1,72 @@
+use std::sync::Arc;
+use tokio::sync::{OwnedSemaphorePermit, Semaphore};
+
+pub struct AdaptiveConcurrency {
+    current_concurrent: usize,
+    min_concurrent: usize,
+    max_concurrent: usize,
+    failure_streak: usize,
+    success_count: usize,
+    fail_count: usize,
+    semaphore: Arc<Semaphore>,
+}
+
+impl AdaptiveConcurrency {
+    pub fn new(max_concurrent: usize) -> Self {
+        let initial = num_cpus::get().min(max_concurrent);
+        AdaptiveConcurrency {
+            current_concurrent: initial,
+            min_concurrent: 1,
+            max_concurrent,
+            failure_streak: 0,
+            success_count: 0,
+            fail_count: 0,
+            semaphore: Arc::new(Semaphore::new(initial)),
+        }
+    }
+
+    pub fn on_success(&mut self) {
+        self.success_count += 1;
+        self.failure_streak = 0;
+
+        if self.success_count % 10 == 0 && self.current_concurrent < self.max_concurrent {
+            self.current_concurrent += 1;
+            self.semaphore
+                .add_permits(1);
+        }
+    }
+
+    pub fn on_failure(&mut self) {
+        self.fail_count += 1;
+        self.failure_streak += 1;
+
+        if self.failure_streak >= 3 && self.current_concurrent > self.min_concurrent {
+            let new_concurrent = (self.current_concurrent / 2).max(self.min_concurrent);
+            let reduction = self.current_concurrent - new_concurrent;
+            self.current_concurrent = new_concurrent;
+
+            for _ in 0..reduction {
+                let _ = self
+                    .semaphore
+                    .try_acquire();
+            }
+        }
+    }
+
+    pub fn get_concurrent(&self) -> usize {
+        self.current_concurrent
+    }
+
+    pub fn semaphore(&self) -> Arc<Semaphore> {
+        self.semaphore
+            .clone()
+    }
+}
+
+pub async fn acquire_slot(semaphore: &Arc<Semaphore>) -> OwnedSemaphorePermit {
+    semaphore
+        .clone()
+        .acquire_owned()
+        .await
+        .unwrap()
+}
diff --git a/src/cli.rs b/src/cli.rs
new file mode 100644
index 0000000..5063187
--- /dev/null
+++ b/src/cli.rs
@@ -0,0 +1,149 @@
+use clap::{Parser, Subcommand};
+use std::path::PathBuf;
+
+#[derive(Parser)]
+#[command(name = "squid-downloader")]
+#[command(author = "Squid Downloader")]
+#[command(version = "0.1.0")]
+#[command(about = "Download high-quality music from multiple streaming services", long_about = None)]
+#[command(color = clap::ColorChoice::Always)]
+pub struct Cli {
+    #[command(subcommand)]
+    pub command: Commands,
+
+    #[arg(
+        short,
+        long,
+        global = true,
+        help = "Output directory for downloads"
+    )]
+    pub output: Option<PathBuf>,
+
+    #[arg(short, long, global = true, help = "Audio quality", value_parser = ["hires", "lossless", "high", "low", "mp3"])]
+    pub quality: Option<String>,
+
+    #[arg(short, long, global = true, help = "Streaming service", value_parser = ["tidal", "amazon", "soundcloud", "khinsider"])]
+    pub service: Option<String>,
+
+    #[arg(
+        long,
+        global = true,
+        help = "Suppress non-essential output"
+    )]
+    pub quiet: bool,
+
+    #[arg(
+        short = 'j',
+        long,
+        global = true,
+        help = "Max concurrent downloads (default: CPU cores)"
+    )]
+    pub concurrent: Option<usize>,
+
+    #[arg(short = 'd', long, global = true, help = "Directory organization mode", value_parser = ["playlist", "album", "artist", "flat"])]
+    pub dir_mode: Option<String>,
+}
+
+#[derive(Subcommand)]
+pub enum Commands {
+    #[command(about = "Search for tracks")]
+    Search {
+        #[arg(help = "Search query (song title)")]
+        query: String,
+
+        #[arg(
+            short,
+            long,
+            help = "Artist name to improve accuracy"
+        )]
+        artist: Option<String>,
+
+        #[arg(
+            short = 'n',
+            long,
+            default_value = "10",
+            help = "Number of results"
+        )]
+        limit: usize,
+    },
+
+    #[command(about = "Download a single track")]
+    Track {
+        #[arg(help = "Track ID or search query")]
+        input: String,
+
+        #[arg(
+            short,
+            long,
+            help = "Artist name to improve accuracy"
+        )]
+        artist: Option<String>,
+
+        #[arg(
+            short = 'f',
+            long,
+            help = "Download first result without prompting"
+        )]
+        first: bool,
+    },
+
+    #[command(about = "Download an entire album")]
+    Album {
+        #[arg(help = "Album ID or search query")]
+        input: String,
+    },
+
+    #[command(about = "Download tracks from an artist")]
+    Artist {
+        #[arg(help = "Artist ID or search query")]
+        input: String,
+    },
+
+    #[command(about = "Download a playlist")]
+    Playlist {
+        #[arg(help = "Playlist ID or URL")]
+        input: String,
+    },
+
+    #[command(about = "Import and download tracks from CSV file")]
+    Csv {
+        #[arg(help = "Path to CSV file")]
+        file: PathBuf,
+
+        #[arg(
+            short = 't',
+            long,
+            default_value = "0.6",
+            help = "Minimum confidence threshold (0.0-1.0)"
+        )]
+        threshold: f64,
+
+        #[arg(
+            short = 'y',
+            long,
+            help = "Skip confirmation prompt"
+        )]
+        yes: bool,
+    },
+
+    #[command(about = "Show information about a track")]
+    Info {
+        #[arg(help = "Track ID")]
+        id: u64,
+    },
+
+    #[command(about = "Get recommendations for a track")]
+    Recommend {
+        #[arg(help = "Track ID")]
+        id: u64,
+    },
+
+    #[command(about = "List available qualities and services")]
+    List,
+}
+
+impl Cli {
+    pub fn parse() -> Self {
+        Parser::parse()
+    }
+}
diff --git a/src/csv.rs b/src/csv.rs
new file mode 100644
index 0000000..e35d9fc
--- /dev/null
+++ b/src/csv.rs
@@ -0,0 +1,391 @@
+use crate::{
+    error::Result,
+    services::{tidal::TidalService, MusicService},
+    types::TrackInfo,
+};
+use colored::Colorize;
+use serde::Deserialize;
+use std::{fs::File, io::BufReader, path::Path};
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct CsvTrack {
+    #[serde(rename = "Track name")]
+    pub track_name: String,
+    #[serde(rename = "Artist name")]
+    pub artist_name: String,
+    #[serde(rename = "Album")]
+    pub album: Option<String>,
+    #[serde(rename = "Playlist name")]
+    pub playlist_name: Option<String>,
+    #[serde(rename = "Type")]
+    pub track_type: Option<String>,
+    #[serde(rename = "ISRC")]
+    pub isrc: Option<String>,
+    #[serde(rename = "Spotify - id")]
+    pub spotify_id: Option<String>,
+}
+
+impl CsvTrack {
+    pub fn parse_artists(&self) -> Vec<String> {
+        let artists: Vec<String> = self
+            .artist_name
+            .split(
+                &[
+                    ',', '&', '/', ';',
+                ][..],
+            )
+            .map(
+                |s| {
+                    s.trim()
+                        .to_string()
+                },
+            )
+            .filter(|s| !s.is_empty())
+            .collect();
+
+        if artists.is_empty() {
+            vec![
+                self.artist_name
+                    .clone(),
+            ]
+        } else {
+            artists
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct CsvMatchResult {
+    pub csv_track: CsvTrack,
+    pub best_match: Option<TrackInfo>,
+    pub confidence: f64,
+    pub search_attempts: Vec<String>,
+}
+
+#[derive(Clone)]
+pub struct CsvMatcher {
+    tidal: TidalService,
+}
+
+impl CsvMatcher {
+    pub fn new() -> Self {
+        CsvMatcher {
+            tidal: TidalService::new(),
+        }
+    }
+
+    pub async fn find_best_match(&self, csv_track: &CsvTrack) -> Result<CsvMatchResult> {
+        let mut search_attempts = Vec::new();
+        let mut candidates: Vec<TrackInfo> = Vec::new();
+
+        let artists = csv_track.parse_artists();
+
+        for artist in &artists {
+            search_attempts.push(
+                format!(
+                    "'{}' by '{}'",
+                    csv_track.track_name, artist
+                ),
+            );
+
+            if let Ok(results) = self
+                .tidal
+                .search(
+                    &csv_track.track_name,
+                    Some(artist),
+                )
+                .await
+            {
+                candidates.extend(results.tracks);
+            }
+        }
+
+        search_attempts.push(
+            format!(
+                "'{}' (track only)",
+                csv_track.track_name
+            ),
+        );
+
+        if let Ok(results) = self
+            .tidal
+            .search(
+                &csv_track.track_name,
+                None,
+            )
+            .await
+        {
+            candidates.extend(results.tracks);
+        }
+
+        candidates.sort_by_key(|t| t.id);
+        candidates.dedup_by_key(|t| t.id);
+
+        let best = Self::score_and_select_best(
+            &candidates,
+            csv_track,
+        );
+
+        Ok(
+            CsvMatchResult {
+                csv_track: csv_track.clone(),
+                best_match: best
+                    .as_ref()
+                    .map(|(track, _)| track.clone()),
+                confidence: best
+                    .map(|(_, score)| score)
+                    .unwrap_or(0.0),
+                search_attempts,
+            },
+        )
+    }
+
+    pub fn score_and_select_best(
+        candidates: &[TrackInfo],
+        csv_track: &CsvTrack,
+    ) -> Option<(
+        TrackInfo,
+        f64,
+    )> {
+        if candidates.is_empty() {
+            return None;
+        }
+
+        let mut best_score = 0.0_f64;
+        let mut best_match: Option<TrackInfo> = None;
+
+        let csv_title_lower = csv_track
+            .track_name
+            .to_lowercase();
+        let csv_artists = csv_track.parse_artists();
+        let csv_artists_lower: Vec<String> = csv_artists
+            .iter()
+            .map(|a| a.to_lowercase())
+            .collect();
+        let csv_album_lower = csv_track
+            .album
+            .as_ref()
+            .map(|a| a.to_lowercase());
+
+        for candidate in candidates {
+            let mut score = 0.0_f64;
+
+            let title_lower = candidate
+                .title
+                .to_lowercase();
+
+            let title_similarity: f64 = if title_lower == csv_title_lower {
+                1.0
+            } else if title_lower.contains(&csv_title_lower) || csv_title_lower.contains(&title_lower) {
+                0.85
+            } else {
+                strsim::jaro_winkler(
+                    &title_lower,
+                    &csv_title_lower,
+                )
+            };
+            score += title_similarity * 0.45;
+
+            if !candidate
+                .artist
+                .is_empty()
+                && !csv_artists_lower.is_empty()
+            {
+                let artist_lower = candidate
+                    .artist
+                    .to_lowercase();
+
+                let artist_similarity: f64 = csv_artists_lower
+                    .iter()
+                    .map(
+                        |csv_artist| {
+                            let sim: f64 = if artist_lower.contains(csv_artist) || csv_artist.contains(&artist_lower) {
+                                1.0
+                            } else {
+                                strsim::jaro_winkler(
+                                    &artist_lower,
+                                    csv_artist,
+                                )
+                            };
+                            sim
+                        },
+                    )
+                    .fold(
+                        0.0_f64,
+                        |max, sim| max.max(sim),
+                    );
+
+                score += artist_similarity * 0.35;
+            }
+
+            if let Some(ref csv_album) = csv_album_lower {
+                if let Some(ref candidate_album) = candidate.album {
+                    let album_lower = candidate_album.to_lowercase();
+
+                    let album_similarity: f64 = if album_lower == *csv_album {
+                        1.0
+                    } else if album_lower.contains(csv_album) || csv_album.contains(&album_lower) {
+                        0.9
+                    } else {
+                        strsim::jaro_winkler(
+                            &album_lower,
+                            csv_album,
+                        )
+                    };
+
+                    score += album_similarity * 0.20;
+                }
+            } else {
+                score += 0.10;
+            }
+
+            if score > best_score {
+                best_score = score;
+                best_match = Some(candidate.clone());
+            }
+        }
+
+        best_match.map(
+            |m| {
+                (
+                    m, best_score,
+                )
+            },
+        )
+    }
+}
+
+pub fn parse_csv_file(path: &Path) -> Result<Vec<CsvTrack>> {
+    let file = File::open(path)?;
+    let reader = BufReader::new(file);
+
+    let mut csv_r = csv::Reader::from_reader(reader);
+    let mut tracks = Vec::new();
+
+    for result in csv_r.deserialize() {
+        let track: CsvTrack = result?;
+        tracks.push(track);
+    }
+
+    Ok(tracks)
+}
+
+pub fn print_csv_summary(results: &[CsvMatchResult]) {
+    println!();
+    println!(
+        "{}",
+        "═"
+            .repeat(70)
+            .bright_blue()
+    );
+    println!(
+        "{}",
+        "CSV Import Summary"
+            .cyan()
+            .bold()
+    );
+    println!(
+        "{}",
+        "═"
+            .repeat(70)
+            .bright_blue()
+    );
+
+    let matched = results
+        .iter()
+        .filter(
+            |r| {
+                r.best_match
+                    .is_some()
+            },
+        )
+        .count();
+    let unmatched = results.len() - matched;
+
+    println!(
+        "{} {} / {} {}",
+        "Matched:".green(),
+        matched
+            .to_string()
+            .green()
+            .bold(),
+        "Unmatched:".red(),
+        unmatched
+            .to_string()
+            .red()
+    );
+    println!();
+
+    for result in results {
+        match &result.best_match {
+            Some(track) => {
+                let confidence_color = if result.confidence > 0.8 {
+                    "✓".green()
+                } else if result.confidence > 0.6 {
+                    "~".yellow()
+                } else {
+                    "?".red()
+                };
+
+                println!(
+                    "  {} {} {} {}",
+                    confidence_color,
+                    format!(
+                        "[{:.0}%]",
+                        result.confidence * 100.0
+                    )
+                    .dimmed(),
+                    result
+                        .csv_track
+                        .track_name
+                        .white(),
+                    format!(
+                        "→ {}",
+                        track.title
+                    )
+                    .cyan()
+                );
+                println!(
+                    "      {} {}",
+                    "Artist:".dimmed(),
+                    track
+                        .artist
+                        .white()
+                );
+                if let Some(ref album) = track.album {
+                    println!(
+                        "      {} {}",
+                        "Album:".dimmed(),
+                        album.white()
+                    );
+                }
+            }
+            None => {
+                println!(
+                    "  {} {}",
+                    "✗".red(),
+                    result
+                        .csv_track
+                        .track_name
+                        .white()
+                );
+                println!(
+                    "    {} {}",
+                    "Searched:".dimmed(),
+                    result
+                        .search_attempts
+                        .join(", ")
+                        .white()
+                );
+            }
+        }
+    }
+
+    println!(
+        "{}",
+        "═"
+            .repeat(70)
+            .bright_blue()
+    );
+    println!();
+}
diff --git a/src/download.rs b/src/download.rs
new file mode 100644
index 0000000..c77aaf5
--- /dev/null
+++ b/src/download.rs
@@ -0,0 +1,584 @@
+use crate::{
+    error::{DownloadError, Result},
+    types::*,
+};
+use colored::Colorize;
+use futures::StreamExt;
+use reqwest::{Client, StatusCode};
+use std::{
+    fs::File,
+    io::Write,
+    path::{Path, PathBuf},
+    sync::Arc,
+    time::{Duration, Instant},
+};
+use tokio::sync::Mutex;
+
+const MAX_RETRIES: usize = 5;
+const BACKOFF_DELAYS: [Duration; 5] = [
+    Duration::from_secs(5),
+    Duration::from_secs(15),
+    Duration::from_secs(30),
+    Duration::from_secs(60),
+    Duration::from_secs(120),
+];
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum DirMode {
+    Playlist,
+    Album,
+    Artist,
+    Flat,
+}
+
+#[derive(Debug, Clone)]
+pub struct DownloadProgressUpdate {
+    pub bytes_downloaded: u64,
+    pub total_bytes: Option<u64>,
+    pub speed_bps: Option<f64>,
+}
+
+pub type ProgressCallback = Arc<Mutex<Box<dyn FnMut(DownloadProgressUpdate) + Send>>>;
+
+#[derive(Clone)]
+pub struct DownloadManager {
+    client: Client,
+    output_dir: PathBuf,
+    album: Option<String>,
+    playlist: Option<String>,
+    dir_mode: DirMode,
+}
+
+impl DownloadManager {
+    pub fn new(output_dir: &Path) -> Self {
+        DownloadManager {
+            client: Client::builder()
+                .user_agent("SquidDownloader/0.1.0")
+                .build()
+                .unwrap(),
+            output_dir: output_dir.to_path_buf(),
+            album: None,
+            playlist: None,
+            dir_mode: DirMode::Playlist,
+        }
+    }
+
+    pub fn with_album(mut self, album: Option<&str>) -> Self {
+        self.album = album.map(|s| s.to_string());
+        self
+    }
+
+    pub fn with_playlist(mut self, playlist: Option<&str>) -> Self {
+        self.playlist = playlist.map(|s| s.to_string());
+        self
+    }
+
+    pub fn with_dir_mode(mut self, mode: DirMode) -> Self {
+        self.dir_mode = mode;
+        self
+    }
+
+    fn sanitize_filename(name: &str) -> String {
+        sanitize_filename::sanitize(name)
+    }
+
+    pub fn generate_filename(&self, track: &TrackInfo, quality: &AudioQuality) -> PathBuf {
+        let artist = Self::sanitize_filename(&track.artist);
+        let title = Self::sanitize_filename(&track.title);
+        let extension = quality.file_extension();
+        let filename = format!(
+            "{} - {}.{}",
+            artist, title, extension
+        );
+
+        match self.dir_mode {
+            DirMode::Playlist => {
+                if let Some(ref playlist) = self.playlist {
+                    let playlist_dir = Self::sanitize_filename(playlist);
+                    self.output_dir
+                        .join(playlist_dir)
+                        .join(filename)
+                } else if let Some(ref album) = self.album {
+                    let album_dir = format!(
+                        "{} - {}",
+                        artist,
+                        Self::sanitize_filename(album)
+                    );
+                    self.output_dir
+                        .join(album_dir)
+                        .join(filename)
+                } else {
+                    self.output_dir
+                        .join(filename)
+                }
+            }
+            DirMode::Album => {
+                if let Some(ref album) = self.album {
+                    let album_dir = format!(
+                        "{} - {}",
+                        artist,
+                        Self::sanitize_filename(album)
+                    );
+                    self.output_dir
+                        .join(album_dir)
+                        .join(filename)
+                } else {
+                    self.output_dir
+                        .join(filename)
+                }
+            }
+            DirMode::Artist => self
+                .output_dir
+                .join(&artist)
+                .join(filename),
+            DirMode::Flat => self
+                .output_dir
+                .join(filename),
+        }
+    }
+
+    fn should_retry(status: StatusCode) -> bool {
+        status == StatusCode::TOO_MANY_REQUESTS || status.is_server_error()
+    }
+
+    pub async fn download_file(&self, url: &str, dest: &Path) -> Result<()> {
+        if let Some(parent) = dest.parent() {
+            tokio::fs::create_dir_all(parent).await?;
+        }
+
+        let mut last_error = None;
+
+        for attempt in 0..MAX_RETRIES {
+            let response = self
+                .client
+                .get(url)
+                .send()
+                .await;
+
+            match response {
+                Ok(resp) => {
+                    let status = resp.status();
+
+                    if status.is_success() {
+                        let mut file = File::create(dest)?;
+                        let bytes = resp
+                            .bytes()
+                            .await?;
+                        file.write_all(&bytes)?;
+                        return Ok(());
+                    }
+
+                    let error = DownloadError::DownloadFailed(
+                        format!(
+                            "HTTP status: {}",
+                            status
+                        ),
+                    );
+
+                    if !Self::should_retry(status) || attempt == MAX_RETRIES - 1 {
+                        return Err(error);
+                    }
+
+                    last_error = Some(error);
+                }
+                Err(e) => {
+                    if attempt == MAX_RETRIES - 1 {
+                        return Err(DownloadError::NetworkError(e));
+                    }
+                    last_error = Some(DownloadError::NetworkError(e));
+                }
+            }
+
+            tokio::time::sleep(BACKOFF_DELAYS[attempt]).await;
+        }
+
+        Err(last_error.unwrap_or(DownloadError::DownloadFailed("Max retries exceeded".to_string())))
+    }
+
+    pub async fn download_file_with_progress<F>(&self, url: &str, dest: &Path, mut progress_callback: F) -> Result<u64>
+    where
+        F: FnMut(DownloadProgressUpdate) + Send,
+    {
+        if let Some(parent) = dest.parent() {
+            tokio::fs::create_dir_all(parent).await?;
+        }
+
+        let mut last_error = None;
+
+        for attempt in 0..MAX_RETRIES {
+            let response = self
+                .client
+                .get(url)
+                .send()
+                .await;
+
+            match response {
+                Ok(resp) => {
+                    let status = resp.status();
+
+                    if status.is_success() {
+                        let total_size = resp.content_length();
+                        let mut file = File::create(dest)?;
+                        let mut downloaded: u64 = 0;
+                        let start_time = Instant::now();
+                        let mut last_update = Instant::now();
+
+                        let mut stream = resp.bytes_stream();
+
+                        while let Some(chunk_result) = stream
+                            .next()
+                            .await
+                        {
+                            let chunk = chunk_result.map_err(DownloadError::NetworkError)?;
+                            file.write_all(&chunk)?;
+                            downloaded += chunk.len() as u64;
+
+                            let now = Instant::now();
+                            let elapsed = now
+                                .duration_since(last_update)
+                                .as_millis();
+                            if elapsed >= 100 || downloaded == total_size.unwrap_or(0) {
+                                let total_elapsed = start_time
+                                    .elapsed()
+                                    .as_secs_f64();
+                                let speed = if total_elapsed > 0.0 {
+                                    Some((downloaded as f64) / total_elapsed)
+                                } else {
+                                    None
+                                };
+
+                                progress_callback(
+                                    DownloadProgressUpdate {
+                                        bytes_downloaded: downloaded,
+                                        total_bytes: total_size,
+                                        speed_bps: speed,
+                                    },
+                                );
+
+                                last_update = now;
+                            }
+                        }
+
+                        return Ok(downloaded);
+                    }
+
+                    let error = DownloadError::DownloadFailed(
+                        format!(
+                            "HTTP status: {}",
+                            status
+                        ),
+                    );
+
+                    if !Self::should_retry(status) || attempt == MAX_RETRIES - 1 {
+                        return Err(error);
+                    }
+
+                    last_error = Some(error);
+                }
+                Err(e) => {
+                    if attempt == MAX_RETRIES - 1 {
+                        return Err(DownloadError::NetworkError(e));
+                    }
+                    last_error = Some(DownloadError::NetworkError(e));
+                }
+            }
+
+            tokio::time::sleep(BACKOFF_DELAYS[attempt]).await;
+        }
+
+        Err(last_error.unwrap_or(DownloadError::DownloadFailed("Max retries exceeded".to_string())))
+    }
+
+    pub async fn download_segments(&self, segment_urls: &[String], dest: &Path) -> Result<()> {
+        if let Some(parent) = dest.parent() {
+            tokio::fs::create_dir_all(parent).await?;
+        }
+
+        let mut file = File::create(dest)?;
+        let total = segment_urls.len();
+
+        for (i, url) in segment_urls
+            .iter()
+            .enumerate()
+        {
+            let mut segment_error = None;
+
+            for attempt in 0..MAX_RETRIES {
+                let response = self
+                    .client
+                    .get(url)
+                    .send()
+                    .await;
+
+                match response {
+                    Ok(resp) => {
+                        let status = resp.status();
+
+                        if status.is_success() {
+                            let bytes = resp
+                                .bytes()
+                                .await?;
+                            file.write_all(&bytes)?;
+                            break;
+                        }
+
+                        let error = DownloadError::SegmentDownloadFailed(
+                            format!(
+                                "Segment {}/{} failed: {}",
+                                i + 1,
+                                total,
+                                status
+                            ),
+                        );
+
+                        if !Self::should_retry(status) || attempt == MAX_RETRIES - 1 {
+                            let _ = std::fs::remove_file(dest);
+                            return Err(error);
+                        }
+
+                        segment_error = Some(error);
+                    }
+                    Err(e) => {
+                        let error = DownloadError::NetworkError(e);
+                        if attempt == MAX_RETRIES - 1 {
+                            let _ = std::fs::remove_file(dest);
+                            return Err(error);
+                        }
+                        segment_error = Some(
+                            DownloadError::SegmentDownloadFailed(
+                                format!(
+                                    "Segment {}/{} network error",
+                                    i + 1,
+                                    total
+                                ),
+                            ),
+                        );
+                    }
+                }
+
+                tokio::time::sleep(BACKOFF_DELAYS[attempt]).await;
+            }
+
+            if let Some(e) = segment_error {
+                let _ = std::fs::remove_file(dest);
+                return Err(e);
+            }
+        }
+
+        Ok(())
+    }
+
+    pub async fn download_segments_with_progress<F>(&self, segment_urls: &[String], dest: &Path, mut progress_callback: F) -> Result<u64>
+    where
+        F: FnMut(DownloadProgressUpdate) + Send,
+    {
+        if let Some(parent) = dest.parent() {
+            tokio::fs::create_dir_all(parent).await?;
+        }
+
+        let mut file = File::create(dest)?;
+        let total = segment_urls.len();
+        let mut downloaded: u64 = 0;
+        let start_time = Instant::now();
+        let mut last_update = Instant::now();
+
+        for (i, url) in segment_urls
+            .iter()
+            .enumerate()
+        {
+            let mut segment_error = None;
+
+            for attempt in 0..MAX_RETRIES {
+                let response = self
+                    .client
+                    .get(url)
+                    .send()
+                    .await;
+
+                match response {
+                    Ok(resp) => {
+                        let status = resp.status();
+
+                        if status.is_success() {
+                            let bytes = resp
+                                .bytes()
+                                .await?;
+                            file.write_all(&bytes)?;
+                            downloaded += bytes.len() as u64;
+
+                            let now = Instant::now();
+                            let elapsed = now
+                                .duration_since(last_update)
+                                .as_millis();
+                            if elapsed >= 100 || i == total - 1 {
+                                let total_elapsed = start_time
+                                    .elapsed()
+                                    .as_secs_f64();
+                                let speed = if total_elapsed > 0.0 {
+                                    Some((downloaded as f64) / total_elapsed)
+                                } else {
+                                    None
+                                };
+
+                                progress_callback(
+                                    DownloadProgressUpdate {
+                                        bytes_downloaded: downloaded,
+                                        total_bytes: None,
+                                        speed_bps: speed,
+                                    },
+                                );
+
+                                last_update = now;
+                            }
+                            break;
+                        }
+
+                        let error = DownloadError::SegmentDownloadFailed(
+                            format!(
+                                "Segment {}/{} failed: {}",
+                                i + 1,
+                                total,
+                                status
+                            ),
+                        );
+
+                        if !Self::should_retry(status) || attempt == MAX_RETRIES - 1 {
+                            let _ = std::fs::remove_file(dest);
+                            return Err(error);
+                        }
+
+                        segment_error = Some(error);
+                    }
+                    Err(e) => {
+                        let error = DownloadError::NetworkError(e);
+                        if attempt == MAX_RETRIES - 1 {
+                            let _ = std::fs::remove_file(dest);
+                            return Err(error);
+                        }
+                        segment_error = Some(
+                            DownloadError::SegmentDownloadFailed(
+                                format!(
+                                    "Segment {}/{} network error",
+                                    i + 1,
+                                    total
+                                ),
+                            ),
+                        );
+                    }
+                }
+
+                tokio::time::sleep(BACKOFF_DELAYS[attempt]).await;
+            }
+
+            if let Some(e) = segment_error {
+                let _ = std::fs::remove_file(dest);
+                return Err(e);
+            }
+        }
+
+        Ok(downloaded)
+    }
+
+    pub async fn download_from_manifest(&self, manifest: &DownloadManifest, track: &TrackInfo) -> Result<PathBuf> {
+        let dest = self.generate_filename(
+            track,
+            &manifest.quality,
+        );
+
+        if let Some(ref bit_depth) = manifest.bit_depth {
+            if let Some(ref sample_rate) = manifest.sample_rate {
+                let sample_str = format_sample_rate(*sample_rate);
+                println!(
+                    "  {} {}, {}-bit FLAC",
+                    "Format:".cyan(),
+                    sample_str.white(),
+                    bit_depth
+                        .to_string()
+                        .white()
+                );
+            }
+        }
+
+        println!(
+            "  {} {}",
+            "Output:".cyan(),
+            dest.display()
+                .to_string()
+                .green()
+        );
+
+        let result = if let Some(ref url) = manifest.url {
+            self.download_file(
+                url, &dest,
+            )
+            .await
+        } else if let Some(ref segments) = manifest.segment_urls {
+            println!(
+                "  {} {} segments",
+                "Downloading:".cyan(),
+                segments
+                    .len()
+                    .to_string()
+                    .white()
+            );
+            self.download_segments(
+                segments, &dest,
+            )
+            .await
+        } else {
+            Err(DownloadError::NoDownloadUrl)
+        };
+
+        if result.is_err() {
+            let _ = std::fs::remove_file(&dest);
+        }
+
+        result?;
+        Ok(dest)
+    }
+
+    pub async fn download_from_manifest_with_progress<F>(&self, manifest: &DownloadManifest, track: &TrackInfo, mut progress_callback: F) -> Result<PathBuf>
+    where
+        F: FnMut(DownloadProgressUpdate) + Send,
+    {
+        let dest = self.generate_filename(
+            track,
+            &manifest.quality,
+        );
+
+        let result = if let Some(ref url) = manifest.url {
+            self.download_file_with_progress(
+                url,
+                &dest,
+                &mut progress_callback,
+            )
+            .await?;
+        } else if let Some(ref segments) = manifest.segment_urls {
+            self.download_segments_with_progress(
+                segments,
+                &dest,
+                &mut progress_callback,
+            )
+            .await?;
+        } else {
+            return Err(DownloadError::NoDownloadUrl);
+        };
+
+        Ok(dest)
+    }
+}
+
+fn format_sample_rate(sample_rate: u32) -> String {
+    if sample_rate >= 1000 {
+        let khz = sample_rate as f64 / 1000.0;
+        format!(
+            "{:.1}kHz",
+            khz
+        )
+    } else {
+        format!(
+            "{}Hz",
+            sample_rate
+        )
+    }
+}
diff --git a/src/error.rs b/src/error.rs
new file mode 100644
index 0000000..2b5954f
--- /dev/null
+++ b/src/error.rs
@@ -0,0 +1,111 @@
+use colored::Colorize;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum DownloadError {
+    #[error("Network request failed: {0}")]
+    NetworkError(#[from] reqwest::Error),
+
+    #[error("Failed to parse JSON response: {0}")]
+    JsonParseError(#[from] serde_json::Error),
+
+    #[error("Failed to decode base64 manifest: {0}")]
+    Base64DecodeError(#[from] base64::DecodeError),
+
+    #[error("Failed to parse XML manifest: {0}")]
+    XmlParseError(String),
+
+    #[error("Track not found: {0}")]
+    TrackNotFound(String),
+
+    #[error("Album not found: {0}")]
+    AlbumNotFound(String),
+
+    #[error("Artist not found: {0}")]
+    ArtistNotFound(String),
+
+    #[error("Playlist not found: {0}")]
+    PlaylistNotFound(String),
+
+    #[error("No download URL available for the requested quality")]
+    NoDownloadUrl,
+
+    #[error("Rate limited. Please wait before making more requests")]
+    RateLimited,
+
+    #[error("IO error: {0}")]
+    IoError(#[from] std::io::Error),
+
+    #[error("Download failed: {0}")]
+    DownloadFailed(String),
+
+    #[error("Segment download failed: {0}")]
+    SegmentDownloadFailed(String),
+
+    #[error("CSV parsing error: {0}")]
+    CsvError(String),
+
+    #[error("Service unavailable: {0}")]
+    ServiceUnavailable(String),
+}
+
+impl From<csv::Error> for DownloadError {
+    fn from(err: csv::Error) -> Self {
+        DownloadError::CsvError(err.to_string())
+    }
+}
+
+impl DownloadError {
+    pub fn pretty_print(&self) {
+        let error_type = match self {
+            DownloadError::NetworkError(_) => "Network Error",
+            DownloadError::JsonParseError(_) => "Parse Error",
+            DownloadError::Base64DecodeError(_) => "Decode Error",
+            DownloadError::XmlParseError(_) => "XML Error",
+            DownloadError::TrackNotFound(_) => "Not Found",
+            DownloadError::AlbumNotFound(_) => "Not Found",
+            DownloadError::ArtistNotFound(_) => "Not Found",
+            DownloadError::PlaylistNotFound(_) => "Not Found",
+            DownloadError::NoDownloadUrl => "Download Error",
+            DownloadError::RateLimited => "Rate Limit",
+            DownloadError::IoError(_) => "IO Error",
+            DownloadError::DownloadFailed(_) => "Download Error",
+            DownloadError::SegmentDownloadFailed(_) => "Download Error",
+            DownloadError::CsvError(_) => "CSV Error",
+            DownloadError::ServiceUnavailable(_) => "Service Error",
+        };
+
+        eprintln!();
+        eprintln!(
+            "{}",
+            "╭─────────────────────────────────────╮".bright_red()
+        );
+        eprintln!(
+            "{} {} {:>24} {}",
+            "│".bright_red(),
+            error_type
+                .red()
+                .bold(),
+            "",
+            "│".bright_red()
+        );
+        eprintln!(
+            "{}",
+            "├─────────────────────────────────────┤".bright_red()
+        );
+        eprintln!(
+            "{} {} {}",
+            "│".bright_red(),
+            self.to_string()
+                .white(),
+            "│".bright_red()
+        );
+        eprintln!(
+            "{}",
+            "╰─────────────────────────────────────╯".bright_red()
+        );
+        eprintln!();
+    }
+}
+
+pub type Result<T> = std::result::Result<T, DownloadError>;
diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..35f31ff
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,2330 @@
+mod adaptive;
+mod cli;
+mod csv;
+mod download;
+mod error;
+mod progress;
+mod services;
+mod types;
+mod ui;
+
+use adaptive::{acquire_slot, AdaptiveConcurrency};
+use cli::{Cli, Commands};
+use colored::Colorize;
+use csv::{CsvMatchResult, CsvMatcher};
+use download::{DirMode, DownloadManager, DownloadProgressUpdate};
+use error::{DownloadError, Result};
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
+use progress::DownloadProgress;
+use regex::Regex;
+use services::{tidal::TidalService, MusicService};
+use std::{
+    path::PathBuf,
+    sync::{
+        atomic::{AtomicU64, AtomicUsize, Ordering},
+        Arc,
+    },
+    time::Duration,
+};
+use tokio::sync::Mutex;
+use types::{AudioQuality, Service};
+use ui::Ui;
+
+const NOT_FOUND_DELAY_MS: u64 = 1000;
+const RATE_LIMIT_DELAY_MS: u64 = 15000;
+const CONSECUTIVE_FAILURE_THRESHOLD: usize = 3;
+const RETRY_BACKOFF_SECS: [u64; 5] = [
+    5, 15, 30, 60, 120,
+];
+
+pub struct ProgressManager {
+    multi: MultiProgress,
+    download_bars: Vec<ProgressBar>,
+    total_bar: ProgressBar,
+    status_bar: ProgressBar,
+    matched_count: Arc<AtomicU64>,
+    downloaded_count: Arc<AtomicU64>,
+    total_tracks: u64,
+}
+
+impl ProgressManager {
+    pub fn new(max_concurrent: usize, total_tracks: u64) -> Self {
+        let multi = MultiProgress::new();
+
+        let mut download_bars = Vec::new();
+        for i in 0..max_concurrent {
+            let pb = multi.add(ProgressBar::new(0));
+            pb.set_style(
+                ProgressStyle::default_bar()
+                    .template(
+                        &format!(
+                            "Slot {}: [{{bar:25.cyan/blue}}] {{msg}}",
+                            i + 1
+                        ),
+                    )
+                    .unwrap()
+                    .progress_chars("█▓▒░ "),
+            );
+            pb.set_message(
+                "Idle"
+                    .dimmed()
+                    .to_string(),
+            );
+            pb.enable_steady_tick(Duration::from_millis(100));
+            download_bars.push(pb);
+        }
+
+        let separator = multi.add(ProgressBar::new_spinner());
+        separator.set_style(
+            ProgressStyle::default_spinner()
+                .template("─────────────────────────────────────────────────────────────────────")
+                .unwrap(),
+        );
+        separator.finish();
+
+        let total_bar = multi.add(ProgressBar::new(total_tracks * 2));
+        total_bar.set_style(
+            ProgressStyle::default_bar()
+                .template("Progress: [{bar:40.cyan/blue}] {pos}/{len} ({eta}) {percent}%")
+                .unwrap()
+                .progress_chars("█▓▒░ "),
+        );
+
+        let status_bar = multi.add(ProgressBar::new_spinner());
+        status_bar.set_style(
+            ProgressStyle::default_spinner()
+                .template("Stage: {msg}")
+                .unwrap(),
+        );
+        status_bar.set_message("1/2 - Matching tracks".to_string());
+        status_bar.enable_steady_tick(Duration::from_millis(100));
+
+        Self {
+            multi,
+            download_bars,
+            total_bar,
+            status_bar,
+            matched_count: Arc::new(AtomicU64::new(0)),
+            downloaded_count: Arc::new(AtomicU64::new(0)),
+            total_tracks,
+        }
+    }
+
+    pub fn set_stage(&self, stage: &str) {
+        self.status_bar
+            .set_message(stage.to_string());
+        self.status_bar
+            .tick();
+    }
+
+    pub fn inc_matched(&self) {
+        self.matched_count
+            .fetch_add(
+                1,
+                Ordering::Relaxed,
+            );
+        self.total_bar
+            .inc(1);
+        self.update_total_message();
+    }
+
+    pub fn inc_downloaded(&self) {
+        self.downloaded_count
+            .fetch_add(
+                1,
+                Ordering::Relaxed,
+            );
+        self.total_bar
+            .inc(1);
+        self.update_total_message();
+    }
+
+    fn update_total_message(&self) {
+        let matched = self
+            .matched_count
+            .load(Ordering::Relaxed);
+        let downloaded = self
+            .downloaded_count
+            .load(Ordering::Relaxed);
+        self.total_bar
+            .set_message(
+                format!(
+                    "{} matched + {} downloaded",
+                    matched, downloaded
+                ),
+            );
+    }
+
+    pub fn set_downloading(&self, slot: usize, artist: &str, title: &str) {
+        if slot
+            < self
+                .download_bars
+                .len()
+        {
+            self.download_bars[slot].set_message(
+                format!(
+                    "{} - {}",
+                    artist, title
+                ),
+            );
+            self.download_bars[slot].set_length(0);
+            self.download_bars[slot].set_position(0);
+        }
+    }
+
+    pub fn update_download_progress(&self, slot: usize, progress: DownloadProgressUpdate) {
+        if slot
+            < self
+                .download_bars
+                .len()
+        {
+            if let Some(total) = progress.total_bytes {
+                self.download_bars[slot].set_length(total);
+            }
+            self.download_bars[slot].set_position(progress.bytes_downloaded);
+            if let Some(speed) = progress.speed_bps {
+                let speed_str = format_speed(speed);
+                self.download_bars[slot].set_message(
+                    format!(
+                        "{} ({})",
+                        self.download_bars[slot]
+                            .message()
+                            .split_whitespace()
+                            .next()
+                            .unwrap_or(""),
+                        speed_str
+                    ),
+                );
+            }
+        }
+    }
+
+    pub fn finish_download(&self, slot: usize, success: bool, artist: &str, title: &str) {
+        if slot
+            < self
+                .download_bars
+                .len()
+        {
+            if success {
+                self.download_bars[slot].set_message(
+                    format!(
+                        "✓ {} - {}",
+                        artist.green(),
+                        title
+                    ),
+                );
+            } else {
+                self.download_bars[slot].set_message(
+                    format!(
+                        "✗ {} - {}",
+                        artist.red(),
+                        title
+                    ),
+                );
+            }
+            self.download_bars[slot].finish();
+        }
+    }
+
+    pub fn clear_slot(&self, slot: usize) {
+        if slot
+            < self
+                .download_bars
+                .len()
+        {
+            self.download_bars[slot].set_message(
+                "Idle"
+                    .dimmed()
+                    .to_string(),
+            );
+            self.download_bars[slot].set_length(0);
+            self.download_bars[slot].set_position(0);
+        }
+    }
+
+    pub fn update_download(&self, slot: usize, msg: String) {
+        if slot
+            < self
+                .download_bars
+                .len()
+        {
+            self.download_bars[slot].set_message(msg);
+            self.download_bars[slot].tick();
+        }
+    }
+
+    pub fn inc_total(&self) {
+        self.total_bar
+            .inc(1);
+    }
+
+    pub fn finish(&self) {
+        for bar in &self.download_bars {
+            bar.finish_and_clear();
+        }
+        self.total_bar
+            .finish();
+        self.status_bar
+            .finish();
+    }
+
+    pub fn finish_with_message(&self, msg: &str) {
+        for bar in &self.download_bars {
+            bar.finish_and_clear();
+        }
+        self.total_bar
+            .finish_with_message(msg.to_string());
+        self.status_bar
+            .finish();
+    }
+
+    pub fn clear(&self) {
+        for bar in &self.download_bars {
+            bar.finish_and_clear();
+        }
+        self.total_bar.finish_and_clear();
+        self.status_bar.finish_and_clear();
+    }
+
+    pub fn reset_for_download(&self, download_count: u64) {
+        for bar in &self.download_bars {
+            bar.reset();
+            bar.set_message("Idle".dimmed().to_string());
+            bar.set_length(0);
+            bar.set_position(0);
+        }
+        self.total_bar.set_length(self.total_tracks + download_count);
+    }
+}
+
+fn format_speed(bytes_per_sec: f64) -> String {
+    if bytes_per_sec >= 1_000_000.0 {
+        format!(
+            "{:.1} MB/s",
+            bytes_per_sec / 1_000_000.0
+        )
+    } else if bytes_per_sec >= 1_000.0 {
+        format!(
+            "{:.1} KB/s",
+            bytes_per_sec / 1_000.0
+        )
+    } else {
+        format!(
+            "{:.0} B/s",
+            bytes_per_sec
+        )
+    }
+}
+
+pub struct SimpleProgressManager {
+    multi: MultiProgress,
+    download_bars: Vec<ProgressBar>,
+    total_bar: ProgressBar,
+}
+
+impl SimpleProgressManager {
+    pub fn new(max_concurrent: usize, total: u64, prefix: &str) -> Self {
+        let multi = MultiProgress::new();
+
+        let mut download_bars = Vec::new();
+        for _ in 0..max_concurrent {
+            let pb = multi.add(ProgressBar::new_spinner());
+            pb.set_style(
+                ProgressStyle::default_spinner()
+                    .template("{msg}")
+                    .unwrap(),
+            );
+            pb.set_message(
+                "Idle"
+                    .dimmed()
+                    .to_string(),
+            );
+            pb.enable_steady_tick(Duration::from_millis(100));
+            download_bars.push(pb);
+        }
+
+        let separator = multi.add(ProgressBar::new_spinner());
+        separator.set_style(
+            ProgressStyle::default_spinner()
+                .template("─────────────────────────────────────────────────────────────────────")
+                .unwrap(),
+        );
+        separator.finish();
+
+        let total_bar = multi.add(ProgressBar::new(total));
+        total_bar.set_style(
+            ProgressStyle::default_bar()
+                .template("{prefix}: [{bar:40.cyan/blue}] {pos}/{len} ({eta}) {percent}%")
+                .unwrap()
+                .progress_chars("█▓▒░ "),
+        );
+        total_bar.set_prefix(prefix.to_string());
+
+        Self {
+            multi,
+            download_bars,
+            total_bar,
+        }
+    }
+
+    pub fn update_download(&self, slot: usize, msg: String) {
+        if slot
+            < self
+                .download_bars
+                .len()
+        {
+            self.download_bars[slot].set_message(msg);
+            self.download_bars[slot].tick();
+        }
+    }
+
+    pub fn clear_slot(&self, slot: usize) {
+        if slot
+            < self
+                .download_bars
+                .len()
+        {
+            self.download_bars[slot].set_message(
+                "Idle"
+                    .dimmed()
+                    .to_string(),
+            );
+        }
+    }
+
+    pub fn inc_total(&self) {
+        self.total_bar
+            .inc(1);
+    }
+
+    pub fn finish_with_message(&self, msg: &str) {
+        for bar in &self.download_bars {
+            bar.finish_and_clear();
+        }
+        self.total_bar
+            .finish_with_message(msg.to_string());
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    colored::control::set_override(true);
+    let args = Cli::parse();
+
+    if !args.quiet {
+        Ui::print_banner();
+    }
+
+    let output_dir = args
+        .output
+        .clone()
+        .unwrap_or_else(|| PathBuf::from("./downloads"));
+    let quality = parse_quality(
+        args.quality
+            .as_deref(),
+    );
+    let service = parse_service(
+        args.service
+            .as_deref(),
+    );
+    let max_concurrent = args
+        .concurrent
+        .unwrap_or_else(num_cpus::get);
+    let dir_mode = parse_dir_mode(
+        args.dir_mode
+            .as_deref(),
+    );
+
+    if let Err(e) = run_command(
+        args,
+        &output_dir,
+        quality,
+        service,
+        max_concurrent,
+        dir_mode,
+    )
+    .await
+    {
+        e.pretty_print();
+        std::process::exit(1);
+    }
+}
+
+fn parse_quality(quality: Option<&str>) -> AudioQuality {
+    match quality {
+        Some("hires") => AudioQuality::HiResLossless,
+        Some("lossless") => AudioQuality::Lossless,
+        Some("high") => AudioQuality::High,
+        Some("low") => AudioQuality::Low,
+        Some("mp3") => AudioQuality::Mp3_320,
+        None => AudioQuality::HiResLossless,
+        _ => AudioQuality::HiResLossless,
+    }
+}
+
+fn parse_service(service: Option<&str>) -> Service {
+    match service {
+        Some("tidal") => Service::Tidal,
+        Some("amazon") => Service::AmazonMusic,
+        Some("soundcloud") => Service::SoundCloud,
+        Some("khinsider") => Service::KHInsider,
+        None => Service::Tidal,
+        _ => Service::Tidal,
+    }
+}
+
+fn parse_dir_mode(dir_mode: Option<&str>) -> DirMode {
+    match dir_mode {
+        Some("playlist") => DirMode::Playlist,
+        Some("album") => DirMode::Album,
+        Some("artist") => DirMode::Artist,
+        Some("flat") => DirMode::Flat,
+        None => DirMode::Playlist,
+        _ => DirMode::Playlist,
+    }
+}
+
+async fn ensure_output_dir(output_dir: &PathBuf) -> Result<()> {
+    if !output_dir.exists() {
+        tokio::fs::create_dir_all(output_dir).await?;
+    }
+    Ok(())
+}
+
+async fn run_command(args: Cli, output_dir: &PathBuf, quality: AudioQuality, service: Service, max_concurrent: usize, dir_mode: DirMode) -> Result<()> {
+    match args.command {
+        Commands::Search {
+            query,
+            artist,
+            limit,
+        } => {
+            Ui::print_info(
+                &format!(
+                    "Searching for: {}",
+                    query.cyan()
+                ),
+            );
+
+            let tidal = TidalService::new();
+            let results = tidal
+                .search(
+                    &query,
+                    artist.as_deref(),
+                )
+                .await?;
+
+            if results
+                .tracks
+                .is_empty()
+            {
+                Ui::print_warning("No results found");
+                return Ok(());
+            }
+
+            Ui::print_info(
+                &format!(
+                    "Found {} results",
+                    results
+                        .tracks
+                        .len()
+                        .to_string()
+                        .green()
+                ),
+            );
+            Ui::print_search_results(
+                &results.tracks,
+                limit,
+            );
+        }
+
+        Commands::Track {
+            input,
+            artist,
+            first,
+        } => {
+            ensure_output_dir(output_dir).await?;
+            download_track(
+                &input,
+                artist.as_deref(),
+                first,
+                output_dir,
+                quality,
+                service,
+            )
+            .await?;
+        }
+
+        Commands::Album {
+            input,
+        } => {
+            ensure_output_dir(output_dir).await?;
+            download_album(
+                &input,
+                output_dir,
+                quality,
+                service,
+                max_concurrent,
+            )
+            .await?;
+        }
+
+        Commands::Artist {
+            input,
+        } => {
+            download_artist(
+                &input, output_dir, quality, service,
+            )
+            .await?;
+        }
+
+        Commands::Playlist {
+            input,
+        } => {
+            ensure_output_dir(output_dir).await?;
+            download_playlist(
+                &input,
+                output_dir,
+                quality,
+                service,
+                max_concurrent,
+            )
+            .await?;
+        }
+
+        Commands::Csv {
+            file,
+            threshold,
+            yes,
+        } => {
+            ensure_output_dir(output_dir).await?;
+            download_from_csv(
+                &file,
+                threshold,
+                yes,
+                output_dir,
+                quality,
+                max_concurrent,
+                dir_mode,
+            )
+            .await?;
+        }
+
+        Commands::Info {
+            id,
+        } => {
+            let tidal = TidalService::new();
+            let track = tidal
+                .get_track_info(id)
+                .await?;
+            Ui::print_track_detail(
+                &track, None,
+            );
+        }
+
+        Commands::Recommend {
+            id,
+        } => {
+            Ui::print_info("Fetching recommendations...");
+            let tidal = TidalService::new();
+            let results = tidal
+                .search(
+                    "recommendations",
+                    None,
+                )
+                .await?;
+            Ui::print_search_results(
+                &results.tracks,
+                10,
+            );
+            let _ = id;
+        }
+
+        Commands::List => {
+            Ui::print_services();
+            Ui::print_qualities();
+        }
+    }
+
+    Ok(())
+}
+
+async fn download_track(input: &str, artist: Option<&str>, first: bool, output_dir: &PathBuf, quality: AudioQuality, _service: Service) -> Result<()> {
+    let tidal = TidalService::new();
+
+    let track_id = if input
+        .parse::<u64>()
+        .is_ok()
+    {
+        input
+            .parse::<u64>()
+            .unwrap()
+    } else {
+        Ui::print_info(
+            &format!(
+                "Searching for: {}",
+                input.cyan()
+            ),
+        );
+
+        let search_results = tidal
+            .search(
+                input, artist,
+            )
+            .await?;
+
+        if search_results
+            .tracks
+            .is_empty()
+        {
+            return Err(DownloadError::TrackNotFound(input.to_string()));
+        }
+
+        let selected_index = if first {
+            0
+        } else {
+            Ui::select_track(&search_results.tracks).ok_or_else(|| DownloadError::TrackNotFound("No track selected".to_string()))?
+        };
+
+        let track = &search_results.tracks[selected_index];
+        Ui::print_info(
+            &format!(
+                "Selected: {} by {}",
+                track
+                    .title
+                    .cyan(),
+                track
+                    .artist
+                    .white()
+            ),
+        );
+
+        track.id
+    };
+
+    let track_info = tidal
+        .get_track_info(track_id)
+        .await?;
+    let manifest = tidal
+        .get_manifest(
+            track_id, quality,
+        )
+        .await?;
+
+    let downloader = DownloadManager::new(output_dir);
+    downloader
+        .download_from_manifest(
+            &manifest,
+            &track_info,
+        )
+        .await?;
+
+    Ui::print_success("Download complete!");
+
+    Ok(())
+}
+
+async fn download_album(input: &str, output_dir: &PathBuf, quality: AudioQuality, _service: Service, max_concurrent: usize) -> Result<()> {
+    let tidal = TidalService::new();
+
+    let album_id = if input
+        .parse::<u64>()
+        .is_ok()
+    {
+        input
+            .parse::<u64>()
+            .unwrap()
+    } else {
+        Ui::print_info(
+            &format!(
+                "Searching for album: {}",
+                input.cyan()
+            ),
+        );
+
+        let search_results = tidal
+            .search(
+                input, None,
+            )
+            .await?;
+
+        if search_results
+            .tracks
+            .is_empty()
+        {
+            return Err(DownloadError::AlbumNotFound(input.to_string()));
+        }
+
+        let track = &search_results.tracks[0];
+        let album_name = track
+            .album
+            .as_ref()
+            .ok_or_else(|| DownloadError::AlbumNotFound("No album info found".to_string()))?;
+
+        Ui::print_info(
+            &format!(
+                "Found album: {} by {}",
+                album_name.cyan(),
+                track
+                    .artist
+                    .white()
+            ),
+        );
+
+        if !Ui::confirm("Download this album?") {
+            Ui::print_info("Cancelled");
+            return Ok(());
+        }
+
+        return Ok(());
+    };
+
+    let album_info = tidal
+        .get_album_info(album_id)
+        .await?;
+    Ui::print_album_detail(&album_info);
+
+    let tracks = tidal
+        .get_album_tracks(album_id)
+        .await?;
+
+    let total_tracks = tracks.len();
+    let progress_mgr = Arc::new(
+        SimpleProgressManager::new(
+            max_concurrent,
+            total_tracks as u64,
+            "Album",
+        ),
+    );
+
+    let album_name = Some(
+        album_info
+            .title
+            .clone(),
+    );
+    let output_dir = output_dir.clone();
+    let adaptive = Arc::new(Mutex::new(AdaptiveConcurrency::new(max_concurrent)));
+    let semaphore = adaptive
+        .lock()
+        .await
+        .semaphore();
+    let success_count = Arc::new(Mutex::new(0usize));
+    let fail_count = Arc::new(Mutex::new(0usize));
+    let slot_counter = Arc::new(AtomicUsize::new(0));
+
+    let mut handles = vec![];
+
+    for track in tracks {
+        let permit = acquire_slot(&semaphore).await;
+        let tidal = TidalService::new();
+        let output_dir = output_dir.clone();
+        let quality = quality;
+        let album_name = album_name.clone();
+        let success_count = success_count.clone();
+        let fail_count = fail_count.clone();
+        let adaptive_inner = adaptive.clone();
+        let progress_inner = progress_mgr.clone();
+        let slot_counter_inner = slot_counter.clone();
+
+        let handle = tokio::spawn(
+            async move {
+                let _permit = permit;
+                let slot = slot_counter_inner.fetch_add(
+                    1,
+                    Ordering::Relaxed,
+                ) % max_concurrent;
+                let downloader = DownloadManager::new(&output_dir).with_album(album_name.as_deref());
+
+                progress_inner.update_download(
+                    slot,
+                    format!(
+                        "Matching: {} - {}",
+                        track
+                            .artist
+                            .white(),
+                        track
+                            .title
+                            .cyan()
+                    ),
+                );
+
+                let result = retry_download(
+                    || async {
+                        let manifest = tidal
+                            .get_manifest(
+                                track.id, quality,
+                            )
+                            .await?;
+                        downloader
+                            .download_from_manifest(
+                                &manifest, &track,
+                            )
+                            .await
+                    },
+                    adaptive_inner.clone(),
+                )
+                .await;
+
+                match result {
+                    Ok(_) => {
+                        adaptive_inner
+                            .lock()
+                            .await
+                            .on_success();
+                        *success_count
+                            .lock()
+                            .await += 1;
+                        progress_inner.update_download(
+                            slot,
+                            format!(
+                                "✓ {} - {}",
+                                track
+                                    .artist
+                                    .white(),
+                                track
+                                    .title
+                                    .green()
+                            ),
+                        );
+                    }
+                    Err(e) => {
+                        adaptive_inner
+                            .lock()
+                            .await
+                            .on_failure();
+                        *fail_count
+                            .lock()
+                            .await += 1;
+                        progress_inner.update_download(
+                            slot,
+                            format!(
+                                "✗ {}: {}",
+                                track
+                                    .title
+                                    .white(),
+                                e.to_string()
+                                    .dimmed()
+                            ),
+                        );
+                    }
+                }
+                progress_inner.inc_total();
+            },
+        );
+
+        handles.push(handle);
+    }
+
+    for handle in handles {
+        handle
+            .await
+            .unwrap();
+    }
+
+    let success = *success_count
+        .lock()
+        .await;
+    let fail = *fail_count
+        .lock()
+        .await;
+
+    let final_concurrent = adaptive
+        .lock()
+        .await
+        .get_concurrent();
+
+    progress_mgr.finish_with_message(
+        &format!(
+            "{} successful, {} failed",
+            success
+                .to_string()
+                .green(),
+            fail.to_string()
+                .red(),
+        ),
+    );
+
+    println!();
+    println!(
+        "Album download complete. Final concurrency: {}",
+        final_concurrent
+            .to_string()
+            .yellow()
+    );
+
+    Ok(())
+}
+
+async fn download_artist(input: &str, _output_dir: &PathBuf, _quality: AudioQuality, _service: Service) -> Result<()> {
+    let tidal = TidalService::new();
+
+    Ui::print_info(
+        &format!(
+            "Searching for artist: {}",
+            input.cyan()
+        ),
+    );
+
+    let search_results = tidal
+        .search(
+            input, None,
+        )
+        .await?;
+
+    if search_results
+        .tracks
+        .is_empty()
+    {
+        return Err(DownloadError::ArtistNotFound(input.to_string()));
+    }
+
+    Ui::print_search_results(
+        &search_results.tracks,
+        5,
+    );
+    Ui::print_warning("Artist downloads are not fully implemented yet.");
+    Ui::print_info("Use 'track' command to download individual tracks.");
+
+    Ok(())
+}
+
+async fn download_playlist(input: &str, output_dir: &PathBuf, quality: AudioQuality, _service: Service, max_concurrent: usize) -> Result<()> {
+    let tidal = TidalService::new();
+
+    let playlist_id = if input
+        .parse::<u64>()
+        .is_ok()
+    {
+        input
+            .parse::<u64>()
+            .unwrap()
+    } else {
+        return Err(DownloadError::PlaylistNotFound("Please provide a playlist ID".to_string()));
+    };
+
+    let playlist_info = tidal
+        .get_playlist_info(playlist_id)
+        .await?;
+    Ui::print_playlist_detail(&playlist_info);
+
+    if !Ui::confirm("Download this playlist?") {
+        Ui::print_info("Cancelled");
+        return Ok(());
+    }
+
+    let tracks = tidal
+        .get_playlist_tracks(playlist_id)
+        .await?;
+
+    let total_tracks = tracks.len();
+    let progress_mgr = Arc::new(
+        SimpleProgressManager::new(
+            max_concurrent,
+            total_tracks as u64,
+            "Playlist",
+        ),
+    );
+
+    let output_dir = output_dir.clone();
+    let adaptive = Arc::new(Mutex::new(AdaptiveConcurrency::new(max_concurrent)));
+    let semaphore = adaptive
+        .lock()
+        .await
+        .semaphore();
+    let success_count = Arc::new(Mutex::new(0usize));
+    let fail_count = Arc::new(Mutex::new(0usize));
+    let slot_counter = Arc::new(AtomicUsize::new(0));
+
+    let mut handles = vec![];
+
+    for track in tracks {
+        let permit = acquire_slot(&semaphore).await;
+        let tidal = TidalService::new();
+        let output_dir = output_dir.clone();
+        let quality = quality;
+        let success_count = success_count.clone();
+        let fail_count = fail_count.clone();
+        let adaptive_inner = adaptive.clone();
+        let progress_inner = progress_mgr.clone();
+        let slot_counter_inner = slot_counter.clone();
+
+        let handle = tokio::spawn(
+            async move {
+                let _permit = permit;
+                let slot = slot_counter_inner.fetch_add(
+                    1,
+                    Ordering::Relaxed,
+                ) % max_concurrent;
+                let downloader = DownloadManager::new(&output_dir);
+
+                progress_inner.update_download(
+                    slot,
+                    format!(
+                        "Matching: {} - {}",
+                        track
+                            .artist
+                            .white(),
+                        track
+                            .title
+                            .cyan()
+                    ),
+                );
+
+                let result = retry_download(
+                    || async {
+                        let manifest = tidal
+                            .get_manifest(
+                                track.id, quality,
+                            )
+                            .await?;
+                        downloader
+                            .download_from_manifest(
+                                &manifest, &track,
+                            )
+                            .await
+                    },
+                    adaptive_inner.clone(),
+                )
+                .await;
+
+                match result {
+                    Ok(_) => {
+                        adaptive_inner
+                            .lock()
+                            .await
+                            .on_success();
+                        *success_count
+                            .lock()
+                            .await += 1;
+                        progress_inner.update_download(
+                            slot,
+                            format!(
+                                "✓ {} - {}",
+                                track
+                                    .artist
+                                    .white(),
+                                track
+                                    .title
+                                    .green()
+                            ),
+                        );
+                    }
+                    Err(e) => {
+                        adaptive_inner
+                            .lock()
+                            .await
+                            .on_failure();
+                        *fail_count
+                            .lock()
+                            .await += 1;
+                        progress_inner.update_download(
+                            slot,
+                            format!(
+                                "✗ {}: {}",
+                                track
+                                    .title
+                                    .white(),
+                                e.to_string()
+                                    .dimmed()
+                            ),
+                        );
+                    }
+                }
+                progress_inner.inc_total();
+            },
+        );
+
+        handles.push(handle);
+    }
+
+    for handle in handles {
+        handle
+            .await
+            .unwrap();
+    }
+
+    let success = *success_count
+        .lock()
+        .await;
+    let fail = *fail_count
+        .lock()
+        .await;
+
+    let final_concurrent = adaptive
+        .lock()
+        .await
+        .get_concurrent();
+
+    progress_mgr.finish_with_message(
+        &format!(
+            "{} successful, {} failed",
+            success
+                .to_string()
+                .green(),
+            fail.to_string()
+                .red(),
+        ),
+    );
+
+    println!();
+    println!(
+        "Playlist download complete. Final concurrency: {}",
+        final_concurrent
+            .to_string()
+            .yellow()
+    );
+
+    Ok(())
+}
+
+#[derive(Debug, Clone)]
+struct DownloadTask {
+    track: crate::types::TrackInfo,
+    csv_track: csv::CsvTrack,
+    confidence: f64,
+    album: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+struct DownloadJob {
+    track: crate::types::TrackInfo,
+    album: Option<String>,
+    playlist: Option<String>,
+    dir_mode: DirMode,
+    retry_count: usize,
+    max_retries: usize,
+    last_error: Option<String>,
+}
+
+async fn download_from_csv(file: &PathBuf, threshold: f64, skip_confirm: bool, output_dir: &PathBuf, quality: AudioQuality, max_concurrent: usize, dir_mode: DirMode) -> Result<()> {
+    Ui::print_info(
+        &format!(
+            "Parsing CSV file: {}",
+            file.display()
+                .to_string()
+                .cyan()
+        ),
+    );
+
+    let csv_tracks = csv::parse_csv_file(file)?;
+    let total = csv_tracks.len();
+    let progress_file = output_dir.join(".download_progress.json");
+    let source_str = file
+        .display()
+        .to_string();
+
+    let (progress, resume) = if progress_file.exists() {
+        if let Ok(existing) = DownloadProgress::load_from_file(&progress_file) {
+            if existing.source == source_str {
+                let completed = existing.get_completed_count();
+                let failed_matches = existing
+                    .failed_matches
+                    .len();
+                println!();
+                println!(
+                    "{} Previous progress found: {}/{} tracks completed, {} failed matches",
+                    "→".cyan(),
+                    completed
+                        .to_string()
+                        .green(),
+                    total
+                        .to_string()
+                        .white(),
+                    failed_matches
+                        .to_string()
+                        .red()
+                );
+                let resume_prompt = "Resume from where you left off?";
+                if Ui::confirm(resume_prompt) {
+                    (
+                        existing, true,
+                    )
+                } else {
+                    let _ = std::fs::remove_file(&progress_file);
+                    (
+                        DownloadProgress::new(
+                            &source_str,
+                            total,
+                        ),
+                        false,
+                    )
+                }
+            } else {
+                (
+                    DownloadProgress::new(
+                        &source_str,
+                        total,
+                    ),
+                    false,
+                )
+            }
+        } else {
+            (
+                DownloadProgress::new(
+                    &source_str,
+                    total,
+                ),
+                false,
+            )
+        }
+    } else {
+        (
+            DownloadProgress::new(
+                &source_str,
+                total,
+            ),
+            false,
+        )
+    };
+
+    Ui::print_info(
+        &format!(
+            "Found {} tracks in CSV",
+            total
+                .to_string()
+                .green()
+        ),
+    );
+
+    let matched_indices: std::collections::HashSet<usize> = if resume {
+        progress
+            .matched_csv_indices
+            .iter()
+            .copied()
+            .collect()
+    } else {
+        std::collections::HashSet::new()
+    };
+
+    let completed_track_ids: std::collections::HashSet<u64> = if resume {
+        progress
+            .completed_track_ids
+            .iter()
+            .copied()
+            .collect()
+    } else {
+        std::collections::HashSet::new()
+    };
+
+    Ui::print_info(
+        &format!(
+            "Matching with adaptive concurrency (max {})...",
+            max_concurrent
+                .to_string()
+                .cyan()
+        ),
+    );
+
+    let progress_mgr = Arc::new(
+        ProgressManager::new(
+            max_concurrent,
+            total as u64,
+        ),
+    );
+    let matcher = Arc::new(CsvMatcher::new());
+    let adaptive = Arc::new(Mutex::new(AdaptiveConcurrency::new(max_concurrent)));
+    let semaphore = adaptive
+        .lock()
+        .await
+        .semaphore();
+    let match_results = Arc::new(Mutex::new(Vec::new()));
+    let progress_counter = Arc::new(Mutex::new(0usize));
+    let consecutive_failures = Arc::new(Mutex::new(0usize));
+    let failed_match_indices = Arc::new(Mutex::new(Vec::<usize>::new()));
+    let matched_indices_shared = Arc::new(Mutex::new(matched_indices.clone()));
+    let progress_shared = Arc::new(Mutex::new(progress.clone()));
+    let csv_tracks_shared = Arc::new(csv_tracks.clone());
+    let slot_counter = Arc::new(AtomicUsize::new(0));
+
+    let mut handles = vec![];
+
+    for (index, track) in csv_tracks
+        .clone()
+        .into_iter()
+        .enumerate()
+    {
+        if resume && matched_indices.contains(&index) {
+            let mut prog = progress_counter
+                .lock()
+                .await;
+            *prog += 1;
+            progress_mgr.inc_matched();
+            continue;
+        }
+
+        let permit = acquire_slot(&semaphore).await;
+        let matcher = matcher.clone();
+        let match_results = match_results.clone();
+        let progress_counter = progress_counter.clone();
+        let consecutive_failures = consecutive_failures.clone();
+        let failed_match_indices = failed_match_indices.clone();
+        let matched_indices_inner = matched_indices_shared.clone();
+        let progress_inner = progress_shared.clone();
+        let csv_tracks_inner = csv_tracks_shared.clone();
+        let track_name = track
+            .track_name
+            .clone();
+        let progress_mgr_inner = progress_mgr.clone();
+        let slot_counter_inner = slot_counter.clone();
+
+        let handle = tokio::spawn(
+            async move {
+                let _permit = permit;
+                let slot = slot_counter_inner.fetch_add(
+                    1,
+                    Ordering::Relaxed,
+                ) % max_concurrent;
+                progress_mgr_inner.update_download(
+                    slot,
+                    format!(
+                        "Matching: {}",
+                        track_name.white()
+                    ),
+                );
+
+                let result = matcher
+                    .find_best_match(&track)
+                    .await
+                    .unwrap_or_else(
+                        |e| CsvMatchResult {
+                            csv_track: track.clone(),
+                            best_match: None,
+                            confidence: 0.0,
+                            search_attempts: vec![
+                                format!(
+                                    "Error: {}",
+                                    e
+                                ),
+                            ],
+                        },
+                    );
+
+                let is_match = result
+                    .best_match
+                    .is_some();
+
+                if !is_match {
+                    let mut failures = consecutive_failures
+                        .lock()
+                        .await;
+                    *failures += 1;
+
+                    if *failures >= CONSECUTIVE_FAILURE_THRESHOLD {
+                        drop(failures);
+                        progress_mgr_inner.update_download(
+                            slot,
+                            format!(
+                                "Rate limited, waiting {}s...",
+                                RATE_LIMIT_DELAY_MS / 1000
+                            ),
+                        );
+                        tokio::time::sleep(Duration::from_millis(RATE_LIMIT_DELAY_MS)).await;
+                    } else {
+                        drop(failures);
+                        tokio::time::sleep(Duration::from_millis(NOT_FOUND_DELAY_MS)).await;
+                    }
+
+                    failed_match_indices
+                        .lock()
+                        .await
+                        .push(index);
+                } else {
+                    *consecutive_failures
+                        .lock()
+                        .await = 0;
+                    matched_indices_inner
+                        .lock()
+                        .await
+                        .insert(index);
+
+                    if let Some(ref matched_track) = result.best_match {
+                        let csv_track = &csv_tracks_inner[index];
+                        progress_inner
+                            .lock()
+                            .await
+                            .add_matched_track(
+                                index,
+                                matched_track,
+                                result.confidence,
+                                &csv_track.track_name,
+                                &csv_track.artist_name,
+                                csv_track
+                                    .album
+                                    .as_deref(),
+                                csv_track
+                                    .playlist_name
+                                    .as_deref(),
+                            );
+                    }
+                }
+
+                let status = if is_match {
+                    if result.confidence >= threshold {
+                        format!(
+                            "✓ [{:.0}%] {}",
+                            result.confidence * 100.0,
+                            track_name.green()
+                        )
+                    } else {
+                        format!(
+                            "? [{:.0}%] {}",
+                            result.confidence * 100.0,
+                            track_name.yellow()
+                        )
+                    }
+                } else {
+                    format!(
+                        "✗ Not found: {}",
+                        track_name.red()
+                    )
+                };
+
+                let mut prog = progress_counter
+                    .lock()
+                    .await;
+                *prog += 1;
+                progress_mgr_inner.update_download(
+                    slot, status,
+                );
+                progress_mgr_inner.inc_matched();
+
+                match_results
+                    .lock()
+                    .await
+                    .push(
+                        (
+                            index, result,
+                        ),
+                    );
+            },
+        );
+
+        handles.push(handle);
+    }
+
+    for handle in handles {
+        handle
+            .await
+            .unwrap();
+    }
+
+    let match_results_inner = Arc::try_unwrap(match_results)
+        .unwrap()
+        .into_inner();
+    let match_results_sorted: Vec<(
+        usize,
+        CsvMatchResult,
+    )> = match_results_inner;
+    let mut match_results: Vec<Option<CsvMatchResult>> = vec![None; total];
+
+    for (index, result) in match_results_sorted {
+        match_results[index] = Some(result);
+    }
+
+    if resume {
+        for m in &progress.matched_tracks {
+            let csv_index = m.csv_index;
+            if match_results[csv_index].is_none() {
+                match_results[csv_index] = Some(
+                    CsvMatchResult {
+                        csv_track: csv::CsvTrack {
+                            track_name: m
+                                .csv_track_name
+                                .clone(),
+                            artist_name: m
+                                .csv_artist_name
+                                .clone(),
+                            album: m
+                                .csv_album
+                                .clone(),
+                            playlist_name: m
+                                .playlist_name
+                                .clone(),
+                            track_type: None,
+                            isrc: None,
+                            spotify_id: None,
+                        },
+                        best_match: Some(
+                            crate::types::TrackInfo {
+                                id: m.track_id,
+                                title: m
+                                    .track_title
+                                    .clone(),
+                                artist: m
+                                    .track_artist
+                                    .clone(),
+                                album: m
+                                    .album
+                                    .clone(),
+                                duration: None,
+                                quality: None,
+                                cover_url: None,
+                            },
+                        ),
+                        confidence: m.confidence,
+                        search_attempts: vec![],
+                    },
+                );
+            }
+        }
+    }
+
+    let mut match_results: Vec<CsvMatchResult> = match_results
+        .into_iter()
+        .enumerate()
+        .map(
+            |(index, opt)| {
+                opt.unwrap_or_else(
+                    || CsvMatchResult {
+                        csv_track: csv_tracks[index].clone(),
+                        best_match: None,
+                        confidence: 0.0,
+                        search_attempts: vec![],
+                    },
+                )
+            },
+        )
+        .collect();
+
+    let failed_indices = Arc::try_unwrap(failed_match_indices)
+        .unwrap()
+        .into_inner();
+
+    for idx in &failed_indices {
+        let track = &csv_tracks[*idx];
+        progress_shared
+            .lock()
+            .await
+            .add_failed_match(
+                &track.track_name,
+                Some(&track.artist_name),
+                track
+                    .album
+                    .as_deref(),
+            );
+    }
+
+    {
+        let mut prog = progress_shared
+            .lock()
+            .await;
+        prog.total_matched = prog
+            .matched_csv_indices
+            .len();
+        let _ = prog.save_to_file(&progress_file);
+    }
+
+    if !failed_indices.is_empty() {
+        let retry_spinner = ProgressBar::new_spinner();
+        retry_spinner.set_style(ProgressStyle::default_spinner());
+        retry_spinner.set_message(
+            format!(
+                "Retrying {} failed matches...",
+                failed_indices.len()
+            ),
+        );
+
+        let retry_match_results = Arc::new(Mutex::new(Vec::new()));
+        let retry_progress = Arc::new(Mutex::new(0usize));
+
+        for idx in &failed_indices {
+            let csv_track = csv_tracks[*idx].clone();
+            let tidal = TidalService::new();
+            let retry_match_results = retry_match_results.clone();
+            let retry_progress = retry_progress.clone();
+
+            let cleaned_name = clean_track_name(&csv_track.track_name);
+            retry_spinner.set_message(
+                format!(
+                    "Retrying: '{}' by '{}'",
+                    cleaned_name, csv_track.artist_name
+                ),
+            );
+            retry_spinner.tick();
+
+            let mut candidates: Vec<crate::types::TrackInfo> = Vec::new();
+
+            let query1 = format!(
+                "{} {}",
+                cleaned_name, csv_track.artist_name
+            );
+            if let Ok(results) = tidal
+                .search(
+                    &query1, None,
+                )
+                .await
+            {
+                candidates.extend(results.tracks);
+                tokio::time::sleep(Duration::from_millis(300)).await;
+            }
+
+            if let Ok(results) = tidal
+                .search(
+                    &cleaned_name,
+                    Some(&csv_track.artist_name),
+                )
+                .await
+            {
+                candidates.extend(results.tracks);
+                tokio::time::sleep(Duration::from_millis(300)).await;
+            }
+
+            if let Ok(results) = tidal
+                .search(
+                    &cleaned_name,
+                    None,
+                )
+                .await
+            {
+                candidates.extend(results.tracks);
+            }
+
+            candidates.sort_by_key(|t| t.id);
+            candidates.dedup_by_key(|t| t.id);
+
+            let best = csv::CsvMatcher::score_and_select_best(
+                &candidates,
+                &csv_track,
+            );
+
+            let result = CsvMatchResult {
+                csv_track: csv_track.clone(),
+                best_match: best
+                    .as_ref()
+                    .map(|(t, _)| t.clone()),
+                confidence: best
+                    .map(|(_, s)| s)
+                    .unwrap_or(0.0),
+                search_attempts: vec![
+                    query1,
+                    cleaned_name.clone(),
+                ],
+            };
+
+            let mut prog = retry_progress
+                .lock()
+                .await;
+            *prog += 1;
+
+            if result
+                .best_match
+                .is_some()
+            {
+                let mut prog = progress_shared
+                    .lock()
+                    .await;
+                prog.total_matched += 1;
+                prog.mark_csv_matched(*idx);
+                if let Some(ref track) = result.best_match {
+                    let csv_track = &csv_tracks[*idx];
+                    prog.add_matched_track(
+                        *idx,
+                        track,
+                        result.confidence,
+                        &csv_track.track_name,
+                        &csv_track.artist_name,
+                        csv_track
+                            .album
+                            .as_deref(),
+                        csv_track
+                            .playlist_name
+                            .as_deref(),
+                    );
+                }
+            }
+
+            retry_match_results
+                .lock()
+                .await
+                .push(
+                    (
+                        *idx, result,
+                    ),
+                );
+        }
+
+        retry_spinner.finish_with_message("Retry complete");
+
+        let retry_results = Arc::try_unwrap(retry_match_results)
+            .unwrap()
+            .into_inner();
+
+        for (idx, result) in retry_results {
+            match_results[idx] = result;
+        }
+    }
+
+    progress_mgr.clear();
+
+    csv::print_csv_summary(&match_results);
+
+    let valid_matches: Vec<(
+        usize,
+        &CsvMatchResult,
+    )> = match_results
+        .iter()
+        .enumerate()
+        .filter(
+            |(_, r)| {
+                r.best_match
+                    .is_some()
+                    && r.confidence >= threshold
+            },
+        )
+        .collect();
+
+    if valid_matches.is_empty() {
+        Ui::print_warning("No tracks matched with sufficient confidence.");
+        progress_shared
+            .lock()
+            .await
+            .save_to_file(&progress_file)?;
+        return Ok(());
+    }
+
+    let skipped = match_results.len() - valid_matches.len();
+    if skipped > 0 {
+        Ui::print_warning(
+            &format!(
+                "{} tracks skipped (below {:.0}% confidence threshold)",
+                skipped,
+                threshold * 100.0
+            ),
+        );
+    }
+
+    let tracks_to_download: Vec<_> = valid_matches
+        .iter()
+        .filter(
+            |(_, r)| {
+                if let Some(ref track) = r.best_match {
+                    !completed_track_ids.contains(&track.id)
+                } else {
+                    false
+                }
+            },
+        )
+        .collect();
+
+    let already_completed = valid_matches.len() - tracks_to_download.len();
+    if already_completed > 0 && resume {
+        println!(
+            "{} {} tracks already downloaded, skipping...",
+            "→".cyan(),
+            already_completed
+                .to_string()
+                .green()
+        );
+    }
+
+    if tracks_to_download.is_empty() {
+        Ui::print_info("All tracks already downloaded.");
+        progress_shared
+            .lock()
+            .await
+            .save_to_file(&progress_file)?;
+        return Ok(());
+    }
+
+    println!();
+    if !skip_confirm {
+        if !Ui::confirm(
+            &format!(
+                "Download {} tracks with adaptive concurrency?",
+                tracks_to_download.len()
+            ),
+        ) {
+            Ui::print_info("Cancelled");
+            progress_shared
+                .lock()
+                .await
+                .save_to_file(&progress_file)?;
+            return Ok(());
+        }
+    }
+
+    Ui::print_info(
+        &format!(
+            "Downloading {} tracks with parallel retry queue (max {})...",
+            tracks_to_download
+                .len()
+                .to_string()
+                .green(),
+            max_concurrent
+                .to_string()
+                .cyan()
+        ),
+    );
+
+    progress_mgr.reset_for_download(tracks_to_download.len() as u64);
+    progress_mgr.set_stage("2/2 - Downloading");
+
+    let output_dir = output_dir.clone();
+    let download_adaptive = Arc::new(Mutex::new(AdaptiveConcurrency::new(max_concurrent)));
+    let success_count = Arc::new(Mutex::new(0usize));
+    let final_fail_count = Arc::new(Mutex::new(0usize));
+
+    let queue: Arc<Mutex<std::collections::VecDeque<DownloadJob>>> = Arc::new(Mutex::new(std::collections::VecDeque::new()));
+    let in_flight = Arc::new(Mutex::new(0usize));
+    let completed = Arc::new(Mutex::new(0usize));
+    let failed_jobs = Arc::new(
+        Mutex::new(
+            Vec::<(
+                DownloadJob,
+                String,
+            )>::new(),
+        ),
+    );
+    let progress_file_shared = progress_file.clone();
+    let download_slot_counter = Arc::new(AtomicUsize::new(0));
+
+    for (_, result) in &tracks_to_download {
+        if let Some(ref track) = result.best_match {
+            let job = DownloadJob {
+                track: track.clone(),
+                album: result
+                    .csv_track
+                    .album
+                    .clone(),
+                playlist: result
+                    .csv_track
+                    .playlist_name
+                    .clone(),
+                dir_mode,
+                retry_count: 0,
+                max_retries: 5,
+                last_error: None,
+            };
+            queue
+                .lock()
+                .await
+                .push_back(job);
+        }
+    }
+
+    let mut worker_handles = vec![];
+
+    for _worker_id in 0..max_concurrent {
+        let queue = queue.clone();
+        let in_flight = in_flight.clone();
+        let completed = completed.clone();
+        let success_count = success_count.clone();
+        let final_fail_count = final_fail_count.clone();
+        let failed_jobs = failed_jobs.clone();
+        let download_adaptive = download_adaptive.clone();
+        let output_dir = output_dir.clone();
+        let quality = quality;
+        let progress_shared = progress_shared.clone();
+        let progress_file_inner = progress_file_shared.clone();
+        let progress_mgr_inner = progress_mgr.clone();
+        let download_slot_counter_inner = download_slot_counter.clone();
+
+        let handle = tokio::spawn(
+            async move {
+                loop {
+                    let job_opt = {
+                        let mut q = queue
+                            .lock()
+                            .await;
+                        q.pop_front()
+                    };
+
+                    let job = match job_opt {
+                        Some(j) => j,
+                        None => {
+                            let in_flight_val = *in_flight
+                                .lock()
+                                .await;
+                            if in_flight_val == 0 {
+                                break;
+                            }
+                            tokio::time::sleep(Duration::from_millis(50)).await;
+                            continue;
+                        }
+                    };
+
+                    *in_flight
+                        .lock()
+                        .await += 1;
+
+                    let slot = download_slot_counter_inner.fetch_add(
+                        1,
+                        Ordering::Relaxed,
+                    ) % max_concurrent;
+                    let tidal = TidalService::new();
+                    let downloader = DownloadManager::new(&output_dir)
+                        .with_album(
+                            job.album
+                                .as_deref(),
+                        )
+                        .with_playlist(
+                            job.playlist
+                                .as_deref(),
+                        )
+                        .with_dir_mode(job.dir_mode);
+
+                    progress_mgr_inner.set_downloading(
+                        slot,
+                        &job.track
+                            .artist,
+                        &job.track
+                            .title,
+                    );
+
+                    let progress_mgr_clone = progress_mgr_inner.clone();
+                    let slot_for_callback = slot;
+                    let result = async {
+                        let manifest = tidal
+                            .get_manifest(
+                                job.track
+                                    .id,
+                                quality,
+                            )
+                            .await?;
+                        downloader
+                            .download_from_manifest_with_progress(
+                                &manifest,
+                                &job.track,
+                                |progress| {
+                                    progress_mgr_clone.update_download_progress(
+                                        slot_for_callback,
+                                        progress,
+                                    );
+                                },
+                            )
+                            .await
+                    }
+                    .await;
+
+                    match result {
+                        Ok(_) => {
+                            download_adaptive
+                                .lock()
+                                .await
+                                .on_success();
+                            *success_count
+                                .lock()
+                                .await += 1;
+                            *completed
+                                .lock()
+                                .await += 1;
+                            *in_flight
+                                .lock()
+                                .await -= 1;
+
+                            {
+                                let mut prog = progress_shared
+                                    .lock()
+                                    .await;
+                                prog.mark_completed(
+                                    job.track
+                                        .id,
+                                );
+                                let _ = prog.save_to_file(&progress_file_inner);
+                            }
+
+                            progress_mgr_inner.finish_download(
+                                slot,
+                                true,
+                                &job.track
+                                    .artist,
+                                &job.track
+                                    .title,
+                            );
+                            progress_mgr_inner.inc_downloaded();
+                        }
+                        Err(e) => {
+                            let error_str = e.to_string();
+                            let is_retryable = matches!(
+                                e,
+                                DownloadError::RateLimited | DownloadError::NetworkError(_) | DownloadError::DownloadFailed(_) | DownloadError::SegmentDownloadFailed(_) | DownloadError::ServiceUnavailable(_)
+                            );
+
+                            download_adaptive
+                                .lock()
+                                .await
+                                .on_failure();
+
+                            if is_retryable && job.retry_count + 1 < job.max_retries {
+                                let delay = Duration::from_secs(
+                                    RETRY_BACKOFF_SECS[job
+                                        .retry_count
+                                        .min(4) as usize],
+                                );
+                                progress_mgr_inner.update_download(
+                                    slot,
+                                    format!(
+                                        "Retrying: {} (attempt {}/{})",
+                                        job.track
+                                            .title
+                                            .yellow(),
+                                        job.retry_count + 1,
+                                        job.max_retries
+                                    ),
+                                );
+                                tokio::time::sleep(delay).await;
+
+                                let retry_job = DownloadJob {
+                                    track: job.track,
+                                    album: job.album,
+                                    playlist: job.playlist,
+                                    dir_mode: job.dir_mode,
+                                    retry_count: job.retry_count + 1,
+                                    max_retries: job.max_retries,
+                                    last_error: Some(error_str),
+                                };
+                                queue
+                                    .lock()
+                                    .await
+                                    .push_back(retry_job);
+                                *in_flight
+                                    .lock()
+                                    .await -= 1;
+                            } else {
+                                *completed
+                                    .lock()
+                                    .await += 1;
+                                *in_flight
+                                    .lock()
+                                    .await -= 1;
+                                *final_fail_count
+                                    .lock()
+                                    .await += 1;
+                                failed_jobs
+                                    .lock()
+                                    .await
+                                    .push(
+                                        (
+                                            job.clone(),
+                                            error_str.clone(),
+                                        ),
+                                    );
+                                progress_shared
+                                    .lock()
+                                    .await
+                                    .add_failure(
+                                        &job.track,
+                                        job.album
+                                            .as_deref(),
+                                        error_str.clone(),
+                                    );
+                                progress_mgr_inner.finish_download(
+                                    slot,
+                                    false,
+                                    &job.track
+                                        .title,
+                                    &error_str,
+                                );
+                                progress_mgr_inner.inc_downloaded();
+                            }
+                        }
+                    }
+
+                    tokio::time::sleep(Duration::from_millis(100)).await;
+                }
+            },
+        );
+
+        worker_handles.push(handle);
+    }
+
+    for handle in worker_handles {
+        let _ = handle.await;
+    }
+
+    let _success = *success_count
+        .lock()
+        .await;
+    let fail = *final_fail_count
+        .lock()
+        .await;
+    let failed_list = Arc::try_unwrap(failed_jobs)
+        .unwrap()
+        .into_inner();
+
+    let mut progress = Arc::try_unwrap(progress_shared)
+        .unwrap()
+        .into_inner();
+    progress.total_downloaded = progress.get_completed_count();
+    progress.successful = progress.get_completed_count();
+
+    progress.save_to_file(&progress_file)?;
+
+    let final_concurrent = download_adaptive
+        .lock()
+        .await
+        .get_concurrent();
+
+    progress_mgr.finish();
+
+    println!();
+    println!(
+        "{}",
+        "═"
+            .repeat(60)
+            .bright_blue()
+    );
+    println!(
+        "{}",
+        "Download Summary"
+            .cyan()
+            .bold()
+    );
+    println!(
+        "{}",
+        "═"
+            .repeat(60)
+            .bright_blue()
+    );
+    println!(
+        "  {} {}",
+        "Total tracks:".dimmed(),
+        total
+            .to_string()
+            .white()
+    );
+    println!(
+        "  {} {}",
+        "Successfully matched:".green(),
+        progress
+            .total_matched
+            .to_string()
+            .green()
+    );
+
+    let failed_matches_count = progress
+        .failed_matches
+        .len();
+    if failed_matches_count > 0 {
+        println!(
+            "  {} {}",
+            "Failed matches:".red(),
+            failed_matches_count
+                .to_string()
+                .red()
+        );
+        for fm in &progress.failed_matches {
+            println!(
+                "    {} {}",
+                "•".red(),
+                fm.track_name
+                    .white()
+            );
+        }
+    }
+
+    println!(
+        "  {} {}",
+        "Successfully downloaded:".green(),
+        progress
+            .get_completed_count()
+            .to_string()
+            .green()
+    );
+
+    if fail > 0 {
+        println!(
+            "  {} {}",
+            "Failed downloads:".red(),
+            fail.to_string()
+                .red()
+        );
+        for (job, error) in &failed_list {
+            println!(
+                "    {} {} - {}",
+                "•".red(),
+                job.track
+                    .title
+                    .white(),
+                error.dimmed()
+            );
+        }
+    }
+
+    println!(
+        "  {} {}",
+        "Final concurrency:".dimmed(),
+        final_concurrent
+            .to_string()
+            .yellow()
+    );
+    println!(
+        "{}",
+        "═"
+            .repeat(60)
+            .bright_blue()
+    );
+    println!(
+        "{} {}",
+        "Progress saved to:".dimmed(),
+        progress_file
+            .display()
+            .to_string()
+            .white()
+    );
+
+    Ok(())
+}
+
+fn clean_track_name(name: &str) -> String {
+    let cleaned: String = name
+        .chars()
+        .filter(|c| c.is_alphanumeric() || *c == ' ' || *c == '-')
+        .collect();
+    let result = cleaned
+        .split_whitespace()
+        .collect::<Vec<_>>()
+        .join(" ");
+
+    let removed_brackets = Regex::new(r"\s*[\(\[][^)\]]*[\)\]]\s*").unwrap();
+    removed_brackets
+        .replace_all(
+            &result, " ",
+        )
+        .trim()
+        .to_string()
+}
+
+async fn retry_download<F, Fut, T>(f: F, adaptive: Arc<Mutex<AdaptiveConcurrency>>) -> Result<T>
+where
+    F: Fn() -> Fut,
+    Fut: std::future::Future<Output = Result<T>>,
+{
+    const MAX_RETRIES: usize = 5;
+    const BACKOFF_DELAYS: [Duration; 5] = [
+        Duration::from_secs(5),
+        Duration::from_secs(15),
+        Duration::from_secs(30),
+        Duration::from_secs(60),
+        Duration::from_secs(120),
+    ];
+
+    let mut last_error = None;
+
+    for attempt in 0..MAX_RETRIES {
+        match f().await {
+            Ok(result) => return Ok(result),
+            Err(e) => {
+                let should_retry = matches!(
+                    e,
+                    DownloadError::RateLimited | DownloadError::NetworkError(_) | DownloadError::DownloadFailed(_) | DownloadError::SegmentDownloadFailed(_) | DownloadError::ServiceUnavailable(_)
+                );
+
+                if !should_retry || attempt == MAX_RETRIES - 1 {
+                    return Err(e);
+                }
+
+                if should_retry {
+                    adaptive
+                        .lock()
+                        .await
+                        .on_failure();
+                }
+
+                last_error = Some(e);
+                tokio::time::sleep(BACKOFF_DELAYS[attempt]).await;
+            }
+        }
+    }
+
+    Err(last_error.unwrap_or(DownloadError::DownloadFailed("Max retries exceeded".to_string())))
+}
diff --git a/src/progress.rs b/src/progress.rs
new file mode 100644
index 0000000..8822bdb
--- /dev/null
+++ b/src/progress.rs
@@ -0,0 +1,262 @@
+use crate::{error::Result, types::TrackInfo};
+use chrono::Utc;
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MatchedTrack {
+    #[serde(rename = "trackId")]
+    pub track_id: u64,
+    #[serde(rename = "trackTitle")]
+    pub track_title: String,
+    #[serde(rename = "trackArtist")]
+    pub track_artist: String,
+    pub album: Option<String>,
+    pub confidence: f64,
+    #[serde(rename = "csvIndex")]
+    pub csv_index: usize,
+    #[serde(rename = "csvTrackName")]
+    pub csv_track_name: String,
+    #[serde(rename = "csvArtistName")]
+    pub csv_artist_name: String,
+    #[serde(rename = "csvAlbum")]
+    pub csv_album: Option<String>,
+    #[serde(rename = "playlistName")]
+    pub playlist_name: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FailedMatch {
+    #[serde(rename = "trackName")]
+    pub track_name: String,
+    pub artist: Option<String>,
+    pub album: Option<String>,
+    #[serde(rename = "searchAttempts")]
+    pub search_attempts: Vec<String>,
+    pub attempts: usize,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CsvTrackInfo {
+    #[serde(rename = "trackName")]
+    pub track_name: String,
+    pub artist: Option<String>,
+    pub album: Option<String>,
+    pub isrc: Option<String>,
+    #[serde(rename = "spotifyId")]
+    pub spotify_id: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FailedDownload {
+    #[serde(rename = "trackId")]
+    pub track_id: u64,
+    #[serde(rename = "trackTitle")]
+    pub track_title: String,
+    #[serde(rename = "trackArtist")]
+    pub track_artist: String,
+    pub album: Option<String>,
+    pub error: String,
+    pub attempts: usize,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DownloadProgress {
+    pub source: String,
+    pub total: usize,
+    pub successful: usize,
+    pub failed: Vec<FailedDownload>,
+    #[serde(rename = "startedAt")]
+    pub started_at: String,
+    #[serde(rename = "completedAt")]
+    pub completed_at: Option<String>,
+    #[serde(rename = "failedMatches")]
+    pub failed_matches: Vec<FailedMatch>,
+    #[serde(rename = "totalMatched")]
+    pub total_matched: usize,
+    #[serde(rename = "totalDownloaded")]
+    pub total_downloaded: usize,
+    #[serde(rename = "completedTrackIds")]
+    pub completed_track_ids: Vec<u64>,
+    #[serde(rename = "matchedCsvIndices")]
+    pub matched_csv_indices: Vec<usize>,
+    #[serde(rename = "matchedTracks")]
+    pub matched_tracks: Vec<MatchedTrack>,
+}
+
+impl DownloadProgress {
+    pub fn new(source: &str, total: usize) -> Self {
+        Self {
+            source: source.to_string(),
+            total,
+            successful: 0,
+            failed: Vec::new(),
+            started_at: Utc::now().to_rfc3339(),
+            completed_at: None,
+            failed_matches: Vec::new(),
+            total_matched: 0,
+            total_downloaded: 0,
+            completed_track_ids: Vec::new(),
+            matched_csv_indices: Vec::new(),
+            matched_tracks: Vec::new(),
+        }
+    }
+
+    pub fn mark_completed(&mut self, track_id: u64) {
+        if !self
+            .completed_track_ids
+            .contains(&track_id)
+        {
+            self.completed_track_ids
+                .push(track_id);
+        }
+    }
+
+    pub fn is_completed(&self, track_id: u64) -> bool {
+        self.completed_track_ids
+            .contains(&track_id)
+    }
+
+    pub fn get_completed_count(&self) -> usize {
+        self.completed_track_ids
+            .len()
+    }
+
+    pub fn mark_csv_matched(&mut self, index: usize) {
+        if !self
+            .matched_csv_indices
+            .contains(&index)
+        {
+            self.matched_csv_indices
+                .push(index);
+        }
+    }
+
+    pub fn is_csv_matched(&self, index: usize) -> bool {
+        self.matched_csv_indices
+            .contains(&index)
+    }
+
+    pub fn add_matched_track(&mut self, csv_index: usize, track: &TrackInfo, confidence: f64, csv_track_name: &str, csv_artist: &str, csv_album: Option<&str>, playlist: Option<&str>) {
+        self.matched_tracks
+            .push(
+                MatchedTrack {
+                    track_id: track.id,
+                    track_title: track
+                        .title
+                        .clone(),
+                    track_artist: track
+                        .artist
+                        .clone(),
+                    album: track
+                        .album
+                        .clone(),
+                    confidence,
+                    csv_index,
+                    csv_track_name: csv_track_name.to_string(),
+                    csv_artist_name: csv_artist.to_string(),
+                    csv_album: csv_album.map(|s| s.to_string()),
+                    playlist_name: playlist.map(|s| s.to_string()),
+                },
+            );
+        self.mark_csv_matched(csv_index);
+    }
+
+    pub fn get_matched_track(&self, csv_index: usize) -> Option<&MatchedTrack> {
+        self.matched_tracks
+            .iter()
+            .find(|m| m.csv_index == csv_index)
+    }
+
+    pub fn add_success(&mut self) {
+        self.successful += 1;
+    }
+
+    pub fn add_failure(&mut self, track: &TrackInfo, album: Option<&str>, error: String) {
+        self.failed
+            .push(
+                FailedDownload {
+                    track_id: track.id,
+                    track_title: track
+                        .title
+                        .clone(),
+                    track_artist: track
+                        .artist
+                        .clone(),
+                    album: album.map(|s| s.to_string()),
+                    error,
+                    attempts: 1,
+                },
+            );
+    }
+
+    pub fn add_failed_match(&mut self, track_name: &str, artist: Option<&str>, album: Option<&str>) {
+        if let Some(existing) = self
+            .failed_matches
+            .iter_mut()
+            .find(
+                |m| {
+                    m.track_name == track_name
+                        && m.artist
+                            .as_deref()
+                            == artist
+                        && m.album
+                            .as_deref()
+                            == album
+                },
+            )
+        {
+            existing.attempts += 1;
+        } else {
+            self.failed_matches
+                .push(
+                    FailedMatch {
+                        track_name: track_name.to_string(),
+                        artist: artist.map(|s| s.to_string()),
+                        album: album.map(|s| s.to_string()),
+                        search_attempts: Vec::new(),
+                        attempts: 1,
+                    },
+                );
+        }
+    }
+
+    pub fn get_failed_matches(&self) -> &[FailedMatch] {
+        &self.failed_matches
+    }
+
+    pub fn total_failed(&self) -> usize {
+        self.failed_matches
+            .len()
+            + self
+                .failed
+                .len()
+    }
+
+    pub fn save_to_file(&self, path: &Path) -> Result<()> {
+        let json = serde_json::to_string_pretty(self)?;
+        std::fs::write(
+            path, json,
+        )?;
+        Ok(())
+    }
+
+    pub fn load_from_file(path: &Path) -> Result<Self> {
+        let content = std::fs::read_to_string(path)?;
+        let progress: Self = serde_json::from_str(&content)?;
+        Ok(progress)
+    }
+
+    pub fn has_failures(&self) -> bool {
+        !self
+            .failed
+            .is_empty()
+    }
+
+    pub fn retry_count(&self) -> usize {
+        self.failed
+            .iter()
+            .map(|f| f.attempts)
+            .sum()
+    }
+}
diff --git a/src/services/mod.rs b/src/services/mod.rs
new file mode 100644
index 0000000..4691028
--- /dev/null
+++ b/src/services/mod.rs
@@ -0,0 +1,21 @@
+pub mod tidal;
+
+use crate::{error::Result, types::*};
+use async_trait::async_trait;
+
+#[async_trait]
+pub trait MusicService: Send + Sync {
+    async fn search(&self, query: &str, artist: Option<&str>) -> Result<SearchResults>;
+
+    async fn get_track_info(&self, track_id: u64) -> Result<TrackInfo>;
+
+    async fn get_album_info(&self, album_id: u64) -> Result<AlbumInfo>;
+
+    async fn get_playlist_info(&self, playlist_id: u64) -> Result<PlaylistInfo>;
+
+    async fn get_album_tracks(&self, album_id: u64) -> Result<Vec<TrackInfo>>;
+
+    async fn get_playlist_tracks(&self, playlist_id: u64) -> Result<Vec<TrackInfo>>;
+
+    async fn get_manifest(&self, track_id: u64, quality: AudioQuality) -> Result<DownloadManifest>;
+}
diff --git a/src/services/tidal.rs b/src/services/tidal.rs
new file mode 100644
index 0000000..a3c6781
--- /dev/null
+++ b/src/services/tidal.rs
@@ -0,0 +1,524 @@
+use crate::{
+    error::{DownloadError, Result},
+    services::MusicService,
+    types::*,
+};
+use async_trait::async_trait;
+use base64::{engine::general_purpose::STANDARD as BASE64, Engine};
+use regex::Regex;
+use reqwest::Client;
+use serde::Deserialize;
+
+const API_BASE: &str = "https://triton.squid.wtf";
+const FALLBACK_APIS: &[&str] = &[
+    "https://aether.squid.wtf",
+    "https://zeus.squid.wtf",
+];
+
+#[derive(Debug, Deserialize)]
+struct ApiResponse<T> {
+    data: T,
+}
+
+#[derive(Debug, Deserialize)]
+struct SearchResponse {
+    items: Vec<TidalTrack>,
+}
+
+#[derive(Debug, Deserialize)]
+struct TidalTrack {
+    id: u64,
+    title: String,
+    #[serde(default)]
+    artist: Option<TidalArtist>,
+    #[serde(default)]
+    album: Option<TidalAlbum>,
+    #[serde(default)]
+    duration: Option<u32>,
+    #[serde(
+        rename = "audioQuality",
+        default
+    )]
+    audio_quality: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct TidalArtist {
+    name: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct TidalAlbum {
+    title: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct TrackInfoData {
+    id: u64,
+    title: String,
+    #[serde(default)]
+    artist: Option<TidalArtist>,
+    #[serde(default)]
+    album: Option<TidalAlbum>,
+    #[serde(default)]
+    duration: Option<u32>,
+    #[serde(
+        rename = "audioQuality",
+        default
+    )]
+    audio_quality: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct TrackManifestData {
+    #[serde(default)]
+    manifest: Option<String>,
+    #[serde(
+        rename = "bitDepth",
+        default
+    )]
+    bit_depth: Option<u8>,
+    #[serde(
+        rename = "sampleRate",
+        default
+    )]
+    sample_rate: Option<u32>,
+}
+
+#[derive(Debug, Deserialize)]
+struct AlbumData {
+    id: u64,
+    title: String,
+    #[serde(default)]
+    artist: Option<TidalArtist>,
+    #[serde(
+        rename = "numberOfTracks",
+        default
+    )]
+    number_of_tracks: Option<u32>,
+}
+
+#[derive(Debug, Deserialize)]
+struct PlaylistData {
+    id: u64,
+    title: String,
+    #[serde(default)]
+    creator: Option<TidalCreator>,
+    #[serde(
+        rename = "numberOfTracks",
+        default
+    )]
+    number_of_tracks: Option<u32>,
+}
+
+#[derive(Debug, Deserialize)]
+struct TidalCreator {
+    name: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct ManifestJson {
+    #[serde(default)]
+    urls: Vec<String>,
+}
+
+#[derive(Clone)]
+pub struct TidalService {
+    client: Client,
+    api_index: usize,
+}
+
+impl TidalService {
+    pub fn new() -> Self {
+        TidalService {
+            client: Client::builder()
+                .user_agent("SquidDownloader/0.1.0")
+                .build()
+                .unwrap(),
+            api_index: 0,
+        }
+    }
+
+    fn get_api_base(&self) -> &str {
+        if self.api_index == 0 {
+            API_BASE
+        } else {
+            FALLBACK_APIS[self.api_index - 1]
+        }
+    }
+
+    fn parse_quality(quality_str: &str) -> AudioQuality {
+        match quality_str
+            .to_uppercase()
+            .as_str()
+        {
+            "HI_RES_LOSSLESS" | "HI_RES" => AudioQuality::HiResLossless,
+            "LOSSLESS" => AudioQuality::Lossless,
+            "HIGH" => AudioQuality::High,
+            "LOW" => AudioQuality::Low,
+            _ => AudioQuality::Auto,
+        }
+    }
+
+    fn map_track_to_info(track: TidalTrack) -> TrackInfo {
+        TrackInfo {
+            id: track.id,
+            title: track.title,
+            artist: track
+                .artist
+                .map(|a| a.name)
+                .unwrap_or_default(),
+            album: track
+                .album
+                .map(|a| a.title),
+            duration: track.duration,
+            quality: track
+                .audio_quality
+                .map(|q| Self::parse_quality(&q)),
+            cover_url: None,
+        }
+    }
+
+    fn parse_mpd_manifest(mpd_xml: &str) -> Result<Vec<String>> {
+        let mut segment_urls = Vec::new();
+        let mut base_url: Option<String> = None;
+
+        let re = Regex::new(r"<BaseURL>([^<]+)</BaseURL>").unwrap();
+        if let Some(caps) = re.captures(mpd_xml) {
+            base_url = Some(caps[1].to_string());
+        }
+
+        let segment_re = Regex::new(r#"media="([^"]+)""#).unwrap();
+        for caps in segment_re.captures_iter(mpd_xml) {
+            let segment = caps[1].to_string();
+            if let Some(ref base) = base_url {
+                let full_url = if base.ends_with('/') {
+                    format!(
+                        "{}{}",
+                        base, segment
+                    )
+                } else {
+                    format!(
+                        "{}/{}",
+                        base, segment
+                    )
+                };
+                segment_urls.push(full_url);
+            } else {
+                segment_urls.push(segment);
+            }
+        }
+
+        if segment_urls.is_empty() {
+            let seg_pattern = r#"<SegmentURL[^>]*media="([^"]+)""#;
+            let seg_re = Regex::new(seg_pattern).unwrap();
+            for caps in seg_re.captures_iter(mpd_xml) {
+                segment_urls.push(caps[1].to_string());
+            }
+        }
+
+        if segment_urls.is_empty() {
+            return Err(DownloadError::XmlParseError("Could not parse segment URLs from MPD manifest".to_string()));
+        }
+
+        Ok(segment_urls)
+    }
+
+    async fn make_request<T: for<'de> Deserialize<'de>>(&self, endpoint: &str) -> Result<T> {
+        let url = format!(
+            "{}{}",
+            self.get_api_base(),
+            endpoint
+        );
+
+        let response = self
+            .client
+            .get(&url)
+            .send()
+            .await?;
+
+        if response.status() == 429 {
+            return Err(DownloadError::RateLimited);
+        }
+
+        let status = response.status();
+        if !status.is_success() {
+            return Err(
+                DownloadError::ServiceUnavailable(
+                    format!(
+                        "API returned status {}",
+                        status
+                    ),
+                ),
+            );
+        }
+
+        let text = response
+            .text()
+            .await?;
+
+        serde_json::from_str(&text).map_err(|e| DownloadError::JsonParseError(e))
+    }
+}
+
+impl Default for TidalService {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl MusicService for TidalService {
+    async fn search(&self, query: &str, artist: Option<&str>) -> Result<SearchResults> {
+        let search_query = match artist {
+            Some(a) => format!(
+                "{} {}",
+                query, a
+            ),
+            None => query.to_string(),
+        };
+
+        let encoded = urlencoding::encode(&search_query);
+        let endpoint = format!(
+            "/search/?s={}",
+            encoded
+        );
+
+        let response: ApiResponse<SearchResponse> = self
+            .make_request(&endpoint)
+            .await?;
+
+        let tracks: Vec<TrackInfo> = response
+            .data
+            .items
+            .into_iter()
+            .map(Self::map_track_to_info)
+            .collect();
+
+        let filtered_tracks = if let Some(artist_name) = artist {
+            tracks
+                .into_iter()
+                .filter(
+                    |t| {
+                        strsim::jaro_winkler(
+                            t.artist
+                                .to_lowercase()
+                                .as_str(),
+                            artist_name
+                                .to_lowercase()
+                                .as_str(),
+                        ) > 0.7
+                    },
+                )
+                .collect()
+        } else {
+            tracks
+        };
+
+        Ok(
+            SearchResults {
+                tracks: filtered_tracks,
+            },
+        )
+    }
+
+    async fn get_track_info(&self, track_id: u64) -> Result<TrackInfo> {
+        let endpoint = format!(
+            "/info/?id={}",
+            track_id
+        );
+        let response: ApiResponse<TrackInfoData> = self
+            .make_request(&endpoint)
+            .await?;
+
+        Ok(
+            TrackInfo {
+                id: response
+                    .data
+                    .id,
+                title: response
+                    .data
+                    .title,
+                artist: response
+                    .data
+                    .artist
+                    .map(|a| a.name)
+                    .unwrap_or_default(),
+                album: response
+                    .data
+                    .album
+                    .map(|a| a.title),
+                duration: response
+                    .data
+                    .duration,
+                quality: response
+                    .data
+                    .audio_quality
+                    .map(|q| Self::parse_quality(&q)),
+                cover_url: None,
+            },
+        )
+    }
+
+    async fn get_album_info(&self, album_id: u64) -> Result<AlbumInfo> {
+        let endpoint = format!(
+            "/album/?id={}",
+            album_id
+        );
+        let response: ApiResponse<AlbumData> = self
+            .make_request(&endpoint)
+            .await?;
+
+        Ok(
+            AlbumInfo {
+                id: response
+                    .data
+                    .id,
+                title: response
+                    .data
+                    .title,
+                artist: response
+                    .data
+                    .artist
+                    .map(|a| a.name)
+                    .unwrap_or_default(),
+                track_count: response
+                    .data
+                    .number_of_tracks
+                    .unwrap_or(0),
+                year: None,
+                cover_url: None,
+            },
+        )
+    }
+
+    async fn get_playlist_info(&self, playlist_id: u64) -> Result<PlaylistInfo> {
+        let endpoint = format!(
+            "/playlist/?id={}",
+            playlist_id
+        );
+        let response: ApiResponse<PlaylistData> = self
+            .make_request(&endpoint)
+            .await?;
+
+        Ok(
+            PlaylistInfo {
+                id: response
+                    .data
+                    .id,
+                title: response
+                    .data
+                    .title,
+                creator: response
+                    .data
+                    .creator
+                    .map(|c| c.name)
+                    .unwrap_or_default(),
+                track_count: response
+                    .data
+                    .number_of_tracks
+                    .unwrap_or(0),
+                cover_url: None,
+            },
+        )
+    }
+
+    async fn get_album_tracks(&self, album_id: u64) -> Result<Vec<TrackInfo>> {
+        let endpoint = format!(
+            "/album/tracks/?id={}",
+            album_id
+        );
+        let response: ApiResponse<SearchResponse> = self
+            .make_request(&endpoint)
+            .await?;
+
+        Ok(
+            response
+                .data
+                .items
+                .into_iter()
+                .map(Self::map_track_to_info)
+                .collect(),
+        )
+    }
+
+    async fn get_playlist_tracks(&self, playlist_id: u64) -> Result<Vec<TrackInfo>> {
+        let endpoint = format!(
+            "/playlist/tracks/?id={}",
+            playlist_id
+        );
+        let response: ApiResponse<SearchResponse> = self
+            .make_request(&endpoint)
+            .await?;
+
+        Ok(
+            response
+                .data
+                .items
+                .into_iter()
+                .map(Self::map_track_to_info)
+                .collect(),
+        )
+    }
+
+    async fn get_manifest(&self, track_id: u64, quality: AudioQuality) -> Result<DownloadManifest> {
+        let endpoint = format!(
+            "/track/?id={}&quality={}",
+            track_id,
+            quality.as_str()
+        );
+        let response: ApiResponse<TrackManifestData> = self
+            .make_request(&endpoint)
+            .await?;
+
+        let manifest_b64 = response
+            .data
+            .manifest
+            .ok_or(DownloadError::NoDownloadUrl)?;
+        let manifest_decoded = BASE64.decode(&manifest_b64)?;
+        let manifest_str = String::from_utf8_lossy(&manifest_decoded);
+
+        let bit_depth = response
+            .data
+            .bit_depth;
+        let sample_rate = response
+            .data
+            .sample_rate;
+
+        if manifest_str.contains("application/dash+xml") || manifest_str.contains("<MPD") {
+            let segment_urls = Self::parse_mpd_manifest(&manifest_str)?;
+            Ok(
+                DownloadManifest {
+                    url: None,
+                    segment_urls: Some(segment_urls),
+                    quality,
+                    bit_depth,
+                    sample_rate,
+                },
+            )
+        } else {
+            let manifest_data: ManifestJson = serde_json::from_str(&manifest_str)?;
+            let url = manifest_data
+                .urls
+                .into_iter()
+                .next()
+                .ok_or(DownloadError::NoDownloadUrl)?;
+
+            Ok(
+                DownloadManifest {
+                    url: Some(url),
+                    segment_urls: None,
+                    quality,
+                    bit_depth,
+                    sample_rate,
+                },
+            )
+        }
+    }
+}
+
+mod urlencoding {
+    pub fn encode(s: &str) -> String {
+        url::form_urlencoded::byte_serialize(s.as_bytes()).collect()
+    }
+}
diff --git a/src/types.rs b/src/types.rs
new file mode 100644
index 0000000..5b26c7d
--- /dev/null
+++ b/src/types.rs
@@ -0,0 +1,224 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub enum AudioQuality {
+    #[serde(rename = "HI_RES_LOSSLESS")]
+    HiResLossless,
+    #[serde(rename = "LOSSLESS")]
+    Lossless,
+    #[serde(rename = "HIGH")]
+    High,
+    #[serde(rename = "LOW")]
+    Low,
+    #[serde(rename = "MP3_320")]
+    Mp3_320,
+    #[default]
+    #[serde(rename = "AUTO")]
+    Auto,
+}
+
+impl AudioQuality {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            AudioQuality::HiResLossless => "HI_RES_LOSSLESS",
+            AudioQuality::Lossless => "LOSSLESS",
+            AudioQuality::High => "HIGH",
+            AudioQuality::Low => "LOW",
+            AudioQuality::Mp3_320 => "MP3_320",
+            AudioQuality::Auto => "AUTO",
+        }
+    }
+
+    pub fn description(&self) -> &'static str {
+        match self {
+            AudioQuality::HiResLossless => "24-bit/192kHz FLAC (Hi-Res)",
+            AudioQuality::Lossless => "16-bit/44.1kHz FLAC (CD Quality)",
+            AudioQuality::High => "320kbps AAC",
+            AudioQuality::Low => "96kbps AAC",
+            AudioQuality::Mp3_320 => "320kbps MP3",
+            AudioQuality::Auto => "Best available",
+        }
+    }
+
+    pub fn file_extension(&self) -> &'static str {
+        match self {
+            AudioQuality::HiResLossless | AudioQuality::Lossless => "flac",
+            AudioQuality::High | AudioQuality::Low => "m4a",
+            AudioQuality::Mp3_320 => "mp3",
+            AudioQuality::Auto => "flac",
+        }
+    }
+
+    pub fn all() -> Vec<Self> {
+        vec![
+            AudioQuality::HiResLossless,
+            AudioQuality::Lossless,
+            AudioQuality::High,
+            AudioQuality::Low,
+        ]
+    }
+}
+
+impl std::fmt::Display for AudioQuality {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            self.description()
+        )
+    }
+}
+
+impl std::str::FromStr for AudioQuality {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s
+            .to_uppercase()
+            .as_str()
+        {
+            "HI_RES_LOSSLESS" | "HIRES" | "HI-RES" | "MASTER" => Ok(AudioQuality::HiResLossless),
+            "LOSSLESS" | "FLAC" | "CD" => Ok(AudioQuality::Lossless),
+            "HIGH" | "AAC320" | "320" => Ok(AudioQuality::High),
+            "LOW" | "AAC96" | "96" => Ok(AudioQuality::Low),
+            "MP3_320" | "MP3" => Ok(AudioQuality::Mp3_320),
+            "AUTO" => Ok(AudioQuality::Auto),
+            _ => Err(
+                format!(
+                    "Unknown quality: {}",
+                    s
+                ),
+            ),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Service {
+    Tidal,
+    AmazonMusic,
+    SoundCloud,
+    KHInsider,
+}
+
+impl Service {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Service::Tidal => "tidal",
+            Service::AmazonMusic => "amazon",
+            Service::SoundCloud => "soundcloud",
+            Service::KHInsider => "khinsider",
+        }
+    }
+
+    pub fn display_name(&self) -> &'static str {
+        match self {
+            Service::Tidal => "Tidal",
+            Service::AmazonMusic => "Amazon Music",
+            Service::SoundCloud => "SoundCloud",
+            Service::KHInsider => "KHInsider",
+        }
+    }
+
+    pub fn all() -> Vec<Self> {
+        vec![
+            Service::Tidal,
+            Service::AmazonMusic,
+            Service::SoundCloud,
+            Service::KHInsider,
+        ]
+    }
+}
+
+impl std::fmt::Display for Service {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            self.display_name()
+        )
+    }
+}
+
+impl std::str::FromStr for Service {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s
+            .to_lowercase()
+            .as_str()
+        {
+            "tidal" | "tdl" => Ok(Service::Tidal),
+            "amazon" | "amazonmusic" | "amz" => Ok(Service::AmazonMusic),
+            "soundcloud" | "sc" => Ok(Service::SoundCloud),
+            "khinsider" | "khi" | "kh" => Ok(Service::KHInsider),
+            _ => Err(
+                format!(
+                    "Unknown service: {}",
+                    s
+                ),
+            ),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TrackInfo {
+    pub id: u64,
+    pub title: String,
+    pub artist: String,
+    pub album: Option<String>,
+    pub duration: Option<u32>,
+    pub quality: Option<AudioQuality>,
+    pub cover_url: Option<String>,
+}
+
+impl TrackInfo {
+    pub fn format_duration(&self) -> String {
+        self.duration
+            .map(
+                |d| {
+                    let mins = d / 60;
+                    let secs = d % 60;
+                    format!(
+                        "{:02}:{:02}",
+                        mins, secs
+                    )
+                },
+            )
+            .unwrap_or_else(|| "--:--".to_string())
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AlbumInfo {
+    pub id: u64,
+    pub title: String,
+    pub artist: String,
+    pub track_count: u32,
+    pub year: Option<u32>,
+    pub cover_url: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PlaylistInfo {
+    pub id: u64,
+    pub title: String,
+    pub creator: String,
+    pub track_count: u32,
+    pub cover_url: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SearchResults {
+    pub tracks: Vec<TrackInfo>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DownloadManifest {
+    pub url: Option<String>,
+    pub segment_urls: Option<Vec<String>>,
+    pub quality: AudioQuality,
+    pub bit_depth: Option<u8>,
+    pub sample_rate: Option<u32>,
+}
diff --git a/src/ui.rs b/src/ui.rs
new file mode 100644
index 0000000..8fc2c90
--- /dev/null
+++ b/src/ui.rs
@@ -0,0 +1,384 @@
+use crate::types::*;
+use colored::Colorize;
+use std::io::{self, Write};
+use tabled::{
+    settings::{object::Rows, Alignment, Modify, Style},
+    Table, Tabled,
+};
+
+#[derive(Tabled)]
+struct TrackRow {
+    #[tabled(rename = "#")]
+    index: usize,
+    #[tabled(rename = "Title")]
+    title: String,
+    #[tabled(rename = "Artist")]
+    artist: String,
+    #[tabled(rename = "Album")]
+    album: String,
+    #[tabled(rename = "Duration")]
+    duration: String,
+}
+
+pub struct Ui;
+
+impl Ui {
+    pub fn print_banner() {
+        println!();
+        println!(
+            "{}",
+            r#"
+  ██████  ██▓███   ▄▄▄       █     █░ ▄▄▄       ███▄    █ 
+▒██    ▒ ▓██░  ██▒▒████▄    ▓█░ █ ░█░▒████▄     ██ ▀█   █ 
+░ ▓██▄   ▓██░ ██▓▒▒██  ▀█▄  ▒█░ █ ░█ ▒██  ▀█▄  ▓██  ▀█ ██▒
+  ▒   ██▒▒██▄█▓▒ ▒░██▄▄▄▄██ ░█░ █ ░█ ░██▄▄▄▄██ ▓██▒  ▐▌██▒
+▒██████▒▒▒██▒ ░  ░ ▓█   ▓██▒░░██▒██▓  ▓█   ▓██▒▒██░   ▓██░
+▒ ▒▓▒ ▒ ░▒▓▒░ ░  ░ ▒▒   ▓▒█░░ ▓░▒ ▒   ▒▒   ▓▒█░░ ▒░   ▒ ▒ 
+░ ░▒  ░ ░░▒ ░       ▒   ▒▒ ░  ▒ ░ ░    ▒   ▒▒ ░░ ░░   ░ ▒░
+░  ░  ░  ░░         ░   ▒     ░   ░    ░   ▒      ░   ░ ░ 
+      ░                  ░  ░  ░            ░  ░         ░ 
+"#
+            .bright_cyan()
+        );
+        println!(
+            "  {} {} • {} {}",
+            "High-quality music downloader".white(),
+            "v0.1.0".yellow(),
+            "Supports:".white(),
+            "Tidal".green()
+        );
+        println!();
+    }
+
+    pub fn print_info(message: &str) {
+        println!(
+            "{} {}",
+            "ℹ"
+                .blue()
+                .bold(),
+            message.white()
+        );
+    }
+
+    pub fn print_success(message: &str) {
+        println!(
+            "{} {}",
+            "✓"
+                .green()
+                .bold(),
+            message.white()
+        );
+    }
+
+    pub fn print_warning(message: &str) {
+        println!(
+            "{} {}",
+            "!".yellow()
+                .bold(),
+            message.white()
+        );
+    }
+
+    pub fn print_error(message: &str) {
+        eprintln!(
+            "{} {}",
+            "✗"
+                .red()
+                .bold(),
+            message.white()
+        );
+    }
+
+    pub fn print_search_results(tracks: &[TrackInfo], limit: usize) {
+        if tracks.is_empty() {
+            Self::print_warning("No results found");
+            return;
+        }
+
+        let rows: Vec<TrackRow> = tracks
+            .iter()
+            .take(limit)
+            .enumerate()
+            .map(
+                |(i, t)| TrackRow {
+                    index: i + 1,
+                    title: t
+                        .title
+                        .clone(),
+                    artist: t
+                        .artist
+                        .clone(),
+                    album: t
+                        .album
+                        .clone()
+                        .unwrap_or_else(|| "-".to_string()),
+                    duration: t.format_duration(),
+                },
+            )
+            .collect();
+
+        let mut table = Table::new(rows);
+        table
+            .with(Style::rounded())
+            .with(Modify::new(Rows::new(1..)).with(Alignment::left()));
+
+        println!();
+        println!(
+            "{}",
+            table
+        );
+        println!();
+    }
+
+    pub fn print_track_detail(track: &TrackInfo, index: Option<usize>) {
+        let prefix = index
+            .map(
+                |i| {
+                    format!(
+                        "{}.",
+                        i
+                    )
+                },
+            )
+            .unwrap_or_default();
+
+        println!(
+            "{} {}",
+            prefix.cyan(),
+            track
+                .title
+                .white()
+                .bold()
+        );
+        println!(
+            "    {} {}",
+            "Artist:".dimmed(),
+            track
+                .artist
+                .white()
+        );
+        if let Some(ref album) = track.album {
+            println!(
+                "    {} {}",
+                "Album:".dimmed(),
+                album.white()
+            );
+        }
+        println!(
+            "    {} {}",
+            "Duration:".dimmed(),
+            track
+                .format_duration()
+                .white()
+        );
+        if let Some(ref quality) = track.quality {
+            println!(
+                "    {} {}",
+                "Quality:".dimmed(),
+                quality
+                    .to_string()
+                    .green()
+            );
+        }
+        println!(
+            "    {} {}",
+            "ID:".dimmed(),
+            track
+                .id
+                .to_string()
+                .yellow()
+        );
+    }
+
+    pub fn print_album_detail(album: &AlbumInfo) {
+        println!();
+        println!(
+            "{}",
+            album
+                .title
+                .white()
+                .bold()
+        );
+        println!(
+            "  {} {}",
+            "Artist:".cyan(),
+            album
+                .artist
+                .white()
+        );
+        println!(
+            "  {} {} tracks",
+            "Tracks:".cyan(),
+            album
+                .track_count
+                .to_string()
+                .white()
+        );
+        if let Some(ref year) = album.year {
+            println!(
+                "  {} {}",
+                "Year:".cyan(),
+                year.to_string()
+                    .white()
+            );
+        }
+        println!();
+    }
+
+    pub fn print_playlist_detail(playlist: &PlaylistInfo) {
+        println!();
+        println!(
+            "{}",
+            playlist
+                .title
+                .white()
+                .bold()
+        );
+        println!(
+            "  {} {}",
+            "Creator:".cyan(),
+            playlist
+                .creator
+                .white()
+        );
+        println!(
+            "  {} {} tracks",
+            "Tracks:".cyan(),
+            playlist
+                .track_count
+                .to_string()
+                .white()
+        );
+        println!();
+    }
+
+    pub fn print_qualities() {
+        println!();
+        println!(
+            "{}",
+            "Available Audio Qualities:"
+                .cyan()
+                .bold()
+        );
+        println!();
+
+        for quality in AudioQuality::all() {
+            println!(
+                "  {} {}",
+                format!(
+                    "{:15}",
+                    quality.as_str()
+                )
+                .yellow(),
+                quality
+                    .description()
+                    .white()
+            );
+        }
+        println!();
+    }
+
+    pub fn print_services() {
+        println!();
+        println!(
+            "{}",
+            "Available Services:"
+                .cyan()
+                .bold()
+        );
+        println!();
+
+        println!(
+            "  {} {}",
+            format!(
+                "{:12}",
+                "tidal"
+            )
+            .yellow(),
+            "Tidal (Hi-Res FLAC)".white()
+        );
+        println!();
+    }
+
+    pub fn select_track(tracks: &[TrackInfo]) -> Option<usize> {
+        if tracks.is_empty() {
+            Self::print_warning("No tracks to select from");
+            return None;
+        }
+
+        if tracks.len() == 1 {
+            return Some(0);
+        }
+
+        Self::print_search_results(
+            tracks,
+            tracks.len(),
+        );
+        print!(
+            "{} {}",
+            "?".green()
+                .bold(),
+            "Select track (1-".white(),
+        );
+        print!(
+            "{}): ",
+            tracks
+                .len()
+                .to_string()
+                .white()
+        );
+
+        io::stdout()
+            .flush()
+            .ok()?;
+
+        let mut input = String::new();
+        io::stdin()
+            .read_line(&mut input)
+            .ok()?;
+
+        let selection: usize = input
+            .trim()
+            .parse()
+            .ok()?;
+
+        if selection == 0 || selection > tracks.len() {
+            Self::print_error(
+                &format!(
+                    "Invalid selection: {}",
+                    selection
+                ),
+            );
+            return None;
+        }
+
+        Some(selection - 1)
+    }
+
+    pub fn confirm(message: &str) -> bool {
+        print!(
+            "{} {} [y/N]: ",
+            "?".green()
+                .bold(),
+            message
+        );
+        io::stdout()
+            .flush()
+            .ok()
+            .unwrap_or(());
+
+        let mut input = String::new();
+        io::stdin()
+            .read_line(&mut input)
+            .ok()
+            .unwrap_or_default();
+
+        matches!(
+            input
+                .trim()
+                .to_lowercase()
+                .as_str(),
+            "y" | "yes"
+        )
+    }
+}