//              Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
//   (See accompanying file LICENSE.txt or copy at
//        https://www.boost.org/LICENSE_1_0.txt)

// SPDX-License-Identifier: BSL-1.0
#pragma once

#include <Progmasoft/Catch3/AssertionInfo.hpp>
#include <Progmasoft/Catch3/Internal/Decomposer.hpp>

#include <string>

namespace Catch {

    class RunContext;

    struct AssertionReaction {
        bool shouldDebugBreak = false;
        bool shouldThrow = false;
        bool shouldSkip = false;
    };

    class AssertionHandler {
        AssertionInfo m_assertionInfo;
        AssertionReaction m_reaction;
        bool m_completed = false;
        // Since all uses are hidden in the .cpp file, we can directly use
        // the final type and avoid going through virtual dispatch, without
        // massive compilation time overhead.
        RunContext& m_resultCapture;

        void finishIncomplete();

    public:
        AssertionHandler
            (   StringRef macroName,
                SourceLineInfo const& lineInfo,
                StringRef capturedExpression,
                ResultDisposition::Flags resultDisposition );
        ~AssertionHandler() {
            // We want the common fast path inlinable, and the virtual
            // dispatch in a function in single TU.
            if ( !m_completed ) { finishIncomplete(); }
        }


        template<typename T>
        constexpr void handleExpr( ExprLhs<T> const& expr ) {
            handleExpr( expr.makeUnaryExpr() );
        }
        void handleExpr( ITransientExpression const& expr );

        void handleMessage(ResultWas::OfType resultType, std::string&& message);

        void handleExceptionThrownAsExpected();
        void handleUnexpectedExceptionNotThrown();
        void handleExceptionNotThrownAsExpected();
        void handleThrowingCallSkipped();

        // Marking this as `noexcept` gives us measurable improvement
        // in optimized compilation times. Making it `noexcept` changes
        // what happens if the underlying code throws, **but** the only
        // way this can throw is if the reporter itself throws from
        // `assertionEnded`. However, in such case the process is going
        // to abort anyway, because we will enter `assertionEnded` again
        // from the (noexcept) destructor of `AssertionHandler` above.
        // In the future, all reporter event handlers will be marked
        // `noexcept` to make this limitation explicit.
        void handleUnexpectedInflightException() noexcept;
        // Ideally we could extend the logic above to more of the handle*
        // function, but right now it would worsen the behaviour of
        // preexisting custom reporters that throw from event handlers.

        void complete();

        // query
        auto allowThrows() const -> bool;
    };

    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str );

} // namespace Catch