use crate::{
    object::{AnyObject, ApObject, Object, ObjectMut, ObjectRef},
    primitives::{OneOrMany, Unparsed, XsdNonNegativeInteger},
    traits::{self, Extends, UnparsedMut, UnparsedMutExt},
};
use std::convert::TryFrom;
use typed_builder::TypedBuilder;

pub mod kind {
    pub use activitystreams::collection::kind::*;
}

use self::kind::*;

pub trait CollectionRef<Kind>: traits::Collection {
    fn collection_ref(&self) -> &Collection<Kind>;
}

pub trait CollectionMut<Kind>: traits::Collection {
    fn collection_mut(&mut self) -> &mut Collection<Kind>;
}

pub trait CollectionPageRef<Kind>: traits::CollectionPage {
    fn collection_page_ref(&self) -> &CollectionPage<Kind>;
}

pub trait CollectionPageMut<Kind>: traits::CollectionPage {
    fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind>;
}

pub trait OrderedCollectionPageRef: traits::CollectionPage {
    fn ordered_collection_page_ref(&self) -> &OrderedCollectionPage;
}

pub trait OrderedCollectionPageMut: traits::CollectionPage {
    fn ordered_collection_page_mut(&mut self) -> &mut OrderedCollectionPage;
}

pub trait CollectionRefExt<Kind>: CollectionRef<Kind> {
    fn items<'a>(&'a self) -> &'a OneOrMany<AnyObject>
    where
        Kind: 'a,
    {
        &self.collection_ref().items
    }

    fn total_items<'a>(&'a self) -> Option<&'a XsdNonNegativeInteger>
    where
        Kind: 'a,
    {
        self.collection_ref().total_items.as_ref()
    }

    fn current<'a>(&'a self) -> Option<&'a AnyObject>
    where
        Kind: 'a,
    {
        self.collection_ref().current.as_ref()
    }

    fn first<'a>(&'a self) -> Option<&'a AnyObject>
    where
        Kind: 'a,
    {
        self.collection_ref().first.as_ref()
    }

    fn last<'a>(&'a self) -> Option<&'a AnyObject>
    where
        Kind: 'a,
    {
        self.collection_ref().last.as_ref()
    }
}

pub trait CollectionMutExt<Kind>: CollectionMut<Kind> {
    fn set_items<T>(&mut self, item: T) -> &mut Self
    where
        T: Into<AnyObject>,
    {
        self.collection_mut().items = item.into().into();
        self
    }

    fn set_many_items<I, T>(&mut self, items: I) -> &mut Self
    where
        I: IntoIterator<Item = T>,
        T: Into<AnyObject>,
    {
        let v: Vec<_> = items.into_iter().map(Into::into).collect();
        self.collection_mut().items = v.into();
        self
    }

    fn add_item<T>(&mut self, item: T) -> &mut Self
    where
        T: Into<AnyObject>,
    {
        self.collection_mut().items.add(item.into());
        self
    }

    fn set_total_items<T>(&mut self, total_items: T) -> &mut Self
    where
        T: Into<XsdNonNegativeInteger>,
    {
        self.collection_mut().total_items = Some(total_items.into());
        self
    }

    fn take_total_items(&mut self) -> Option<XsdNonNegativeInteger> {
        self.collection_mut().total_items.take()
    }

    fn delete_total_items(&mut self) -> &mut Self {
        self.collection_mut().total_items = None;
        self
    }

    fn set_current<T>(&mut self, current: T) -> &mut Self
    where
        T: Into<AnyObject>,
    {
        self.collection_mut().current = Some(current.into());
        self
    }

    fn take_current(&mut self) -> Option<AnyObject> {
        self.collection_mut().current.take()
    }

    fn delete_current(&mut self) -> &mut Self {
        self.collection_mut().current = None;
        self
    }

    fn set_first<T>(&mut self, first: T) -> &mut Self
    where
        T: Into<AnyObject>,
    {
        self.collection_mut().first = Some(first.into());
        self
    }

    fn take_first(&mut self) -> Option<AnyObject> {
        self.collection_mut().first.take()
    }

    fn delete_first(&mut self) -> &mut Self {
        self.collection_mut().first = None;
        self
    }

    fn set_last<T>(&mut self, last: T) -> &mut Self
    where
        T: Into<AnyObject>,
    {
        self.collection_mut().last = Some(last.into());
        self
    }

    fn take_last(&mut self) -> Option<AnyObject> {
        self.collection_mut().last.take()
    }

    fn delete_last(&mut self) -> &mut Self {
        self.collection_mut().last = None;
        self
    }
}

pub trait CollectionPageRefExt<Kind>: CollectionPageRef<Kind> {
    fn part_of<'a>(&'a self) -> Option<&'a AnyObject>
    where
        Kind: 'a,
    {
        self.collection_page_ref().part_of.as_ref()
    }

    fn next<'a>(&'a self) -> Option<&'a AnyObject>
    where
        Kind: 'a,
    {
        self.collection_page_ref().next.as_ref()
    }

    fn prev<'a>(&'a self) -> Option<&'a AnyObject>
    where
        Kind: 'a,
    {
        self.collection_page_ref().prev.as_ref()
    }
}

pub trait CollectionPageMutExt<Kind>: CollectionPageMut<Kind> {
    fn set_part_of<T>(&mut self, part_of: T) -> &mut Self
    where
        T: Into<AnyObject>,
    {
        self.collection_page_mut().part_of = Some(part_of.into());
        self
    }

    fn take_part_of(&mut self) -> Option<AnyObject> {
        self.collection_page_mut().part_of.take()
    }

    fn delete_part_of(&mut self) -> &mut Self {
        self.collection_page_mut().part_of = None;
        self
    }

    fn set_next<T>(&mut self, next: T) -> &mut Self
    where
        T: Into<AnyObject>,
    {
        self.collection_page_mut().next = Some(next.into());
        self
    }

    fn take_next(&mut self) -> Option<AnyObject> {
        self.collection_page_mut().next.take()
    }

    fn delete_next(&mut self) -> &mut Self {
        self.collection_page_mut().next = None;
        self
    }

    fn set_prev<T>(&mut self, prev: T) -> &mut Self
    where
        T: Into<AnyObject>,
    {
        self.collection_page_mut().prev = Some(prev.into());
        self
    }

    fn take_prev(&mut self) -> Option<AnyObject> {
        self.collection_page_mut().prev.take()
    }

    fn delete_prev(&mut self) -> &mut Self {
        self.collection_page_mut().prev = None;
        self
    }
}

pub trait OrderedCollectionPageRefExt: OrderedCollectionPageRef {
    fn start_index(&self) -> Option<&XsdNonNegativeInteger> {
        self.ordered_collection_page_ref().start_index.as_ref()
    }
}

pub trait OrderedCollectionPageMutExt: OrderedCollectionPageMut {
    fn set_start_index<T>(&mut self, start_index: T) -> &mut Self
    where
        T: Into<XsdNonNegativeInteger>,
    {
        self.ordered_collection_page_mut().start_index = Some(start_index.into());
        self
    }

    fn take_start_index(&mut self) -> Option<XsdNonNegativeInteger> {
        self.ordered_collection_page_mut().start_index.take()
    }

    fn delete_start_index(&mut self) -> &mut Self {
        self.ordered_collection_page_mut().start_index = None;
        self
    }
}

pub type OrderedCollection = Collection<OrderedCollectionType>;
pub type UnorderedCollection = Collection<CollectionType>;
pub type UnorderedCollectionPage = CollectionPage<CollectionPageType>;

#[derive(Debug, Clone, serde::Deserialize, serde::Serialize, TypedBuilder)]
#[serde(rename_all = "camelCase")]
#[builder(doc)]
pub struct Collection<Kind> {
    #[builder(setter(into))]
    pub items: OneOrMany<AnyObject>,

    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(strip_option, into))]
    pub total_items: Option<XsdNonNegativeInteger>,

    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(strip_option, into))]
    pub current: Option<AnyObject>,

    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(strip_option, into))]
    pub first: Option<AnyObject>,

    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(strip_option, into))]
    pub last: Option<AnyObject>,

    #[serde(flatten)]
    pub inner: Object<Kind>,
}

#[derive(Debug, Clone, serde::Deserialize, serde::Serialize, TypedBuilder)]
#[serde(rename_all = "camelCase")]
#[builder(doc)]
pub struct CollectionPage<Kind> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(strip_option, into))]
    pub part_of: Option<AnyObject>,

    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(strip_option, into))]
    pub next: Option<AnyObject>,

    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(strip_option, into))]
    pub prev: Option<AnyObject>,

    #[serde(flatten)]
    pub inner: Collection<Kind>,
}

#[derive(Debug, Clone, serde::Deserialize, serde::Serialize, TypedBuilder)]
#[serde(rename_all = "camelCase")]
#[builder(doc)]
pub struct OrderedCollectionPage {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default, setter(strip_option, into))]
    pub start_index: Option<XsdNonNegativeInteger>,

    #[serde(flatten)]
    pub inner: CollectionPage<OrderedCollectionPageType>,
}

impl<Kind> Collection<Kind> {
    fn extending(mut inner: Object<Kind>) -> Result<Self, serde_json::Error> {
        let items = inner.remove("items")?;
        let total_items = inner.remove("totalItems")?;
        let current = inner.remove("current")?;
        let first = inner.remove("first")?;
        let last = inner.remove("last")?;

        Ok(Collection {
            items,
            total_items,
            current,
            first,
            last,
            inner,
        })
    }

    fn retracting(self) -> Result<Object<Kind>, serde_json::Error> {
        let Collection {
            items,
            total_items,
            current,
            first,
            last,
            mut inner,
        } = self;

        inner
            .insert("last", last)?
            .insert("first", first)?
            .insert("current", current)?
            .insert("totalItems", total_items)?
            .insert("items", items)?;

        Ok(inner)
    }
}

impl<Kind> CollectionPage<Kind> {
    fn extending(object: Object<Kind>) -> Result<Self, serde_json::Error> {
        let mut inner = Collection::extending(object)?;

        let part_of = inner.remove("partOf")?;
        let next = inner.remove("next")?;
        let prev = inner.remove("prev")?;

        Ok(CollectionPage {
            part_of,
            next,
            prev,
            inner,
        })
    }

    fn retracting(self) -> Result<Object<Kind>, serde_json::Error> {
        let CollectionPage {
            part_of,
            next,
            prev,
            mut inner,
        } = self;

        inner
            .insert("prev", prev)?
            .insert("next", next)?
            .insert("partOf", part_of)?;

        inner.retracting()
    }
}

impl OrderedCollectionPage {
    fn extending(object: Object<OrderedCollectionPageType>) -> Result<Self, serde_json::Error> {
        let mut inner = CollectionPage::extending(object)?;

        let start_index = inner.remove("startIndex")?;

        Ok(OrderedCollectionPage { start_index, inner })
    }

    fn retracting(self) -> Result<Object<OrderedCollectionPageType>, serde_json::Error> {
        let OrderedCollectionPage {
            start_index,
            mut inner,
        } = self;

        inner.insert("startIndex", start_index)?;

        inner.retracting()
    }
}

impl<Kind> traits::Base for Collection<Kind> {}
impl<Kind> traits::Object for Collection<Kind> {}
impl<Kind> traits::Collection for Collection<Kind> {}

impl<Kind> traits::Base for CollectionPage<Kind> {}
impl<Kind> traits::Object for CollectionPage<Kind> {}
impl<Kind> traits::Collection for CollectionPage<Kind> {}
impl<Kind> traits::CollectionPage for CollectionPage<Kind> {}

impl traits::Base for OrderedCollectionPage {}
impl traits::Object for OrderedCollectionPage {}
impl traits::Collection for OrderedCollectionPage {}
impl traits::CollectionPage for OrderedCollectionPage {}

impl<Kind> Extends<Object<Kind>> for Collection<Kind> {
    type Error = serde_json::Error;

    fn extends(object: Object<Kind>) -> Result<Self, Self::Error> {
        Self::extending(object)
    }

    fn retracts(self) -> Result<Object<Kind>, Self::Error> {
        self.retracting()
    }
}

impl<Kind> TryFrom<Collection<Kind>> for Object<Kind> {
    type Error = serde_json::Error;

    fn try_from(collection: Collection<Kind>) -> Result<Self, Self::Error> {
        collection.retracting()
    }
}

impl<Kind> TryFrom<Object<Kind>> for Collection<Kind> {
    type Error = serde_json::Error;

    fn try_from(object: Object<Kind>) -> Result<Self, Self::Error> {
        Self::extending(object)
    }
}

impl<Kind> Extends<Object<Kind>> for CollectionPage<Kind> {
    type Error = serde_json::Error;

    fn extends(object: Object<Kind>) -> Result<Self, Self::Error> {
        Self::extending(object)
    }

    fn retracts(self) -> Result<Object<Kind>, Self::Error> {
        self.retracting()
    }
}

impl<Kind> TryFrom<Object<Kind>> for CollectionPage<Kind> {
    type Error = serde_json::Error;

    fn try_from(object: Object<Kind>) -> Result<Self, Self::Error> {
        Self::extending(object)
    }
}

impl<Kind> TryFrom<CollectionPage<Kind>> for Object<Kind> {
    type Error = serde_json::Error;

    fn try_from(collection_page: CollectionPage<Kind>) -> Result<Self, Self::Error> {
        collection_page.retracting()
    }
}

impl Extends<Object<OrderedCollectionPageType>> for OrderedCollectionPage {
    type Error = serde_json::Error;

    fn extends(object: Object<OrderedCollectionPageType>) -> Result<Self, Self::Error> {
        Self::extending(object)
    }

    fn retracts(self) -> Result<Object<OrderedCollectionPageType>, Self::Error> {
        self.retracting()
    }
}

impl TryFrom<Object<OrderedCollectionPageType>> for OrderedCollectionPage {
    type Error = serde_json::Error;

    fn try_from(object: Object<OrderedCollectionPageType>) -> Result<Self, Self::Error> {
        Self::extending(object)
    }
}

impl TryFrom<OrderedCollectionPage> for Object<OrderedCollectionPageType> {
    type Error = serde_json::Error;

    fn try_from(collection_page: OrderedCollectionPage) -> Result<Self, Self::Error> {
        collection_page.retracting()
    }
}

impl<Kind> UnparsedMut for Collection<Kind> {
    fn unparsed_mut(&mut self) -> &mut Unparsed {
        self.inner.unparsed_mut()
    }
}

impl<Kind> UnparsedMut for CollectionPage<Kind> {
    fn unparsed_mut(&mut self) -> &mut Unparsed {
        self.inner.unparsed_mut()
    }
}

impl UnparsedMut for OrderedCollectionPage {
    fn unparsed_mut(&mut self) -> &mut Unparsed {
        self.inner.unparsed_mut()
    }
}

impl<Kind> ObjectRef<Kind> for Collection<Kind> {
    fn object_ref(&self) -> &Object<Kind> {
        &self.inner
    }
}
impl<Kind> ObjectMut<Kind> for Collection<Kind> {
    fn object_mut(&mut self) -> &mut Object<Kind> {
        &mut self.inner
    }
}

impl<Kind> CollectionRef<Kind> for Collection<Kind> {
    fn collection_ref(&self) -> &Collection<Kind> {
        self
    }
}
impl<Kind> CollectionMut<Kind> for Collection<Kind> {
    fn collection_mut(&mut self) -> &mut Collection<Kind> {
        self
    }
}

impl<Kind> ObjectRef<Kind> for CollectionPage<Kind> {
    fn object_ref(&self) -> &Object<Kind> {
        self.inner.object_ref()
    }
}
impl<Kind> ObjectMut<Kind> for CollectionPage<Kind> {
    fn object_mut(&mut self) -> &mut Object<Kind> {
        self.inner.object_mut()
    }
}

impl<Kind> CollectionRef<Kind> for CollectionPage<Kind> {
    fn collection_ref(&self) -> &Collection<Kind> {
        &self.inner
    }
}
impl<Kind> CollectionMut<Kind> for CollectionPage<Kind> {
    fn collection_mut(&mut self) -> &mut Collection<Kind> {
        &mut self.inner
    }
}

impl<Kind> CollectionPageRef<Kind> for CollectionPage<Kind> {
    fn collection_page_ref(&self) -> &CollectionPage<Kind> {
        self
    }
}
impl<Kind> CollectionPageMut<Kind> for CollectionPage<Kind> {
    fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind> {
        self
    }
}

impl ObjectRef<OrderedCollectionPageType> for OrderedCollectionPage {
    fn object_ref(&self) -> &Object<OrderedCollectionPageType> {
        self.inner.object_ref()
    }
}
impl ObjectMut<OrderedCollectionPageType> for OrderedCollectionPage {
    fn object_mut(&mut self) -> &mut Object<OrderedCollectionPageType> {
        self.inner.object_mut()
    }
}

impl CollectionRef<OrderedCollectionPageType> for OrderedCollectionPage {
    fn collection_ref(&self) -> &Collection<OrderedCollectionPageType> {
        self.inner.collection_ref()
    }
}
impl CollectionMut<OrderedCollectionPageType> for OrderedCollectionPage {
    fn collection_mut(&mut self) -> &mut Collection<OrderedCollectionPageType> {
        self.inner.collection_mut()
    }
}

impl CollectionPageRef<OrderedCollectionPageType> for OrderedCollectionPage {
    fn collection_page_ref(&self) -> &CollectionPage<OrderedCollectionPageType> {
        &self.inner
    }
}
impl CollectionPageMut<OrderedCollectionPageType> for OrderedCollectionPage {
    fn collection_page_mut(&mut self) -> &mut CollectionPage<OrderedCollectionPageType> {
        &mut self.inner
    }
}

impl<Inner> traits::Collection for ApObject<Inner> where Inner: traits::Collection {}
impl<Inner> traits::CollectionPage for ApObject<Inner> where Inner: traits::CollectionPage {}

impl<Inner, Kind> CollectionRef<Kind> for ApObject<Inner>
where
    Inner: CollectionRef<Kind>,
{
    fn collection_ref(&self) -> &Collection<Kind> {
        self.inner.collection_ref()
    }
}
impl<Inner, Kind> CollectionMut<Kind> for ApObject<Inner>
where
    Inner: CollectionMut<Kind>,
{
    fn collection_mut(&mut self) -> &mut Collection<Kind> {
        self.inner.collection_mut()
    }
}

impl<Inner, Kind> CollectionPageRef<Kind> for ApObject<Inner>
where
    Inner: CollectionPageRef<Kind>,
{
    fn collection_page_ref(&self) -> &CollectionPage<Kind> {
        self.inner.collection_page_ref()
    }
}
impl<Inner, Kind> CollectionPageMut<Kind> for ApObject<Inner>
where
    Inner: CollectionPageMut<Kind>,
{
    fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind> {
        self.inner.collection_page_mut()
    }
}

impl<Inner> OrderedCollectionPageRef for ApObject<Inner>
where
    Inner: OrderedCollectionPageRef,
{
    fn ordered_collection_page_ref(&self) -> &OrderedCollectionPage {
        self.inner.ordered_collection_page_ref()
    }
}
impl<Inner> OrderedCollectionPageMut for ApObject<Inner>
where
    Inner: OrderedCollectionPageMut,
{
    fn ordered_collection_page_mut(&mut self) -> &mut OrderedCollectionPage {
        self.inner.ordered_collection_page_mut()
    }
}

impl<T, Kind> CollectionRefExt<Kind> for T where T: CollectionRef<Kind> {}
impl<T, Kind> CollectionMutExt<Kind> for T where T: CollectionMut<Kind> {}

impl<T, Kind> CollectionPageRefExt<Kind> for T where T: CollectionPageRef<Kind> {}
impl<T, Kind> CollectionPageMutExt<Kind> for T where T: CollectionPageMut<Kind> {}

impl<T> OrderedCollectionPageRefExt for T where T: OrderedCollectionPageRef {}
impl<T> OrderedCollectionPageMutExt for T where T: OrderedCollectionPageMut {}