use super::func::*;

pub trait CopyWeakFunctor {
    type CF<'a, A: Copy>;
}

pub trait CopyFunctor: CopyWeakFunctor {
    fn copy_fmap<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Fn(A) -> B>(
        f: F,
        fa: Self::CF<'a, A>,
    ) -> Self::CF<'a, B>;

    fn copy_replace<'a, A: 'a + Copy, B: 'a + Copy>(fa: Self::CF<'a, A>, b: B) -> Self::CF<'a, B> {
        Self::copy_fmap(move |_| b, fa)
    }

    fn copy_void<'a, A: 'a + Copy>(fa: Self::CF<'a, A>) -> Self::CF<'a, ()> {
        Self::copy_replace(fa, ())
    }
}

impl<T: WeakFunctor> CopyWeakFunctor for T {
    type CF<'a, A: Copy> = T::F<'a, A>;
}

impl<T: Functor> CopyFunctor for T {
    fn copy_fmap<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Fn(A) -> B>(
        f: F,
        fa: Self::CF<'a, A>,
    ) -> Self::CF<'a, B> {
        Self::fmap(f, fa)
    }

    fn copy_replace<'a, A: 'a + Copy, B: 'a + Copy>(fa: Self::CF<'a, A>, b: B) -> Self::CF<'a, B> {
        Self::replace(fa, b)
    }

    fn copy_void<'a, A: 'a + Copy>(fa: Self::CF<'a, A>) -> Self::CF<'a, ()> {
        Self::void(fa)
    }
}

pub trait CopyApplicativeSeq: CopyFunctor {
    fn copy_seq<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Copy + Fn(A) -> B>(
        ff: Self::CF<'a, F>,
        fa: Self::CF<'a, A>,
    ) -> Self::CF<'a, B>;

    fn _copy_la2<'a, A: 'a + Copy, B: 'a + Copy, C: 'a + Copy, F: 'a + Copy + Fn(A, B) -> C>(
        f: F,
        fa: Self::CF<'a, A>,
        fb: Self::CF<'a, B>,
    ) -> Self::CF<'a, C> {
        Self::copy_seq(Self::copy_fmap(move |a| move |b| f(a, b), fa), fb)
    }
}

impl<T: ApplicativeSeq> CopyApplicativeSeq for T {
    fn copy_seq<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Copy + Fn(A) -> B>(
        ff: Self::CF<'a, F>,
        fa: Self::CF<'a, A>,
    ) -> Self::CF<'a, B> {
        Self::seq(ff, fa)
    }
}

pub trait CopyApplicativeLA2: CopyFunctor {
    fn copy_la2<'a, A: 'a + Copy, B: 'a + Copy, C: 'a + Copy, F: 'a + Copy + Fn(A, B) -> C>(
        f: F,
        fa: Self::CF<'a, A>,
        fb: Self::CF<'a, B>,
    ) -> Self::CF<'a, C>;

    fn _copy_seq<'a, A: 'a + Copy, B: 'a + Copy, F: 'a + Copy + Fn(A) -> B>(
        ff: Self::CF<'a, F>,
        fa: Self::CF<'a, A>,
    ) -> Self::CF<'a, B> {
        Self::copy_la2(|f, a| f(a), ff, fa)
    }
}

impl<T: ApplicativeLA2> CopyApplicativeLA2 for T {
    fn copy_la2<'a, A: 'a + Copy, B: 'a + Copy, C: 'a + Copy, F: 'a + Copy + Fn(A, B) -> C>(
        f: F,
        fa: Self::CF<'a, A>,
        fb: Self::CF<'a, B>,
    ) -> Self::CF<'a, C> {
        Self::la2(f, fa, fb)
    }
}

// pub trait CopyApplicative: CopyFunctor + CopyApplicativeSeq + CopyApplicativeLA2 {
//     fn copy_pure<A: Copy>(a: A) -> Self::CF<A>;

//     fn copy_discard_first<A: Copy, B: Copy>(fa: Self::CF<A>, fb: Self::CF<B>) -> Self::CF<B> {
//         Self::copy_seq(Self::copy_replace(fa, |b| b), fb)
//     }

//     fn copy_discard_second<A: Copy, B: Copy>(fa: Self::CF<A>, fb: Self::CF<B>) -> Self::CF<A> {
//         Self::copy_la2(|a, _| a, fa, fb)
//     }
// }

// impl<T: Applicative> CopyApplicative for T {
//     fn copy_pure<A: Copy>(a: A) -> Self::CF<A> {
//         Self::pure(a)
//     }

//     fn copy_discard_first<A: Copy, B: Copy>(fa: Self::CF<A>, fb: Self::CF<B>) -> Self::CF<B> {
//         Self::discard_first(fa, fb)
//     }

//     fn copy_discard_second<A: Copy, B: Copy>(fa: Self::CF<A>, fb: Self::CF<B>) -> Self::CF<A> {
//         Self::discard_second(fa, fb)
//     }
// }

// pub trait CopyMonad: CopyApplicative {
//     fn copy_bind<A: Copy, B: Copy, F: Copy + Fn(A) -> Self::CF<B>>(
//         fa: Self::CF<A>,
//         f: F,
//     ) -> Self::CF<B>;

//     fn copy_join<A: Copy>(ffa: Self::CF<Self::CF<A>>) -> Self::CF<A>
//     where
//         Self::CF<A>: Copy,
//     {
//         // ugly
//         Self::copy_bind(ffa, |fa| fa)
//     }
// }

// impl<T: Monad> CopyMonad for T {
//     fn copy_bind<A: Copy, B: Copy, F: Copy + Fn(A) -> Self::CF<B>>(
//         fa: Self::CF<A>,
//         f: F,
//     ) -> Self::CF<B> {
//         T::bind(fa, f)
//     }

//     fn copy_join<A: Copy>(ffa: Self::CF<Self::CF<A>>) -> Self::CF<A>
//     where
//         Self::CF<A>: Copy,
//     {
//         T::join(ffa)
//     }
// }