use std::io;
use std::collections::HashSet;
use std::process::Command;
use std::num::ParseIntError;
use std::str::FromStr;
use std::string::FromUtf8Error;

/// Converts a resolution to a string.
pub fn resolution_to_string(res: (u32, u32)) -> String {
    format!("{}x{}", res.0, res.1).to_owned()
}

/// Sets the sound to the HDMI output.
pub fn enable_hdmi_sound() -> Result<(), Error>{
    Command::new("pactl")
        .args(&[
            "set-card-profile",
            "0",
            "output:hdmi-stereo",
        ])
        .output()?;
    Ok(())
}

/// Disables the HDMI sound output.
pub fn disable_hdmi_sound() -> Result<(), Error>{
    Command::new("pactl")
        .args(&[
            "set-card-profile",
            "0",
            "output:analog-stereo+input:analog-stereo",
        ])
        .output()?;
    Ok(())
}

/// The different kinds of errors that can happen.
#[derive(Debug)]
pub enum Error {

    /// An io::Error happened while running the xrandr command.
    IoError(io::Error),

    /// An error happened while parsing the xrandr output to a string
    Utf8Error(FromUtf8Error),

    /// An error happened while parsing the resolution of a xrandr screen.
    ParseIntError(ParseIntError),

    /// Not enough screens detected.
    NoScreenDetected,

}

#[derive(Debug, Copy, Clone)]
/// The relative location of the second screen compared to the first one.
pub enum Side {
    /// On the right of the main screen.
    Right,

    /// On the left of the main screen.
    Left,

    /// Above the main screen.
    Above,

    /// Below the main screen.
    Below,
}

impl Side {
    /// Returns the corresponding xrandr argument.
    pub fn to_argument(&self) -> String {
        match *self {
            Side::Right => "--right-of",
            Side::Left => "--left-of",
            Side::Above => "--above",
            Side::Below => "--below",
        }.to_owned()
    }
}

impl FromStr for Side {
    type Err = ();

    fn from_str(s: &str) -> Result<Side, Self::Err> {
        match s {
            "left" => Ok(Side::Left),
            "right" => Ok(Side::Right),
            "above" => Ok(Side::Above),
            "below" => Ok(Side::Below),
            _ => Err(()),
        }
    }
}

impl From<io::Error> for Error {
    fn from(e: io::Error) -> Error {
        Error::IoError(e)
    }
}

impl From<FromUtf8Error> for Error {
    fn from(e: FromUtf8Error) -> Error {
        Error::Utf8Error(e)
    }
}

impl From<ParseIntError> for Error {
    fn from(e: ParseIntError) -> Error {
        Error::ParseIntError(e)
    }
}

/// A struct that represents a screen and its supported resolutions.
#[derive(Debug)]
pub struct Screen {
    /// The name of the screen received from xrandr.
    pub name: String,

    /// The available resolutions of the screen.
    pub resolutions: Vec<(u32, u32)>,

    /// Whether the screen is primary or not
    pub primary: bool,

    /// Whether the screen is connected or not.
    pub connected: bool,

    /// Whether the screen is active or not.
    pub active: bool,
}

impl Screen {

    /// Creates a screen from the first line in the xrandr command.
    pub fn from_line(line: &str) -> Screen {
        let split = line.split_whitespace().collect::<Vec<_>>();
        Screen {
            name: split[0].to_string(),
            resolutions: vec![],
            primary: line.contains("primary"),
            connected: line.contains(" connected"),
            active: false,
        }
    }

    /// Finds the best common resolution between two screens.
    fn best_common_resolution(&self, other: &Screen) -> Option<(u32, u32)> {
        let self_res: HashSet<(u32, u32)> = self.resolutions.clone().into_iter().collect();
        let other_res: HashSet<(u32, u32)> = other.resolutions.clone().into_iter().collect();
        self_res.intersection(&other_res).into_iter().max().cloned()
    }
}

/// A struct that contains all the screens and allows to manage them.
#[derive(Debug)]
pub struct MultiScreen {
    /// All the contained screens.
    screens: Vec<Screen>,
}

impl MultiScreen {

    /// Finds all the screens by spawning and parsing the output of xrandr.
    pub fn detect() -> Result<MultiScreen, Error> {
        let mut screens = vec![];

        let xrandr = Command::new("xrandr")
            .output()?;

        let output = String::from_utf8(xrandr.stdout)?;
        let output = output.split('\n').skip(1);

        for line in output {

            if line.is_empty() {
                continue;
            }

            // This will match whether its connected or disconnected
            // It tells us it is a new screen
            if line.contains("connected") {

                screens.push(Screen::from_line(line));

            } else if let Some(last) = screens.last_mut() {

                // Get the first thing
                let split = line.split_whitespace().collect::<Vec<_>>();

                // Remove the _ with the frequency
                let resolution = split[0]
                    .split("_").collect::<Vec<_>>()[0]
                    .split("x").collect::<Vec<_>>();

                if split[1].contains("*") {
                    last.active = true;
                }

                if let Ok(width) = resolution[0].parse::<u32>() {
                    if let Ok(height) = resolution[1].parse::<u32>() {
                        last.resolutions.push((width, height));
                    } else {
                        eprintln!("Warning: couldn't parse height: {}, skipping...", resolution[1]);
                    }
                } else {
                    eprintln!("Warning: couldn't parse width: {}, skipping...", resolution[0]);
                }

            }

        }

        for screen in &mut screens {
            screen.resolutions.sort();
        }

        Ok(MultiScreen { screens: screens })
    }

    /// Returns a pair of screen corresponding to the two main screens.
    pub fn main_screens(&self) -> Option<(&Screen, &Screen)> {
        if let Some(main) = self.screens.iter().filter(|x| x.primary).next() {
            if let Some(second) = self.screens.iter().filter(|x| !x.primary && x.connected).next() {
                Some((main, second))
            } else {
                None
            }
        } else {
            None
        }
    }

    /// Returns the arguments of xrandr that disable all screens except the primary.
    pub fn only_primary_args(&self) -> Vec<String> {

        let mut primary_found = false;
        let mut args = vec![];

        for screen in &self.screens {

            if ! screen.primary || primary_found {
                args.push("--output".to_owned());
                args.push(screen.name.clone());
                args.push("--off".to_owned());
            } else {
                args.push("--output".to_owned());
                args.push(screen.name.clone());
                args.push("--auto".to_owned());
                primary_found = true;
            }

        }

        args
    }

    /// Returns the arguments to duplicate the screens.
    pub fn duplicate_args(&self) -> Option<Vec<String>> {
        if let Some((ref main, ref second)) = self.main_screens() {
            if let Some(best_resolution) = main.best_common_resolution(second) {

                Some(vec![
                    "--output".to_owned(),
                    main.name.clone(),
                    "--mode".to_owned(),
                    resolution_to_string(best_resolution),

                    "--output".to_owned(),
                    second.name.clone(),
                    "--mode".to_owned(),
                    resolution_to_string(best_resolution),
                    "--same-as".to_owned(),
                    main.name.clone(),
                ])

            } else {
                None
            }
        } else {
            None
        }
    }

    /// Returns the arguments for two screens.
    pub fn two_screen_args(&self, side: Side) -> Option<Vec<String>> {
        if let Some((ref main, ref second)) = self.main_screens() {

            Some(vec![
                "--output".to_owned(),
                main.name.clone(),
                "--auto".to_owned(),

                "--output".to_owned(),
                second.name.clone(),
                "--auto".to_owned(),
                side.to_argument(),
                main.name.clone(),
            ])

        } else {
            None
        }
    }

    /// Returns the arguments for enabling only the second screen.
    pub fn only_secondary_args(&self) -> Option<Vec<String>> {

        let (main, second) = match self.main_screens() {
            Some(x) => x,
            None => return None,
        };

        let (width, height) = match second.resolutions.iter().max() {
            Some(x) => x,
            None => return None,
        };

        Some(vec![
             "--output".to_owned(),
             main.name.clone(),
             "--off".to_owned(),
             "--output".to_owned(),
             second.name.clone(),
             "--mode".to_owned(),
             format!("{}x{}", width, height),
        ])
    }

    /// Calls the xrandr program to disable all screens except the primary.
    pub fn only_primary(&self) -> Result<(), Error> {
        self.run_command(self.only_primary_args())
    }

    /// Calls the xrandr program to duplicate the screens.
    pub fn duplicate(&self) -> Result<(), Error> {
        if let Some(args) = self.duplicate_args() {
            self.run_command(args)
        } else {
            Err(Error::NoScreenDetected)
        }
    }

    /// Calls the xrandr program to set two screens.
    pub fn two_screens(&self, side: Side) -> Result<(), Error> {
        if let Some(args) = self.two_screen_args(side) {
            self.run_command(args)
        } else {
            Err(Error::NoScreenDetected)
        }
    }

    /// Calls the xrandr program to enable only the second screen.
    pub fn only_secondary(&self) -> Result<(), Error> {
        if let Some(args) = self.only_secondary_args() {
            self.run_command(args)
        } else {
            Err(Error::NoScreenDetected)
        }
    }

    /// Run an xrandr command with its args.
    pub fn run_command(&self, args: Vec<String>) -> Result<(), Error> {
        Command::new("xrandr")
            .args(args)
            .spawn()?
            .wait()?;

        Ok(())
    }

    /// If a HDMI screen is detected, puts the sound on it. Otherwise, disables it.
    pub fn enable_hdmi_sound_if_present(&self) -> Result<(), Error> {
        let hdmi = self.screens
            .iter()
            .fold(false, |acc, x| acc || x.name.to_lowercase().contains("hdmi") && x.active);

        Ok(if hdmi {
            enable_hdmi_sound()?
        } else {
            disable_hdmi_sound()?
        })
    }

}