// Copyright (C) 2019 Robin Krahl <robin.krahl@ireas.org>
// SPDX-License-Identifier: MIT

use std::fmt;
use std::io;
use std::process;
use std::str;

#[derive(Debug)]
pub enum Error {
    DialogError(dialog::Error),
    IoError(io::Error),
    Error(String),
    UrlParseError(url::ParseError),
    Utf8Error(str::Utf8Error),
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match *self {
            Error::DialogError(ref err) => write!(f, "Dialog error: {:?}", err),
            Error::IoError(ref err) => write!(f, "IO error: {}", err),
            Error::Error(ref string) => write!(f, "Error: {}", string),
            Error::UrlParseError(ref err) => write!(f, "URL parse error: {}", err),
            Error::Utf8Error(ref err) => write!(f, "UTF-8 error: {}", err),
        }
    }
}

impl From<&str> for Error {
    fn from(string: &str) -> Error {
        Error::Error(string.to_string())
    }
}

impl From<dialog::Error> for Error {
    fn from(error: dialog::Error) -> Error {
        Error::DialogError(error)
    }
}

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

impl From<(&str, process::ExitStatus)> for Error {
    fn from(data: (&str, process::ExitStatus)) -> Error {
        let (command, status) = data;
        let msg = match status.code() {
            Some(code) => format!("{} failed with error code {}", command, code),
            None => format!("{} was terminated by a signal", command),
        };
        Error::Error(msg)
    }
}

impl From<url::ParseError> for Error {
    fn from(error: url::ParseError) -> Error {
        Error::UrlParseError(error)
    }
}

impl From<str::Utf8Error> for Error {
    fn from(error: str::Utf8Error) -> Error {
        Error::Utf8Error(error)
    }
}