use serde::{Deserialize, Deserializer, Serialize};
use std::{convert::Infallible, path::PathBuf, str::FromStr};

#[derive(Debug, PartialEq, Eq, Clone, Default, Serialize)]
pub struct SearchPath {
    pub path: PathBuf,
    pub hidden: bool,
    pub recurse: Option<usize>,
}

impl From<PathBuf> for SearchPath {
    fn from(path: PathBuf) -> Self {
        Self {
            path,
            ..Default::default()
        }
    }
}

impl FromStr for SearchPath {
    type Err = Infallible;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        s.parse().map(PathBuf::into)
    }
}

impl<'de> Deserialize<'de> for SearchPath {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum Variants {
            String(String),
            Struct {
                path: PathBuf,
                #[serde(default)]
                hidden: bool,
                #[serde(default)]
                recurse: Option<usize>,
            },
        }

        match Variants::deserialize(deserializer)? {
            Variants::String(s) => s.parse().map_err(serde::de::Error::custom),
            Variants::Struct {
                path,
                hidden,
                recurse,
            } => Ok(Self {
                path,
                hidden,
                recurse,
            }),
        }
    }
}