#ifndef MCS_DIMENSION_HPP
#define MCS_DIMENSION_HPP

#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>

#include <boost/mpl/and.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/bool_fwd.hpp>
#include <boost/mpl/clear.hpp>
#include <boost/mpl/contains.hpp>
#include <boost/mpl/deref.hpp>
#include <boost/mpl/empty.hpp>
#include <boost/mpl/equal_to.hpp>
#include <boost/mpl/fold.hpp>
#include <boost/mpl/front.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/insert_range.hpp>
#include <boost/mpl/iter_fold.hpp>
#include <boost/mpl/iterator_range.hpp>
#include <boost/mpl/next.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/push_front.hpp>
#include <boost/mpl/remove_if.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/transform.hpp>

#include <mcs/units/static_rational.hpp>
#include <mcs/units/dimension_tag.hpp>

namespace mcs {

namespace units {

using namespace boost::mpl;

// type resolving to dimensionless
struct dimensionless_type { };

// append one sequence to another
template<typename S1,typename S2>
struct append
{ 
    typedef typename insert_range<
                                  S1,
                                  typename end<S1>::type,
                                  S2
                                 >::type    type;
};

// determine if two sequences are the same size
template<typename S1,typename S2>
struct same_size
{ 
    typedef typename equal_to<
                              size<S1>,
                              size<S2>
                             >::type    type;
};

// get the dim tag at position N
template<typename Seq,long N>
struct dim_at_c
{
    typedef typename get_dim<
                             typename at_c<Seq,N>::type
                            >::type    type;
};

// get the value at position N
template<typename Seq,long N>
struct value_at_c
{
    typedef typename get_value<
                               typename at_c<Seq,N>::type
                              >::type    type;
};

// determine if two sequences are commensurate; i.e. same size 
// and containing the same elements, order irrelevant
template<typename S1,typename S2>
struct is_commensurate
{
    typedef typename and_<
                          same_size<S1,S2>,
                          fold<
                               S1,
                               true_,
                               if_<
                                      contains<S2,_2>,
                                   and_<_1,true_>,
                                   and_<_1,false_> 
                                  > 
                              > 
                         >::type    type;
                                     
    static const bool    value = boost::is_same<type,true_>::value;
};

template<typename Seq>
struct add_collapse_dims
{
    typedef typename next<typename begin<Seq>::type>::type    start_iter;
    typedef typename end<Seq>::type                           end_iter;
    
    typedef typename iterator_range<start_iter,end_iter>::type    iter;
    
    typedef typename iter_fold<iter,
                               typename front<Seq>::type,
                               Add<_1,deref<_2> > 
                              >::type    type;
};

template<typename Seq>
struct subtract_collapse_dims
{
    typedef typename next<typename begin<Seq>::type>::type    start_iter;
    typedef typename end<Seq>::type                            end_iter;
    
    typedef typename iterator_range<start_iter,end_iter>::type    iter;
    
    typedef typename iter_fold<iter,
                               typename front<Seq>::type,
                               Subtract<_1,deref<_2> > 
                              >::type    type;
};

// returns a sequence with the distinct dimension tags in the input sequence
template<typename Seq>
struct distinct_dims
{
    typedef typename begin<Seq>::type    start_iter;
    typedef typename end<Seq>::type      end_iter;
    
    typedef typename iterator_range<start_iter,end_iter>::type    rng;
    
    typedef typename iter_fold<rng,
                               typename clear<Seq>::type,
                               if_<
                                   not_<contains<_1,get_dim<deref<_2> > > >,
                                   push_front<_1,get_dim<deref<_2> > >,
                                   _1
                                  > 
                              >::type    type;
};

// extract all dims having a specified tag
template<typename Seq,typename T>
struct get_by_dim
{
    typedef typename remove_if<Seq,
                               not_<boost::is_same<get_dim<_>,T> > 
                              >::type    type;
};

// extract all dimensionless dimensions
template<typename Seq>
struct strip_zero_dims
{
    typedef typename remove_if<Seq,
                                  boost::is_same<get_value<_>,Rational<0> > 
                              >::type    type;
};

// reduce dimension list, collapsing duplicates and stripping dimensionless tags
template<typename Seq>
struct reduce_dimension
{
    typedef Seq    sequence;
    
    typedef typename distinct_dims<sequence>::type    distinct_type;
    
    typedef typename begin<distinct_type>::type  start_iter;
    typedef typename end<distinct_type>::type    end_iter;
    
    typedef typename iterator_range<start_iter,end_iter>::type    rng;
    
    typedef typename iter_fold<rng,
                               typename clear<sequence>::type,
                               push_front<
                                          _1,
                                          add_collapse_dims<
                                              get_by_dim<sequence,deref<_2> > 
                                                           > 
                                         > 
                              >::type    type1;
    
    typedef typename strip_zero_dims<type1>::type    type2;
    
    typedef typename if_<empty<type2>,dimensionless_type,type2>::type    type;
};

// negate dimension list, collapsing duplicates 
//  and stripping dimensionless tags
template<typename Seq>
struct Negate
{
    typedef Seq        sequence;
    
    typedef typename transform<sequence,Negate<_1> >::type    type1;
    
    typedef typename reduce_dimension<type1>::type    type;
};

template<typename S1,typename S2>
struct Add
{
    typedef typename strip_zero_dims<S1>::type    seq1;
    typedef typename strip_zero_dims<S2>::type    seq2;
    
    BOOST_STATIC_ASSERT((equal_to<
                                  typename is_commensurate<seq1,seq2>::type,
                                  true_
                                 >::value == true));
    
    typedef seq1    type;
};

template<typename S1,typename S2>
struct Subtract
{
    typedef typename strip_zero_dims<S1>::type    seq1;
    typedef typename strip_zero_dims<S2>::type    seq2;
    
    BOOST_STATIC_ASSERT((equal_to<
                                  typename is_commensurate<seq1,seq2>::type,
                                  true_
                                 >::value == true));
    
    typedef seq1    type;
};

template<typename S1,typename S2>
struct Multiply
{
    typedef typename append<S1,S2>::type    sequence;
    
    typedef typename reduce_dimension<sequence>::type    type;
};

template<typename S1,typename S2> 
struct Divide
{
    typedef typename append<S1,typename Negate<S2>::type>::type    sequence;
    
    typedef typename reduce_dimension<sequence>::type    type;
};

template<typename Seq,typename Exp> 
struct Power
{
    typedef Seq        sequence;
    
    typedef typename transform<sequence,Multiply<_1,Exp> >::type    type1;
    
    typedef typename reduce_dimension<type1>::type    type;    
};

template<typename Seq,typename Exp> 
struct Root
{
    typedef Seq        sequence;
    
    typedef typename transform<sequence,Divide<_1,Exp> >::type    type1;
    
    typedef typename reduce_dimension<type1>::type    type;
};

} // namespace units

} // namespace mcs

#endif // MCS_DIMENSION_HPP