/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Copyright 2015-2018 Danny Robson <danny@nerdcruft.net>
 */

#pragma once

#include "cast.hpp"
#include "types/traits.hpp"

#include <limits>
#include <type_traits>
#include <iosfwd>


namespace util::strongdef {
    /// A transparent wrapper around a (typically lightweight) type for the
    /// purposes of overload disambiguation. It acts like a typesafe typedef.
    template <typename TagT, typename T = typename TagT::index_type>
    struct index {
        using value_type = T;
        using tag_type   = TagT;

        // TODO: ideally we'd default the constructor, but templated
        // constructors can't be defaulted? So we just stub one out.
        constexpr explicit index () { ; }

        constexpr explicit index (util::types::identity_t<T> const &_data): data (_data) { ; }
        constexpr index (index const&) = default;

        index& operator= (T const &) = delete;
        index& operator= (index const &) = default;

        // conversion operators must not be explicit or it defeats the point
        // of this class (ease of use, transparency).
        explicit operator const T& (void) const& { return data; }
        explicit operator       T& (void)      & { return data; }

        constexpr auto operator== (T const &) = delete;
        constexpr auto operator== (index const &rhs) const
        {
            return data == rhs.data;
        }

        constexpr auto operator!= (T const&) = delete;
        constexpr auto operator!= (index const &rhs) const
        {
            return data != rhs.data;
        }

        constexpr auto operator< (T const &) const = delete;
        constexpr auto operator< (index const &rhs) const { return data < rhs.data; }

        constexpr auto operator> (T const &) const = delete;
        constexpr auto operator> (index const &rhs) const { return data > rhs.data; }

        constexpr auto& operator++ (void)& { ++data; return *this; }

        T data;
    };


    template <typename TagT, typename T>
    std::ostream&
    operator<< (std::ostream &os, index<TagT,T> const &val)
    {
        return os << val.data;
    }
}


template <typename ContainerT>
static auto indices (ContainerT const &obj)
{
    using index_t = typename ContainerT::index_t;

    struct view {
        view (ContainerT const &_obj):
            m_obj (_obj)
        { ; }

        struct iterator {
            iterator (index_t _idx):
                idx (_idx)
            { ; }

            iterator& operator++ ()
            {
                ++idx.data;
                return *this;
            }

            index_t const& operator*  () const { return  idx; }
            index_t const* operator-> () const { return &idx; }

            bool operator!= (iterator const &rhs) { return idx != rhs.idx; }

        private:
            index_t idx;
        };

        iterator begin (void) const { return iterator (index_t (0)); }
        iterator end   (void) const
        {
            return index_t (
                util::cast::narrow<
                    typename index_t::value_type
                > (
                    m_obj.size ()
                )
            );
        }

    private:
        ContainerT const &m_obj;
    };

    return view {obj};
}