use core::ops::Deref;

use serde::{Deserialize, Serialize};
#[cfg(feature = "schemars")]
use schemars::JsonSchema;

use crate::api::{
    DomainObject, DomainType
};
use crate::{ApiClient, Client, Result};

impl Client {
    pub fn host_group_api(&self) -> ApiClient<HostGroup> {
        self.into()
    }

    pub fn service_group_api(&self) -> ApiClient<ServiceGroup> {
        self.into()
    }

    pub fn contact_group_api(&self) -> ApiClient<ContactGroup> {
        self.into()
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
pub struct Group {
    pub name: String,
    pub alias: String
}

impl Group {
    pub fn new(name: String, alias: String) -> Self {
        Self { name, alias }
    }
}

impl From<DomainObject<serde_json::Value>> for Group {
    fn from(value: DomainObject<serde_json::Value>) -> Self {
        Self::new(value.id, value.title.unwrap_or_default())
    }
}


macro_rules! domain_group {
    ($id:ident, $typ:expr) => {
        #[derive(Debug, Clone, Serialize, Deserialize)]
        #[cfg_attr(feature = "schemars", derive(JsonSchema))]
        pub struct $id(Group);

        impl Deref for $id {
            type Target = Group;

            fn deref(&self) -> &Self::Target {
                &self.0
            }
        }

        impl $id {
            pub fn new(name: String, alias: String) -> Self {
                Self(Group::new(name, alias))
            }
        }

        impl From<DomainObject<serde_json::Value>> for $id {
            fn from(value: DomainObject<serde_json::Value>) -> Self {
                Self(Group::from(value))
            }
        }

        impl From<&Client> for ApiClient<$id> {
            fn from(value: &Client) -> Self {
                Self::new(value)
            }
        }

        impl ApiClient<$id> {
            pub async fn create(&self, group: &$id) -> Result<()> {
                self.inner.create($typ, group, &()).await
            }
            pub async fn read(&self, id: &str) -> Result<$id> {
                let obj: DomainObject<serde_json::Value> =
                    self.inner.read($typ, id, &()).await?;
                Ok($id::from(obj))
            }
            pub async fn update(&self, id: &str, alias: &str) -> Result<()> {
                #[derive(Serialize)]
                struct Body<'a> {
                    alias: &'a str
                }

                self.inner.update($typ, id, &Body { alias }).await
            }
            pub async fn delete(&self, id: &str) -> Result<()> {
                self.inner.delete($typ, id, &()).await
            }

            pub async fn bulk_create(&self, entries: &[$id]) -> Result<()> {
                self.inner.bulk_create($typ, entries, &()).await
            }
            pub async fn bulk_read(&self) -> Result<Vec<$id>> {
                let entries: Vec<DomainObject<serde_json::Value>> =
                    self.inner.bulk_read($typ, &()).await?;
                let objects = entries.into_iter()
                    .map($id::from)
                    .collect();
                Ok(objects)
            }
            pub async fn bulk_update(&self, entries: &[Group]) -> Result<()> {
                #[derive(Serialize)]
                struct UpdateAttributes<'a> {
                    alias: &'a str
                }
                #[derive(Serialize)]
                struct UpdateRequest<'a> {
                    name: &'a str,
                    attributes: UpdateAttributes<'a>
                }
                impl <'a> UpdateRequest<'a> {
                    fn from(value: &'a Group) -> Self {
                        Self {
                            name: value.name.as_str(),
                            attributes: UpdateAttributes {
                                alias: value.alias.as_str()
                            }
                        }
                    }
                }

                let entries = entries.iter()
                    .map(UpdateRequest::from)
                    .collect::<Vec<_>>();
                self.inner.bulk_update($typ, &entries).await
            }
            pub async fn bulk_delete(&self, entries: &[String]) -> Result<()> {
                self.inner.bulk_delete($typ, entries).await
            }
        }
    }
}

domain_group!(HostGroup, DomainType::HostGroupConfig);
domain_group!(ServiceGroup, DomainType::ServiceGroupConfig);
domain_group!(ContactGroup, DomainType::ContactGroupConfig);