#ifndef arc__validate__except_hxx_
#define arc__validate__except_hxx_

#include <arc/validate/export.hxx>

#include <stdexcept>
#include <iostream>
#include <memory>
#include <source_location>

namespace arc::validate
{

  class LIBARC_VALIDATE_SYMEXPORT skipped_t
  {};

  class LIBARC_VALIDATE_SYMEXPORT not_implemented_t
  {};

  class LIBARC_VALIDATE_SYMEXPORT failure_t
  {
  public:
    class LIBARC_VALIDATE_SYMEXPORT extras_t
    {
    public:
      template<typename T>
      extras_t(T extras)
        : extras_{std::make_shared<container_t<T>>(std::move(extras))}
      {}

      friend
      std::ostream&
      operator<<(std::ostream&, extras_t const&);

    private:
      struct concept_t
      {
        virtual
        ~concept_t() noexcept = default;

        virtual
        void
        print(std::ostream&) const = 0;

      };

      template<typename T>
      struct container_t
        : concept_t
      {
        template<typename... Args>
        container_t(Args&&... args)
          : extras{std::forward<Args>(args)...}
        {}

        void
        print(std::ostream& o) const
        {
          extras.print(o);
        }

        T extras;

      };

      std::shared_ptr<concept_t const> extras_;

    };

    failure_t(std::source_location,
              std::string,
              extras_t);

    extras_t const&
    extras() const;

  private:
    extras_t extras_;

  };

  LIBARC_VALIDATE_SYMEXPORT
  std::ostream&
  operator<<(std::ostream&, failure_t::extras_t const&);

} // namespace arc::validate

#endif