use rmp::{os, server::ServerError, ServerState, TrackChangeOptions};
use std::sync::{Arc, Mutex};

use crate::CliArgs;

pub mod decoder;
pub mod playback;

#[derive(Default)]
pub struct Server {
    pub state: ServerState,
}

pub fn run(args: CliArgs) -> Result<(), ServerError> {
    if let Err(err) = os::server::reserve_pid() {
        let exit_code = handle_error(err);
        std::process::exit(exit_code);
    }

    let server = Arc::new(Mutex::new(Server {
        state: ServerState {
            track_change_options: TrackChangeOptions {
                shuffle: args.shuffle,
                next: args.next,
                repeat: args.repeat,
            },
            player: None,
        },
        ..Default::default()
    }));

    Ok(())
}

pub fn kill() {
    if let Err(err) = os::server::kill() {
        let exit_code = handle_error(err);
        std::process::exit(exit_code);
    }
}

pub fn is_running() -> Result<bool, ServerError> {
    match os::server::is_running() {
        Ok(is_running) => Ok(is_running),
        Err(err) => {
            let exit_code = handle_error(err);
            std::process::exit(exit_code);
        }
    }
}

pub fn run_in_background() {
    if let Err(err) = os::server::run_in_background() {
        let exit_code = handle_error(err);
        std::process::exit(exit_code);
    }
}

fn handle_error(err: ServerError) -> i32 {
    match &err {
        ServerError::Other(msg) => {
            eprintln!("Unknown error: {msg}");
            1
        }
        ServerError::Io(err) => {
            eprintln!("IO error: {err}");
            2
        }
        ServerError::AlreadyRunning => {
            eprintln!("Server already running");
            100
        }
        ServerError::NotRunning => {
            eprintln!("Server is not running");
            101
        }
        ServerError::MissingRuntimeDir(path) => {
            eprintln!("Missing runtime directory: {}", path.to_string_lossy());
            200
        }
    }
}