use std::fmt;

use syn::Lit;

use crate::ast::NestedMeta;
use crate::{FromMeta, Result};

use self::Override::*;

/// A value which can inherit a default value or have an explicit value specified.
///
/// # Usage
/// This type is meant for attributes like `default` in `darling`, which can take the following forms:
///
/// * `#[darling(default)]`
/// * `#[darling(default="path::to::fn")]`
///
/// In a struct collecting input for this attribute, that would be written as:
///
/// ```rust,ignore
/// use darling::{util::Override, FromField};
/// #[derive(FromField)]
/// #[darling(attributes(darling))]
/// pub struct Options {
///    default: Option<Override<syn::Path>>,
/// }
///
/// impl Options {
///     fn hydrate(self) -> Option<syn::Path> {
///         self.default.map(|ov| ov.unwrap_or(syn::parse_path("::Default::default").unwrap()))
///     }
/// }
/// ```
///
/// The `word` format (with no associated value), would produce `Override::Inherit`, while a list
/// or value format would produce `Override::Explicit`.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Override<T> {
    /// Inherit the eventual value from an external source.
    Inherit,

    /// Explicitly set the value.
    Explicit(T),
}

impl<T> Override<T> {
    /// Converts from `Override<T>` to `Override<&T>`.
    ///
    /// Produces a new `Override`, containing a reference into the original, leaving the original in place.
    pub fn as_ref(&self) -> Override<&T> {
        match *self {
            Inherit => Inherit,
            Explicit(ref val) => Explicit(val),
        }
    }

    /// Converts from `Override<T>` to `Override<&mut T>`.
    ///
    /// Produces a new `Override`, containing a mutable reference into the original.
    pub fn as_mut(&mut self) -> Override<&mut T> {
        match *self {
            Inherit => Inherit,
            Explicit(ref mut val) => Explicit(val),
        }
    }

    /// Returns `true` if the override is an `Explicit` value.
    pub fn is_explicit(&self) -> bool {
        match *self {
            Inherit => false,
            Explicit(_) => true,
        }
    }

    /// Converts from `Override<T>` to `Option<T>`.
    pub fn explicit(self) -> Option<T> {
        match self {
            Inherit => None,
            Explicit(val) => Some(val),
        }
    }

    /// Unwraps an override, yielding the content of an `Explicit`. Otherwise, it returns `optb`.
    pub fn unwrap_or(self, optb: T) -> T {
        match self {
            Inherit => optb,
            Explicit(val) => val,
        }
    }

    /// Unwraps an override, yielding the content of an `Explicit`. Otherwise, it calls `op`.
    pub fn unwrap_or_else<F>(self, op: F) -> T
    where
        F: FnOnce() -> T,
    {
        match self {
            Inherit => op(),
            Explicit(val) => val,
        }
    }
}

impl<T: Default> Override<T> {
    /// Returns the contained value or the default value of `T`.
    pub fn unwrap_or_default(self) -> T {
        self.unwrap_or_else(Default::default)
    }
}

impl<T> Default for Override<T> {
    fn default() -> Self {
        Inherit
    }
}

impl<T> From<Option<T>> for Override<T> {
    fn from(v: Option<T>) -> Self {
        match v {
            None => Inherit,
            Some(val) => Explicit(val),
        }
    }
}

impl<T: fmt::Display> fmt::Display for Override<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Inherit => write!(f, "Inherit"),
            Explicit(ref val) => write!(f, "Explicit `{}`", val),
        }
    }
}

/// Parses a `Meta`. A bare word will produce `Override::Inherit`, while
/// any value will be forwarded to `T::from_meta`.
impl<T: FromMeta> FromMeta for Override<T> {
    fn from_word() -> Result<Self> {
        Ok(Inherit)
    }

    fn from_list(items: &[NestedMeta]) -> Result<Self> {
        Ok(Explicit(FromMeta::from_list(items)?))
    }

    fn from_value(lit: &Lit) -> Result<Self> {
        Ok(Explicit(FromMeta::from_value(lit)?))
    }
}
