#pragma once
#include <exception>
#include <stdexcept>
#include <cstring>
#include <cassert>
#include <string>

struct Slug {};

template <class T>
class Try {
public:
    Try() {
    }
    Try(T value) : value_(value), empty_(false) {
    }
    template <typename Ex>
    Try(const Ex& ex) {
        try {
            throw ex;
        } catch (...) {
            eptr_ = std::current_exception();
        }
    }
    Try(std::exception_ptr ep) : eptr_(ep) {
    }
    template <typename Ex>
    Try(T value, const Ex& ex) : value_(value), empty_(false) {
        try {
            throw ex;
        } catch (...) {
            eptr_ = std::current_exception();
        }
    }
    const T& Value() {
        if (eptr_) {
            std::rethrow_exception(eptr_);
        } else if (empty_) {
            throw std::runtime_error("Object is empty");
        }
        return value_;
    }
    virtual void Throw() {
        if (eptr_) {
            std::rethrow_exception(eptr_);
        } else {
            throw std::runtime_error("No exception");
        }
    }
    bool IsFailed() {
        if (eptr_) {
            return true;
        } else {
            return false;
        }
    }

private:
    bool empty_ = true;
    T value_;
    std::exception_ptr eptr_;
};

template <>
class Try<void> : private Try<Slug> {
public:
    Try() {
    }
    template <typename Exv>
    Try(const Exv& exv) : Try<Slug>(exv) {
    }
    void Throw() {
        Try<Slug>::Throw();
    }
    bool IsFailed() {
        return Try<Slug>::IsFailed();
    }
};

template <class Function, class... Args>
auto TryRun(Function func, Args... args) {
    using ReturnType = decltype(func(args...));
    try {
        func(args...);
        if constexpr (std::is_same<ReturnType, void>::value) {
            return Try<ReturnType>();
        } else {
            return Try<ReturnType>(func(args...));
        }
    } catch (std::exception& e) {
        return Try<ReturnType>(std::current_exception());
    } catch (const char* str) {
        std::runtime_error e(str);
        return Try<ReturnType>(e);
    } catch (int i) {
        std::runtime_error e(std::strerror(i));
        return Try<ReturnType>(e);
    } catch (...) {
        std::runtime_error e("Unknown exception");
        return Try<ReturnType>(e);
    }
}