/*
 * This file is a part of RSPlayer
 * Licensed under the GPL-3.0 License
 * Copyright (C) 2026 Salmonik @ salmonik@tuta.io
 * https://codeberg.org/salmonik/RSPlayer
*/

use std::path::PathBuf;

#[derive(Debug, Clone, PartialEq)]
#[allow(dead_code)]
pub enum PlaybackState {
    Stopped,
    Playing,
    Paused,
}

#[derive(Debug, Clone)]
#[allow(dead_code)]
pub struct Track {
    pub path: PathBuf,
    pub title: String,
    pub artist: String,
    pub album: String,
    pub duration: Option<u64>,
}

#[derive(Debug, Clone, PartialEq)]
#[allow(dead_code)]
pub enum ShuffleMode {
    None,
    All,
    Album,
    Albums,
}

#[allow(dead_code)]
pub struct Player {
    pub state: PlaybackState,
    pub current_track: Option<Track>,
    pub queue: Vec<Track>,
    pub volume: u8,
    pub shuffle: ShuffleMode,
}

#[allow(dead_code)]
#[allow(clippy::new_without_default)]
impl Player {
    pub fn new() -> Self {
        Player {
            state: PlaybackState::Stopped,
            current_track: None,
            queue: Vec::new(),
            volume: 70,
            shuffle: ShuffleMode::None,
        }
    }

    pub fn state(&self) -> &PlaybackState {
        &self.state
    }

    pub fn volume(&self) -> u8 {
        self.volume
    }

    pub fn play(&mut self) {
        if self.state == PlaybackState::Paused {
            self.resume();
        } else if self.current_track.is_none() && !self.queue.is_empty() {
            self.current_track = Some(self.queue.remove(0));
            self.state = PlaybackState::Playing;
        }
    }

    pub fn play_track(&mut self, track: Track) {
        self.current_track = Some(track);
        self.state = PlaybackState::Playing;
    }

    pub fn pause(&mut self) {
        if self.state == PlaybackState::Playing {
            self.state = PlaybackState::Paused;
        }
    }

    pub fn resume(&mut self) {
        if self.state == PlaybackState::Paused {
            self.state = PlaybackState::Playing;
        }
    }

    pub fn stop(&mut self) {
        self.state = PlaybackState::Stopped;
        self.current_track = None;
    }

    pub fn next(&mut self) {
        if !self.queue.is_empty() {
            self.current_track = Some(self.queue.remove(0));
        } else {
            self.stop();
        }
    }

    pub fn previous(&mut self) {
        if (self.state == PlaybackState::Playing || self.state == PlaybackState::Paused)
            && self.current_track.is_some()
        {
            self.state = PlaybackState::Playing;
        }
    }

    pub fn set_volume(&mut self, level: u8) {
        self.volume = level.min(100);
    }

    pub fn set_shuffle(&mut self, mode: ShuffleMode) {
        self.shuffle = mode;
    }

    pub fn queue_track(&mut self, track: Track, position: &str) {
        match position {
            "now" => self.queue.insert(0, track),
            "next" => {
                let idx = 1.min(self.queue.len());
                self.queue.insert(idx, track);
            }
            _ => self.queue.push(track),
        }
    }

    pub fn dequeue_next(&mut self) -> Option<Track> {
        if !self.queue.is_empty() {
            Some(self.queue.remove(0))
        } else {
            None
        }
    }
}