use std::collections::HashMap;

use anyhow::Result;
use serde::{Deserialize, Serialize};

pub mod handle;
pub use handle::handle;

#[derive(Deserialize, Serialize)]
struct ProjectList(HashMap<String, ProjectDefinition>);

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
struct ProjectDefinition {
    #[serde(default)]
    #[serde(skip_serializing_if = "is_default")]
    name: String,

    #[serde(default)]
    #[serde(skip_serializing_if = "is_default")]
    prefix: String,

    #[serde(default)]
    #[serde(skip_serializing_if = "is_default")]
    subprojects: HashMap<String, ProjectDefinition>,
}

fn is_default<T: Default + PartialEq>(input: &T) -> bool {
    input == &T::default()
}

#[derive(Debug, Clone)]
pub struct ProjectName {
    project_segments: Vec<String>,
}

impl ProjectName {
    #[must_use]
    pub fn segments(&self) -> &[String] {
        &self.project_segments
    }

    /// # Errors
    /// Never.
    pub fn try_from_project(s: &str) -> Result<Self> {
        Ok(Self::from_project(s))
    }
    pub fn from_project(s: &str) -> Self {
        let me = Self {
            project_segments: s.split('.').map(ToOwned::to_owned).collect(),
        };
        me
    }
    pub fn from_context(s: &str) -> Self {
        let me = Self {
            project_segments: s.split('_').map(ToOwned::to_owned).collect(),
        };
        me
    }
}

// Source: https://stackoverflow.com/a/67792465
fn sort_alphabetically<T: Serialize, S: serde::Serializer>(
    value: &T,
    serializer: S,
) -> Result<S::Ok, S::Error> {
    let value = serde_json::to_value(value).map_err(serde::ser::Error::custom)?;
    value.serialize(serializer)
}

#[derive(Serialize)]
pub(super) struct SortAlphabetically<T: Serialize>(
    #[serde(serialize_with = "sort_alphabetically")] T,
);