#pragma once
/*
 * Created by Brett on 06/02/24.
 * Licensed under GNU General Public License V3.0
 * See LICENSE file for license detail
 */

#ifndef BLT_RANGES_H
#define BLT_RANGES_H

#include <blt/std/types.h>
#include <blt/meta/meta.h>
#include <blt/meta/iterator.h>
#include <type_traits>
#include <iterator>
#include <memory>
#include <utility>
#include <limits>

namespace blt
{
    template<typename T>
    struct enumerate_item
    {
        blt::size_t index;
        T value;
    };
    
    template<typename Iter>
    class enumerate_iterator_base
    {
        public:
            explicit enumerate_iterator_base(Iter iter, blt::size_t place = 0): iter(std::move(iter)), index(place)
            {}
            
            enumerate_item<blt::meta::deref_return_t<Iter>> operator*() const
            {
                return {index, *this->iter};
            }
            
            friend bool operator==(const enumerate_iterator_base& a, const enumerate_iterator_base& b)
            {
                return a.iter == b.iter;
            }
            
            friend bool operator!=(const enumerate_iterator_base& a, const enumerate_iterator_base& b)
            {
                return a.iter != b.iter;
            }
            
            auto base() const
            {
                return iter;
            }
            
            auto get_index() const
            {
                return index;
            }
        
        protected:
            Iter iter;
            blt::size_t index;
    };
    
    template<typename Iter>
    class enumerate_forward_iterator : public enumerate_iterator_base<Iter>
    {
        public:
            using enumerate_iterator_base<Iter>::enumerate_iterator_base;
            
            enumerate_forward_iterator& operator++()
            {
                ++this->iter;
                ++this->index;
                return *this;
            }
            
            enumerate_forward_iterator operator++(int)
            {
                auto tmp = *this;
                ++*this;
                return tmp;
            }
    };
    
    template<typename Iter>
    class enumerate_bidirectional_iterator : public enumerate_forward_iterator<Iter>
    {
        public:
            using enumerate_forward_iterator<Iter>::enumerate_forward_iterator;
            
            enumerate_bidirectional_iterator& operator--()
            {
                --this->iter;
                --this->index;
                return *this;
            }
            
            enumerate_bidirectional_iterator operator--(int)
            {
                auto tmp = *this;
                --*this;
                return tmp;
            }
    };
    
    template<typename Iter, typename = std::void_t<>>
    class enumerate_wrapper;
    
    template<typename Iter>
    class enumerate_wrapper<Iter, std::enable_if_t<blt::meta::is_forward_iterator_v<Iter>, std::void_t<std::forward_iterator_tag>>>
            : public enumerate_forward_iterator<Iter>
    {
        public:
            using iterator_category = std::forward_iterator_tag;
            using value_type = enumerate_item<blt::meta::deref_return_t<Iter>>;
            using difference_type = typename std::iterator_traits<Iter>::difference_type;
            using pointer = value_type;
            using reference = value_type;
            using iterator_type = Iter;
            
            using enumerate_forward_iterator<Iter>::enumerate_forward_iterator;
    };
    
    template<typename Iter>
    class enumerate_wrapper<Iter, std::enable_if_t<blt::meta::is_bidirectional_or_better_v<Iter>, std::void_t<std::bidirectional_iterator_tag>>>
            : public enumerate_bidirectional_iterator<Iter>
    {
        public:
            using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
            using value_type = enumerate_item<blt::meta::deref_return_t<Iter>>;
            using difference_type = typename std::iterator_traits<Iter>::difference_type;
            using pointer = value_type;
            using reference = value_type;
            using iterator_type = Iter;
            
            using enumerate_bidirectional_iterator<Iter>::enumerate_bidirectional_iterator;
    };
    
    template<typename Iter, typename IterWrapper>
    class enumerator_base
    {
        public:
            explicit enumerator_base(Iter begin, Iter end): begin_(std::move(begin)), end_(std::move(end))
            {}
            
            explicit enumerator_base(IterWrapper begin, IterWrapper end): begin_(std::move(begin)), end_(std::move(end))
            {}
            
            auto begin()
            {
                return begin_;
            }
            
            auto end()
            {
                return end_;
            }
        
        protected:
            IterWrapper begin_;
            IterWrapper end_;
    };
    
    template<typename Iter, typename IterWrapper, typename Reverse>
    class enumerator_reversible : public enumerator_base<Iter, IterWrapper>
    {
        public:
            explicit enumerator_reversible(Iter begin, Iter end, blt::size_t container_size):
                    enumerator_base<Iter, IterWrapper>(std::move(begin), std::move(end)), container_size(container_size)
            {}
            
            explicit enumerator_reversible(Iter begin, Iter end, blt::size_t begin_index, blt::size_t end_index):
                    enumerator_base<Iter, IterWrapper>(IterWrapper{enumerate_wrapper<Iter>(std::move(begin), begin_index)},
                                                       IterWrapper{enumerate_wrapper<Iter>(std::move(end), end_index)}),
                    container_size(std::abs(static_cast<blt::ptrdiff_t>(end_index) - static_cast<blt::ptrdiff_t>(begin_index)))
            {}
            
            auto rev()
            {
                return Reverse{this->end_.base(), this->begin_.base(), this->container_size, 0ul};
            }
        
        protected:
            blt::size_t container_size;
    };
    
    template<typename Iter, typename = std::void_t<>>
    class enumerator;
    
    template<typename Iter, typename = std::void_t<>>
    class enumerator_rev;
    
    template<typename Iter>
    class enumerator<Iter, std::enable_if_t<blt::meta::is_forward_iterator_v<Iter>, std::void_t<std::forward_iterator_tag>>>
            : public enumerator_base<Iter, enumerate_wrapper<Iter>>
    {
        public:
            using enumerator_base<Iter, enumerate_wrapper<Iter>>::enumerator_base;
    };
    
    template<typename Iter>
    class enumerator<Iter, std::enable_if_t<blt::meta::is_bidirectional_iterator_v<Iter>, std::void_t<std::bidirectional_iterator_tag>>>
            : public enumerator_reversible<Iter, enumerate_wrapper<Iter>, enumerator_rev<Iter>>
    {
        public:
            using enumerator_reversible<Iter, enumerate_wrapper<Iter>, enumerator_rev<Iter>>::enumerator_reversible;
    };
    
    template<typename Iter>
    class enumerator<Iter, std::enable_if_t<blt::meta::is_random_access_iterator_v<Iter>, std::void_t<std::random_access_iterator_tag>>>
            : public enumerator_reversible<Iter, enumerate_wrapper<Iter>, enumerator_rev<Iter>>
    {
        public:
            using enumerator_reversible<Iter, enumerate_wrapper<Iter>, enumerator_rev<Iter>>::enumerator_reversible;
    };
    
    template<typename Iter>
    class enumerator_rev<Iter, std::enable_if_t<blt::meta::is_bidirectional_iterator_v<Iter>, std::void_t<std::bidirectional_iterator_tag>>>
            : public enumerator_reversible<Iter, std::reverse_iterator<enumerate_wrapper<Iter>>, enumerator<Iter>>
    {
        public:
            using enumerator_reversible<Iter, std::reverse_iterator<enumerate_wrapper<Iter>>, enumerator<Iter>>::enumerator_reversible;
    };
    
    template<typename Iter>
    class enumerator_rev<Iter, std::enable_if_t<blt::meta::is_random_access_iterator_v<Iter>, std::void_t<std::random_access_iterator_tag>>>
            : public enumerator_reversible<Iter, std::reverse_iterator<enumerate_wrapper<Iter>>, enumerator<Iter>>
    {
        public:
            using enumerator_reversible<Iter, std::reverse_iterator<enumerate_wrapper<Iter>>, enumerator<Iter>>::enumerator_reversible;
    };
    
    template<typename Iter>
    enumerator(Iter, Iter) -> enumerator<Iter>;
    
    template<typename Iter>
    enumerator(Iter, Iter, blt::size_t) -> enumerator<Iter>;
    
    template<typename Iter>
    enumerator(Iter, Iter, blt::size_t, blt::size_t) -> enumerator<Iter>;
    
    template<typename T>
    static inline auto enumerate(const T& container)
    {
        return enumerator{container.begin(), container.end(), container.size()};
    }
    
    template<typename T, blt::size_t size>
    static inline auto enumerate(const T(& container)[size])
    {
        return enumerator{&container[0], &container[size], size};
    }
    
    template<typename T, blt::size_t size>
    static inline auto enumerate(T(& container)[size])
    {
        return enumerator{&container[0], &container[size], size};
    }
    
    template<typename T>
    static inline auto enumerate(T& container)
    {
        return enumerator{container.begin(), container.end(), container.size()};
    }
    
    template<typename T>
    static inline auto enumerate(T&& container)
    {
        return enumerator{container.begin(), container.end(), container.size()};
    }
    
    namespace itr
    {
        
        template<typename Begin, typename End>
        class itr_container
        {
            public:
                itr_container(Begin&& begin, End&& end): begin_(std::forward<Begin>(begin)), end_(std::forward<End>(end))
                {}
                
                Begin begin()
                {
                    return begin_;
                }
                
                End end()
                {
                    return end_;
                }
            
            private:
                Begin begin_;
                End end_;
        };
        
        // TODO: cleanup! all of this! add support for reversing
        template<typename C1_TYPE, typename C2_TYPE>
        class pair_iterator
        {
            public:
                using c1_ref = blt::meta::deref_return_t<C1_TYPE>;
                using c2_ref = blt::meta::deref_return_t<C2_TYPE>;
                
                using iterator_category = std::forward_iterator_tag;
                using value_type = std::pair<c1_ref, c2_ref>;
                using difference_type = blt::ptrdiff_t;
                using pointer = void*;
                using reference = value_type&;
                using const_reference = const value_type&;
                
                explicit pair_iterator(C1_TYPE c1, C2_TYPE c2): current_c1_iter(c1), current_c2_iter(c2)
                {}
                
                pair_iterator& operator++()
                {
                    ++current_c1_iter;
                    ++current_c2_iter;
                    return *this;
                }
                
                bool operator==(pair_iterator other) const
                {
                    return current_c1_iter == other.current_c1_iter && current_c2_iter == other.current_c2_iter;
                }
                
                bool operator!=(pair_iterator other) const
                {
                    return current_c1_iter != other.current_c1_iter || current_c2_iter != other.current_c2_iter;
                }
                
                value_type operator*() const
                {
                    return {*current_c1_iter, *current_c2_iter};
                };
                
                value_type operator*()
                {
                    return {*current_c1_iter, *current_c2_iter};
                };
            
            private:
                C1_TYPE current_c1_iter;
                C2_TYPE current_c2_iter;
        };
    }
    
    template<typename Begin, typename End>
    static inline auto iterate(Begin&& begin, End&& end)
    {
        return itr::itr_container<Begin, End>{std::forward<Begin>(begin), std::forward<End>(end)};
    }
    
    template<typename Begin, typename End>
    static inline auto reverse_iterate(Begin&& begin, End&& end)
    {
        return itr::itr_container{std::reverse_iterator(std::forward<Begin>(end)), std::reverse_iterator(std::forward<End>(begin))};
    }
    
    template<typename C1_ITER, typename C2_ITER, template<typename, typename> typename iterator = itr::pair_iterator>
    class pair_enumerator
    {
        public:
            explicit pair_enumerator(C1_ITER c1_begin, C1_ITER c1_end, C2_ITER c2_begin, C2_ITER c2_end):
                    begin_(std::move(c1_begin), std::move(c2_begin)), end_(std::move(c1_end), std::move(c2_end))
            {
                auto size_c1 = c1_end - c1_begin;
                auto size_c2 = c2_end - c2_begin;
                if (size_c1 != size_c2)
                    throw std::runtime_error("Iterator sizes don't match!");
            }
            
            iterator<C1_ITER, C2_ITER> begin()
            {
                return begin_;
            }
            
            iterator<C1_ITER, C2_ITER> end()
            {
                return end_;
            }
        
        private:
            iterator<C1_ITER, C2_ITER> begin_;
            iterator<C1_ITER, C2_ITER> end_;
    };
    
    template<typename T, typename G>
    static inline auto in_pairs(const T& container1, const G& container2)
    {
        return pair_enumerator{container1.begin(), container1.end(), container2.begin(), container2.end()};
    }
    
    template<typename T, typename G>
    static inline auto in_pairs(T& container1, G& container2)
    {
        return pair_enumerator{container1.begin(), container1.end(), container2.begin(), container2.end()};
    }
    
    template<typename T, typename G, blt::size_t size>
    static inline auto in_pairs(const T(& container1)[size], const G(& container2)[size])
    {
        return pair_enumerator{&container1[0], &container1[size], &container2[0], &container2[size]};
    }
    
    template<typename T, typename G, blt::size_t size>
    static inline auto in_pairs(T(& container1)[size], G(& container2)[size])
    {
        return pair_enumerator{&container1[0], &container1[size], &container2[0], &container2[size]};
    }
    
    template<typename T, typename G>
    static inline auto in_pairs(T&& container1, G&& container2)
    {
        return pair_enumerator{container1.begin(), container1.end(), container2.begin(), container2.end()};
    }
    
    template<typename T>
    struct range
    {
        public:
            struct range_itr
            {
                public:
                    using iterator_category = std::bidirectional_iterator_tag;
                    using difference_type = T;
                    using value_type = T;
                    using pointer = T*;
                    using reference = T&;
                private:
                    T current;
                    bool forward;
                public:
                    
                    explicit range_itr(T current, bool forward): current(current), forward(forward)
                    {}
                    
                    value_type operator*() const
                    { return current; }
                    
                    value_type operator->()
                    { return current; }
                    
                    range_itr& operator++()
                    {
                        if (forward)
                            current++;
                        else
                            current--;
                        return *this;
                    }
                    
                    range_itr& operator--()
                    {
                        if (forward)
                            current--;
                        else
                            current++;
                        return *this;
                    }
                    
                    friend bool operator==(const range_itr& a, const range_itr& b)
                    {
                        return a.current == b.current;
                    }
                    
                    friend bool operator!=(const range_itr& a, const range_itr& b)
                    {
                        return a.current != b.current;
                    }
            };
        
        private:
            T _begin;
            T _end;
            T offset = 0;
        public:
            range(T begin, T end): _begin(begin), _end(end), offset(end < begin ? 1 : 0)
            {}
            
            range_itr begin()
            {
                return range_itr(_begin - offset, offset == 0);
            }
            
            range_itr end()
            {
                // not sure if i like this
                return range_itr(_end - offset, offset == 0);
            }
    };
    
    template<typename I>
    class itr_offset
    {
        private:
            I begin_;
            I end_;
        public:
            template<typename T>
            itr_offset(I begin, I end, T offset): begin_(begin), end_(end)
            {
                for (T t = 0; t < offset; t++)
                    ++begin_;
            }
            
            template<typename C, typename T>
            itr_offset(C& container, T offset): begin_(container.begin()), end_(container.end())
            {
                for (T t = 0; t < offset; t++)
                    ++begin_;
            }
            
            auto begin()
            {
                return begin_;
            }
            
            auto end()
            {
                return end_;
            }
    };
    
    template<typename C, typename T>
    itr_offset(C, T) -> itr_offset<typename C::iterator>;
    
    inline constexpr std::size_t dynamic_extent = std::numeric_limits<std::size_t>::max();
    
    template<typename T, std::size_t extent = dynamic_extent>
    class span;
    
    // https://codereview.stackexchange.com/questions/217814/c17-span-implementation
    namespace span_detail
    {
        // detect specializations of span
        template<class T>
        struct is_span : std::false_type
        {
        };
        
        template<class T, std::size_t N>
        struct is_span<span<T, N>> : std::true_type
        {
        };
        
        template<class T>
        inline constexpr bool is_span_v = is_span<T>::value;
        
        // detect specializations of std::array
        template<class T>
        struct is_array : std::false_type
        {
        };
        
        template<class T, std::size_t N>
        struct is_array<std::array<T, N>> : std::true_type
        {
        };
        
        template<class T>
        inline constexpr bool is_array_v = is_array<T>::value;
        
        // detect container
        template<class C, class = void>
        struct is_cont : std::false_type
        {
        };
        
        template<class C>
        struct is_cont<C,
                std::void_t<
                        std::enable_if_t<!is_span_v<C>>,
                        std::enable_if_t<!is_array_v<C>>,
                        std::enable_if_t<!std::is_array_v<C>>,
                        decltype(data(std::declval<C>())),
                        decltype(size(std::declval<C>()))
                >> : std::true_type
        {
        };
        
        template<class C>
        inline constexpr bool is_cont_v = is_cont<C>::value;
    }
    
    template<typename T, std::size_t extent>
    class span
    {
        public:
            using element_type = T;
            using value_type = std::remove_cv_t<T>;
            using size_type = blt::size_t;
            using difference_type = std::ptrdiff_t;
            using pointer = T*;
            using const_pointer = const T*;
            using reference = T&;
            using const_reference = const T&;
            using iterator = T*;
            using const_iterator = const T*;
            using reverse_iterator = std::reverse_iterator<iterator>;
            using const_reverse_iterator = std::reverse_iterator<const_iterator>;
        private:
            size_type size_;
            pointer data_;
        public:
            constexpr span() noexcept: size_(0), data_(nullptr)
            {}
            
            constexpr span(T* data, size_type count): size_(count), data_(data)
            {}
            
            template<class It, std::size_t SIZE, typename std::enable_if_t<extent != dynamic_extent && SIZE == extent, bool> = true>
            constexpr explicit span(It first, size_type count): size_(count), data_(&*first)
            {}
            
            template<class It, std::size_t SIZE, typename std::enable_if_t<extent == dynamic_extent && SIZE == extent, bool> = true>
            constexpr span(It first, size_type count): size_(count), data_(&*first)
            {}
            
            template<class It, class End, std::size_t SIZE, typename std::enable_if_t<extent != dynamic_extent && SIZE == extent, bool> = true>
            constexpr explicit span(It first, End last): size_(&*last - &*first), data_(&*first)
            {}
            
            template<class It, class End, std::size_t SIZE, typename std::enable_if_t<extent == dynamic_extent && SIZE == extent, bool> = true>
            constexpr span(It first, End last): size_(&*last - &*first), data_(&*first)
            {}
            
            template<std::size_t N, typename std::enable_if_t<(N == dynamic_extent || N == extent) &&
                                                              (std::is_convertible_v<std::remove_pointer_t<decltype(
                                                              std::data(std::declval<T(&)[N]>()))>(*)[], T(*)[]>), bool> = true>
            constexpr span(element_type (& arr)[N]) noexcept: size_{N}, data_{arr} // NOLINT
            {}
            
            template<class U, std::size_t N, typename std::enable_if_t<(N == dynamic_extent || N == extent) &&
                                                                       (std::is_convertible_v<std::remove_pointer_t<decltype(
                                                                       std::data(std::declval<T(&)[N]>()))>(*)[], T(*)[]>), bool> = true>
            constexpr span(std::array<U, N>& arr) noexcept: size_(N), data_{arr.data()} // NOLINT
            {}
            
            template<class U, std::size_t N, typename std::enable_if_t<(N == dynamic_extent || N == extent) &&
                                                                       (std::is_convertible_v<std::remove_pointer_t<decltype(
                                                                       std::data(std::declval<T(&)[N]>()))>(*)[], T(*)[]>), bool> = true>
            constexpr span(const std::array<U, N>& arr) noexcept: size_(N), data_{arr.data()} // NOLINT
            {}
            
            template<class R, class RCV = std::remove_cv_t<std::remove_reference_t<R>>, typename std::enable_if_t<
                    extent != dynamic_extent && span_detail::is_cont_v<RCV> &&
                    std::is_convertible_v<std::remove_pointer_t<decltype(std::data(std::declval<R>()))>(*)[], T(*)[]>, bool> = true>
            explicit constexpr span(R&& range): size_(std::size(range)), data_(std::data(range))
            {}
            
            template<class R, class RCV = std::remove_cv_t<std::remove_reference_t<R>>, typename std::enable_if_t<
                    extent == dynamic_extent && span_detail::is_cont_v<RCV> &&
                    std::is_convertible_v<std::remove_pointer_t<decltype(std::data(std::declval<R>()))>(*)[], T(*)[]>, bool> = true>
            constexpr span(R&& range): size_(std::size(range)), data_(std::data(range)) // NOLINT
            {}
            
            template<size_type SIZE, typename std::enable_if_t<
                    extent != dynamic_extent && SIZE == extent && std::is_const_v<element_type>, bool> = true>
            explicit constexpr span(std::initializer_list<value_type> il) noexcept: size_(il.size()), data_(&il.begin()) // NOLINT
            {}
            
            template<size_type SIZE, typename std::enable_if_t<
                    extent == dynamic_extent && SIZE == extent && std::is_const_v<element_type>, bool> = true>
            explicit span(std::initializer_list<value_type> il) noexcept: size_(il.size()), data_(&il.begin()) // NOLINT
            {}
            
            template<class U, std::size_t N, typename std::enable_if_t<
                    extent != dynamic_extent && N == dynamic_extent && std::is_convertible_v<U(*)[], T(*)[]>, bool> = true>
            explicit constexpr span(const span<U, N>& source) noexcept: size_{source.size()}, data_{source.data()}
            {}
            
            template<class U, std::size_t N, typename std::enable_if_t<
                    !(extent != dynamic_extent && N == dynamic_extent) && std::is_convertible_v<U(*)[], T(*)[]>, bool> = true>
            constexpr span(const span<U, N>& source) noexcept: size_{source.size()}, data_{source.data()} // NOLINT
            {}
            
            constexpr span& operator=(const span& copy)
            {
                size_ = copy.size();
                data_ = copy.data();
                return *this;
            }
            
            constexpr span(const span& other) noexcept = default;
            
            constexpr iterator begin() const noexcept
            {
                return data();
            }
            
            constexpr iterator end() const noexcept
            {
                return data() + size();
            }
            
            constexpr const_iterator cbegin() const noexcept
            {
                return data();
            }
            
            constexpr const_iterator cend() const noexcept
            {
                return data() + size();
            }
            
            constexpr reverse_iterator rbegin() const noexcept
            {
                return reverse_iterator{end()};
            }
            
            constexpr reverse_iterator rend() const noexcept
            {
                return reverse_iterator{begin()};
            }
            
            constexpr const_reverse_iterator crbegin() const noexcept
            {
                return reverse_iterator{cend()};
            }
            
            constexpr const_reverse_iterator crend() const noexcept
            {
                return reverse_iterator{cbegin()};
            }
            
            friend constexpr iterator begin(span s) noexcept
            {
                return s.begin();
            }
            
            friend constexpr iterator end(span s) noexcept
            {
                return s.end();
            }
            
            [[nodiscard]] constexpr size_type size() const noexcept
            {
                return size_;
            }
            
            [[nodiscard]] constexpr size_type size_bytes() const noexcept
            {
                return size() * sizeof(T);
            }
            
            [[nodiscard]] constexpr bool empty() const noexcept
            {
                return size() == 0;
            }
            
            constexpr reference operator[](size_type idx) const
            {
                return *(data() + idx);
            }
            
            constexpr reference front() const
            {
                return *data();
            }
            
            constexpr reference back() const
            {
                return *(data() + (size() - 1));
            }
            
            constexpr pointer data() const noexcept
            {
                return data_;
            }
            
            constexpr span<T, dynamic_extent> first(size_type cnt) const
            {
                return {data(), cnt};
            }
            
            constexpr span<T, dynamic_extent> last(size_type cnt) const
            {
                return {data() + (size() - cnt), cnt};
            }
            
            constexpr span<T, dynamic_extent> subspan(size_type off, size_type cnt = dynamic_extent) const
            {
                return {data() + off, cnt == dynamic_extent ? size() - off : cnt};
            }
        
    };
    
    template<class T, std::size_t N>
    span(T (&)[N]) -> span<T, N>;
    
    template<class T, std::size_t N>
    span(std::array<T, N>&) -> span<T, N>;
    
    template<class T, std::size_t N>
    span(const std::array<T, N>&) -> span<const T, N>;
    
    template<class Cont>
    span(Cont&) -> span<typename Cont::value_type>;
    
    template<class Cont>
    span(const Cont&) -> span<const typename Cont::value_type>;
}

#endif //BLT_RANGES_H