// -*- C++ -*-

#ifndef __map_range_h__
#define __map_range_h__

#include <cstdlib>
#include <tuple>
#include <memory>
#include <map>

#include "mbase_def.h"
#include "ranges/range_base.h"
#include "ranges/index_base.h"

#include "ranges/rpack_num.h"
#include "map_range_factory_product_map.h"
#include "ranges/x_to_string.h"
#include "ranges/type_map.h"

#include "xfor/xfor.h"

namespace MultiArrayTools
{
    namespace
    {
	using namespace MultiArrayHelper;
    }


    template <class Func, class... Indices>
    auto mkMapOp(const std::shared_ptr<Func>& func,
		 const std::shared_ptr<Indices>&... is)
	-> decltype(std::make_tuple(FunctionalMultiArray<typename Func::value_type,Func,
                                    typename Indices::RangeType...>().exec(is...),
                                    FunctionalMultiArray<typename Func::value_type,Func,
                                    typename Indices::RangeType...>()))
    {
        typedef FunctionalMultiArray<typename Func::value_type,Func,typename Indices::RangeType...> FMA;
        if(Func::FISSTATIC){
            FMA fma(is->range()...);
            return std::make_tuple(fma.exec(is...),fma);
        }
        else {
            FMA fma(is->range()...,func);
            return std::make_tuple(fma.exec(is...),fma);
        }
    }

    
    
    template <class Op, class IndexPack, class Expr, SpaceType STYPE = SpaceType::ANY>
    //template <class MapF, class IndexPack, class Expr, SpaceType STYPE = SpaceType::ANY>
    class OpExpr
    {
    public:
	//typedef decltype(mkMapOp(std::declval<MapF>(), std::declval<IndexPack>())) Op;
	typedef SingleIndex<typename Op::value_type,STYPE> OIType;
	//typedef typename MapF::IndexPack IndexPack;
	static constexpr size_t LAYER = Expr::LAYER + 1;
	static constexpr size_t SIZE = Expr::SIZE + Op::SIZE;
	
    private:
	OpExpr() = default;
	
	const OIType* mIndPtr;
	size_t mSPos;
	size_t mMax;
	size_t mStep;
	Expr mExpr;
	Op mOp;
	
	typedef decltype(mOp.rootSteps(std::declval<intptr_t>()).extend( mExpr.rootSteps(std::declval<intptr_t>()) )) ExtType;
	ExtType mExt;

    public:
	OpExpr(const OpExpr& in) = default;
	OpExpr(OpExpr&& in) = default;
	OpExpr& operator=(const OpExpr& in) = default;
	OpExpr& operator=(OpExpr&& in) = default;

        OpExpr(const Op& mapf, const IndexPack& ipack, const std::shared_ptr<OIType>& oind, size_t step, Expr ex);
	//OpExpr(const MapF& mapf, const IndexPack& ipack, const std::shared_ptr<OIType>& oind, size_t step, Expr ex);

	inline void operator()(size_t mlast, ExtType last);
	inline void operator()(size_t mlast = 0);

	auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;

    };
    
    template <class Op, SpaceType XSTYPE, class... Indices>
    class GenMapIndex : public IndexInterface<GenMapIndex<Op,XSTYPE,Indices...>,
                                              std::tuple<typename Indices::MetaType...> >
    {
    public:
	
	typedef IndexInterface<GenMapIndex<Op,XSTYPE,Indices...>,
			       std::tuple<typename Indices::MetaType...> > IB;
	typedef std::tuple<std::shared_ptr<Indices>...> IndexPack;
	typedef std::tuple<typename Indices::MetaType...> MetaType;
	typedef GenMapRange<Op,XSTYPE,typename Indices::RangeType...> RangeType;
	typedef GenMapIndex IType;
	typedef SingleIndex<typename Op::value_type,XSTYPE> OIType;
	
	static constexpr IndexType sType() { return IndexType::MULTI; }
	static constexpr size_t sDim() { return sizeof...(Indices); }
	static constexpr size_t totalDim() { return mkTotalDim<Indices...>(); }

        static constexpr SpaceType STYPE = XSTYPE;
        static constexpr bool PARALLEL = false;
        
    private:
	
	IndexPack mIPack;
	std::array<size_t,sizeof...(Indices)+1> mBlockSizes;
	std::shared_ptr<OIType> mOutIndex;
	
    public:

	const IndexPack& pack() const { return mIPack; }
	
	GenMapIndex() = delete;
	
	// NO DEFAULT HERE !!!
	// ( have to assign sub-indices (ptr!) correctly )
	//MapIndex(const MapIndex& in);
	//MapIndex& operator=(const MapIndex& in);

	template <class MRange>
	GenMapIndex(const std::shared_ptr<MRange>& range);

	template <size_t DIR>
	GenMapIndex& up();

	template <size_t DIR>
	GenMapIndex& down();

	template <size_t N>
	auto get() const -> decltype( *std::get<N>( mIPack ) )&;

	template <size_t N>
	auto getPtr() const -> decltype( std::get<N>( mIPack ) )&;

	template <size_t N>
	size_t getBlockSize() const { return std::get<N>(mBlockSizes); }
	
	std::shared_ptr<OIType> outIndex() const;
	
	// raplace instances (in contrast to its analogon in ContainerIndex
	// MultiIndices CANNOT be influences be its subindices, so there is
	// NO foreign/external controll)
	// Do NOT share index instances between two or more MapIndex instances
	GenMapIndex& operator()(std::shared_ptr<Indices>&... indices);

	// ==== >>>>> STATIC POLYMORPHISM <<<<< ====
	
	IndexType type() const;

	GenMapIndex& operator=(size_t pos);

	GenMapIndex& operator++();
	GenMapIndex& operator--();

	int pp(std::intptr_t idxPtrNum);
	int mm(std::intptr_t idxPtrNum);

	std::string stringMeta() const;
	MetaType meta() const;
	GenMapIndex& at(const MetaType& metaPos);
	
	size_t dim() const;
	bool first() const;
	bool last() const;
	std::shared_ptr<RangeType> range() const;

	template <size_t N>
	auto getPtr() -> decltype( std::get<N>( mIPack ) )&;

	size_t getStepSize(size_t n) const;

	std::string id() const;
	void print(size_t offset) const;

	template <class Exprs>
	auto ifor(size_t step, Exprs exs) const
	    -> decltype(RPackNum<sizeof...(Indices)-1>::mkForh
			(step, mIPack, mBlockSizes, OpExpr<Op,IndexPack,Exprs,XSTYPE>( range()->map(), mIPack, mOutIndex, step, exs ) ) );
	// first step arg not used!

        template <class Exprs>
	auto pifor(size_t step, Exprs exs) const
	    -> decltype(ifor(step, exs)); // NO MULTITHREADING

	/*
	template <class Exprs>
	auto iforh(Exprs exs) const
	    -> decltype(RPackNum<sizeof...(Indices)-1>::mkForh(mIPack, exs));
	*/
    };

    
    /*************************
     *   MapRangeFactory   *
     *************************/

    // NOT THREAD SAVE
    template <class Op, SpaceType XSTYPE, class... Ranges>
    class GenMapRangeFactory : public RangeFactoryBase
    {
    public:
	typedef GenMapRange<Op,XSTYPE,Ranges...> oType;
	
	GenMapRangeFactory() = delete;

        template <class MA>
	GenMapRangeFactory(const std::tuple<Op,MA>& mapf, const std::shared_ptr<Ranges>&... rs);

        template <class MA>
	GenMapRangeFactory(const std::tuple<Op,MA>& mapf,
                           const typename GenMapRange<Op,XSTYPE,Ranges...>::Space& space);

	virtual std::shared_ptr<RangeBase> create() override;

    private:
	
	std::shared_ptr<RangeBase> checkIfCreated(const std::tuple<std::shared_ptr<Ranges>...>& ptp);
	
    };
    
    /******************
     *   MapRange   *
     ******************/
    
    template <class Op, SpaceType XSTYPE, class... Ranges>
    class GenMapRange : public RangeInterface<GenMapIndex<Op,XSTYPE,typename Ranges::IndexType...> >
    {
    public:
	typedef RangeBase RB;
	typedef std::tuple<std::shared_ptr<Ranges>...> Space;
	typedef GenMapIndex<Op,XSTYPE,typename Ranges::IndexType...> IndexType;
	typedef GenMapRange RangeType;
	typedef SingleRange<typename Op::value_type,XSTYPE> ORType;
	typedef SingleRangeFactory<typename Op::value_type,XSTYPE> ORFType;
	//typedef typename RangeInterface<MapIndex<typename Ranges::IndexType...> >::IndexType IndexType;

    protected:
	GenMapRange() = delete;
	GenMapRange(const GenMapRange& in) = delete;
	GenMapRange& operator=(const GenMapRange& in) = delete;

        template <class MA>
        GenMapRange(const std::tuple<Op,MA>& mapf, const Space& space);

        template <class MA>
        GenMapRange(const std::tuple<Op,MA>& mapf, const std::shared_ptr<Ranges>&... rs);
	
	Space mSpace;
        Op mMapf;
	//Op mMapf;
	std::shared_ptr<ORType> mOutRange;
	MultiArray<size_t,ORType> mMapMult;
        vector<size_t> mMapPos;
        
    private:
        template <class MA>
	void mkOutRange(const MA& mapf);
	
    public:
	
	static constexpr size_t sdim = sizeof...(Ranges);

	template <size_t N>
	auto get() const -> decltype( *std::get<N>( mSpace ) )&;

	template <size_t N>
	auto getPtr() const -> decltype( std::get<N>( mSpace ) )&;

	std::shared_ptr<ORType> outRange() const;
	const Op& map() const;
	
	virtual size_t dim() const final;
	virtual size_t size() const final;

	virtual SpaceType spaceType() const final;
        virtual DataHeader dataHeader() const final;
        
        virtual vector<size_t> typeNum() const final;
        virtual size_t cmeta(char* target, size_t pos) const final;
        virtual size_t cmetaSize() const final;
	virtual std::string stringMeta(size_t pos) const final;
	virtual vector<char> data() const final;
	
	const Space& space() const;
	
	virtual IndexType begin() const final;
	virtual IndexType end() const final;

	const MultiArray<size_t,ORType>& mapMultiplicity() const;
	MultiArray<size_t,GenMapRange> explMapMultiplicity() const;

        vector<size_t> mapPos() const;
        
	/*
	template <class... ERanges>
	auto cat(const std::shared_ptr<GenMapRange<ERanges...> >& erange)
	    -> std::shared_ptr<GenMapRange<Ranges...,ERanges...> >;
        */
	friend GenMapRangeFactory<Op,XSTYPE,Ranges...>;

	static constexpr bool HASMETACONT = false;
	static constexpr bool defaultable = false;
	static constexpr size_t ISSTATIC = SubProp<Op,Ranges...>::ISSTATIC;
	static constexpr size_t SIZE = SubProp<Op,Ranges...>::SIZE;
    };

    // for legacy
    template <class Op, class... Indices>
    using MapIndex = GenMapIndex<Op,SpaceType::ANY,Indices...>;

    template <class Op, class... Ranges>
    using MapRangeFactory = GenMapRangeFactory<Op,SpaceType::ANY,Ranges...>;

    template <class Op, class... Ranges>
    using MapRange = GenMapRange<Op,SpaceType::ANY,Ranges...>;

    template <class Op, class... Indices>
    auto mapResult/*<MapIndex<Op,Indices...> >*/(const std::shared_ptr<MapIndex<Op,Indices...> >& ind)
	-> decltype(ind->outIndex())
    {
	return ind->outIndex();
    }
}


#endif