use std::{
    sync::{Arc, Mutex},
    time::Duration,
};

use rmp::{
    protocol::{Message, MessageType},
    ServerState,
};

pub struct App {
    pub title: String,
    pub should_quit: bool,
    pub enhanced_graphics: bool,
    pub message_queue: Arc<Mutex<Vec<Message>>>,
    pub state: Arc<Mutex<Option<ServerState>>>,
}

impl App {
    pub fn new(title: &str, enhanced_graphics: bool) -> Self {
        Self {
            title: title.to_string(),
            should_quit: false,
            enhanced_graphics,
            message_queue: Arc::new(Mutex::new(vec![])),
            state: Arc::new(Mutex::new(None)),
        }
    }

    fn push_message(&mut self, message: Message) {
        self.message_queue.lock().unwrap().push(message);
    }

    pub fn connected(&self) -> bool {
        self.state.lock().unwrap().is_some()
    }

    pub fn toggle_shuffle(&mut self) {
        self.push_message(Message::new(MessageType::ToggleSuffle, None));
    }

    pub fn toggle_next(&mut self) {
        self.push_message(Message::new(MessageType::ToggleNext, None));
    }

    pub fn toggle_repeat(&mut self) {
        self.push_message(Message::new(MessageType::ToggleRepeat, None));
    }

    pub fn fetch_state(&mut self) {
        self.push_message(Message::new(MessageType::StateFetch, None));
    }

    pub fn play(&mut self) {
        self.push_message(Message::new(MessageType::PlayTrack, None));
    }

    pub fn toggle_pause(&mut self) {
        self.push_message(Message::new(MessageType::TogglePause, None));
    }

    pub fn on_key(&mut self, key: char) {
        match key {
            'S' => self.toggle_shuffle(),
            'X' => self.toggle_next(),
            'R' => self.toggle_repeat(),
            ' ' => self.toggle_pause(),
            'q' => self.should_quit = true,
            _ => (),
        }
    }

    pub fn on_left(&mut self) {}

    pub fn on_right(&mut self) {}

    pub fn on_up(&mut self) {}

    pub fn on_down(&mut self) {}

    pub fn on_enter(&mut self) {
        self.play();
    }

    pub fn on_tab(&mut self) {}

    pub fn on_tick(&mut self, _duration: Duration) {
        self.push_message(Message::new(MessageType::StateFetch, None));
    }
}