/*
 * 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:
 *      2016-2017, Danny Robson <danny@nerdcruft.net>
 */

#ifndef CRUFT_VK_OBJECT_HPP
#define CRUFT_VK_OBJECT_HPP

#include "./traits.hpp"
#include "./except.hpp"

#include <utility>
#include <vector>

namespace cruft::vk {
    /// the base class for all non-trivial vulkan objects requiring lifetime
    /// management.
    template <typename T>
    struct object {
        using native_t = id_t<T>;

        object (native_t);
        object (object&&);

        object (const object&) = delete;

        const native_t& native (void) const&;
        native_t& native (void) &;

    protected:
        native_t m_native;
    };


    template <typename SelfT>
    struct root : public object<SelfT> {
        using native_t = typename object<SelfT>::native_t;

        template <typename ...Args>
        root (Args &&...args):
            object<SelfT> (make (std::forward<Args> (args)...))
        { ; }

        ~root ()
        {
            life_traits<SelfT>::destroy (this->native (), nullptr);
        }

    private:
        template <typename ...Args>
        static native_t
        make (Args &&...args)
        {
            native_t id;
            auto res = life_traits<SelfT>::create (std::forward<Args> (args)..., &id);
            error::try_code (res);
            return id;
        }
    };


    /// a vulkan object that must be directly instantiated through
    /// constructor arguments, rather than being enumerated and owned by
    /// another object.
    template <typename T>
    struct descendant : public object<T> {
        using native_t = typename object<T>::native_t;

        template <typename ...Args>
        descendant (Args &&...args):
            object<T> (make (std::forward<Args> (args)...))
        { ; }

        ~descendant ()
        {
            life_traits<T>::destroy (this->native (), nullptr);
        }

    private:
        template <typename Base, typename ...Args>
        static
        native_t make (Base &&base, Args &&...args)
        {
            native_t id;
            auto res = life_traits<T>::create (base.native (), std::forward<Args> (args)..., &id);
            error::try_code (res);
            return id;
        }
    };


    /// a vulkan object that is obtained by listings from a parent object.
    template <typename T>
    struct enumerated : public object<T> {
        using object<T>::object;

        static std::vector<T>
        find (const instance &parent);
    };


    /// a vulkan object that is directly owned by a parent object.
    ///
    /// typically implies that this object must be freed using a reference to
    /// the parent object.
    template <typename SelfT, typename OwnerT>
    struct owned : public object<SelfT> {
        using native_t = typename object<SelfT>::native_t;
        using owner_t = OwnerT;

        using object<SelfT>::object;

        ///////////////////////////////////////////////////////////////////////
        template <typename ...Args>
        owned (OwnerT &owner, Args &&...args):
            object<SelfT> (
                error::try_query (
                    life_traits<SelfT>::create,
                    owner.native (),
                    std::forward<Args> (args)...
                )
            )
        { ; }


        //---------------------------------------------------------------------
        owned (owned &&rhs):
            object<SelfT> (std::move (rhs))
        { ; }


        //---------------------------------------------------------------------
        ~owned ()
        {
            CHECK_EQ (this->native (), VK_NULL_HANDLE);
        }


        //---------------------------------------------------------------------
        void
        destroy (OwnerT &owner)
        {
            life_traits<SelfT>::destroy (owner.native (), this->native (), nullptr);
            this->m_native = VK_NULL_HANDLE;
        }
    };


    template <typename SelfT, typename OwnerT, typename ...Args>
    auto
    make_owned (OwnerT &owner, Args &&...args)
    {
        class destroyer {
        public:
            destroyer (SelfT &&_self, OwnerT &_owner):
                m_self (std::move (_self)),
                m_owner (_owner)
            { ; }

            destroyer (destroyer &&rhs):
                m_self (std::move (rhs.m_self)),
                m_owner (rhs.m_owner)
            { ; }

            ~destroyer ()
            {
                m_self.destroy (m_owner);
            }

            // it's unclear whether we want to work around reseating m_owner,
            // or if this operation just isn't sufficiently prevalent to
            // justify the work.
            destroyer& operator= (destroyer &&rhs) = delete;

            SelfT*
            operator-> ()&
            { return &m_self; }

        private:
            SelfT m_self;
            OwnerT &m_owner;
        };

        return destroyer {
            SelfT { owner, std::forward<Args> (args)... },
            owner
        };
    };
};

#endif