#pragma once

#include <cxxabi.h>
#include <iostream>

#include <concepts>
#include <functional>
#include <memory>
#include <string_view>
#include <tuple>
#include <unordered_map>
#include <variant>

namespace mcc::fsm
{

namespace traits
{

/*
    The only requirement to Event-class is public-accepted static constant 'ID'
 */
template <typename T>
concept fsm_event_c = std::is_default_constructible_v<T> && std::is_move_constructible_v<T> && std::movable<T> &&
                      requires { requires std::same_as<const std::string_view, decltype(T::ID)>; };


/*
    The only requirements to State-class is public-accepted static constant 'ID' and
    definition of type transition_table_t
 */
template <typename T>
concept fsm_state_c =
    std::is_default_constructible_v<T> && std::is_move_constructible_v<T> && std::movable<T> && requires {
        requires std::same_as<const std::string_view, decltype(T::ID)>;
        typename T::transition_t;
    };


// concept for std::pair
template <typename T>
concept fsm_pair_of_types_c =
    requires { []<typename T1, typename T2>(std::type_identity<std::pair<T1, T2>>) {}(std::type_identity<T>()); };


template <typename T>
concept fsm_tuple_of_pairs_c =
    requires { []<fsm_pair_of_types_c... PTs>(std::type_identity<std::tuple<PTs...>>) {}(std::type_identity<T>()); };


template <typename T>
concept fsm_tuple_of_events_c =
    requires { []<fsm_event_c... EvTs>(std::type_identity<std::tuple<EvTs...>>) {}(std::type_identity<T>()); };
}  // namespace traits


/*  Event-to-State transition table definition  */

template <traits::fsm_pair_of_types_c... PTs>
struct fsm_transition_table_t;

template <traits::fsm_pair_of_types_c PT>
struct fsm_transition_table_t<PT> {
    using events_t = std::tuple<typename PT::first_type>;

    using event_state_pair_t = PT;

    using unique_states_t = std::tuple<typename PT::second_type>;

    template <typename EvT>
    using find_state_by_event_t =
        std::conditional_t<std::same_as<EvT, typename PT::first_type>, typename PT::second_type, void>;
};


template <traits::fsm_pair_of_types_c PT, traits::fsm_pair_of_types_c... PTs>
struct fsm_transition_table_t<PT, PTs...> {
private:
    static constexpr bool non_unique_event = (std::same_as<typename PTs::first_type, typename PTs::first_type> || ...);

public:
    using events_t =
        std::conditional_t<non_unique_event,
                           typename fsm_transition_table_t<PTs...>::events_t,
                           decltype(std::tuple_cat(std::declval<std::tuple<typename PT::first_type>>(),
                                                   std::declval<typename fsm_transition_table_t<PTs...>::events_t>()))>;

    using event_state_pair_t =
        std::conditional_t<non_unique_event,
                           typename fsm_transition_table_t<PTs...>::event_state_pair_t,
                           decltype(std::tuple_cat(
                               std::declval<std::tuple<PT>>(),
                               std::declval<typename fsm_transition_table_t<PTs...>::event_state_pair_t>()))>;

    using unique_states_t = std::conditional_t<
        non_unique_event,
        typename fsm_transition_table_t<PTs...>::unique_states_t,
        std::conditional_t<(std::same_as<typename PT::second_type, typename PTs::second_type> || ...),
                           typename fsm_transition_table_t<PTs...>::unique_states_t,
                           decltype(std::tuple_cat(
                               std::declval<std::tuple<typename PT::second_type>>(),
                               std::declval<typename fsm_transition_table_t<PTs...>::unique_states_t>()))>>;

private:
    template <typename EvT, traits::fsm_tuple_of_pairs_c TplT>
    struct find_state_by_event;

    template <typename LookEvT, typename EvT, typename StT>
    struct find_state_by_event<LookEvT, std::tuple<std::pair<EvT, StT>>> {
        using state_t = std::conditional_t<std::same_as<LookEvT, EvT>, StT, void>;
    };

    template <typename LookEvT, typename EvT, typename StT, traits::fsm_pair_of_types_c... PairTs>
    struct find_state_by_event<LookEvT, std::tuple<std::pair<EvT, StT>, PairTs...>> {
        using state_t = std::conditional_t<std::same_as<LookEvT, EvT>,
                                           StT,
                                           typename find_state_by_event<LookEvT, std::tuple<PairTs...>>::state_t>;
    };

public:
    // template <typename EvT, traits::fsm_tuple_of_pairs_c TplT>
    template <typename EvT>
    using find_state_by_event_t = typename find_state_by_event<EvT, event_state_pair_t>::state_t;
};


class MccFiniteStateMachine
{
protected:
    /*  helper types definition  */

    // merge N std::tuple types with filtering dublicates
    // (NOTE: the first std::tuple must contain unique types!!!)
    template <typename... TplTs>
    struct merge_tuples;

    template <typename TplT>
    struct merge_tuples<TplT> {
        using result_t = TplT;
    };

    template <typename TplT1, typename TplT2>
    struct merge_tuples<TplT1, TplT2> {
        using result_t = TplT1;
    };

    template <typename... T1, typename T2, typename... T2s>
    struct merge_tuples<std::tuple<T1...>, std::tuple<T2, T2s...>>
        : std::conditional_t<(std::same_as<T1, T2> || ...),
                             merge_tuples<std::tuple<T1...>, std::tuple<T2s...>>,
                             merge_tuples<std::tuple<T1..., T2>, std::tuple<T2s...>>> {
    };

    template <typename TplT1, typename TplT2, typename TplT3, typename... TplTs>
    struct merge_tuples<TplT1, TplT2, TplT3, TplTs...>
        : merge_tuples<typename merge_tuples<TplT1, TplT2>::result_t, TplT3, TplTs...> {
    };

    template <typename... TplTs>
    using merge_tuples_t = typename merge_tuples<TplTs...>::result_t;


    // deduce all unique states from the initial one
    template <bool stop, typename ResTplT, typename... InTplTs>
    struct deduce_states;

    template <typename ResTplT, typename... InTplTs>
    struct deduce_states<true, ResTplT, InTplTs...> {
        using states_t = ResTplT;
    };

    template <typename ResTplT, traits::fsm_state_c... StTs, typename... InTplTs>
    struct deduce_states<false, ResTplT, std::tuple<StTs...>, InTplTs...> {
        using curr_collection_t =
            merge_tuples_t<ResTplT, std::tuple<StTs...>, typename StTs::transition_t::unique_states_t...>;

        using states_t = typename deduce_states<std::tuple_size_v<ResTplT> == std::tuple_size_v<curr_collection_t>,
                                                curr_collection_t,
                                                typename StTs::transition_t::unique_states_t...,
                                                InTplTs...>::states_t;
    };

    template <traits::fsm_state_c InitStateT>
    using deduce_states_t = typename deduce_states<false, std::tuple<>, std::tuple<InitStateT>>::states_t;


    // deduce all unique events from the initial state transition table
    template <bool stop, typename ResTplT, typename... InTplTs>
    struct deduce_events;

    template <typename ResTplT, typename... InTplTs>
    struct deduce_events<true, ResTplT, InTplTs...> {
        using events_t = ResTplT;
    };

    template <traits::fsm_state_c StT>
    struct deduce_events<false, typename StT::transition_t::events_t, std::tuple<>> {
        using curr_collection_t = typename StT::transition_t::events_t;
        using events_t = typename deduce_states<false,
                                                curr_collection_t,
                                                typename StT::transition_t::events_t,
                                                typename StT::transition_t::unique_states_t>::events_t;
    };

    template <traits::fsm_tuple_of_events_c ResTplT,
              traits::fsm_tuple_of_events_c... EvTplTs,
              traits::fsm_state_c... StTs,
              typename... InTplTs>
    struct deduce_events<false, ResTplT, EvTplTs..., std::tuple<StTs...>, InTplTs...> {
        using curr_collection_t = merge_tuples_t<ResTplT, EvTplTs...>;

        using events_t = typename deduce_states<std::tuple_size_v<ResTplT> == std::tuple_size_v<curr_collection_t>,
                                                curr_collection_t,
                                                typename StTs::transition_t::events_t...,
                                                typename StTs::transition_t::unique_states_t...>::events_t;
    };

    template <traits::fsm_state_c InitStateT>
    using deduce_events_t = typename deduce_events<false, InitStateT>::events_t;
    // using deduce_events_t = typename deduce_events<false, std::tuple<>, std::tuple<>,
    // std::tuple<InitStateT>>::events_t;

    template <typename TplT>
    struct variant_from_tuple;

    template <typename... Ts>
    struct variant_from_tuple<std::tuple<Ts...>> {
        using variant_t = std::variant<Ts*...>;
    };

    template <typename TplT>
    using variant_from_tuple_t = typename variant_from_tuple<TplT>::variant_t;


    //
    template <typename EvTplT, typename FT, size_t... Is>
    static void for_each_event(FT&& func, std::index_sequence<Is...>)
    {
        (func(std::get<Is>(EvTplT{})), ...);
    };

    template <typename EvTplT, typename FT>
    static void for_each_event(FT&& func)
    {
        for_each_event<EvTplT>(std::forward<FT>(func), std::make_index_sequence<std::tuple_size_v<EvTplT>>());
    };


    template <traits::fsm_event_c EvT>
    inline static std::unordered_map<const MccFiniteStateMachine*, std::function<void(EvT&)>> _dispatchEventFunc{};

public:
    template <traits::fsm_state_c InitStateT>
    MccFiniteStateMachine(InitStateT)
    {
        using states_t = deduce_states_t<InitStateT>;
        auto states = std::make_shared<states_t>();

        auto currentState = std::make_shared<variant_from_tuple_t<states_t>>();
        *currentState = &std::get<InitStateT>(*states);

        int status;
        char* aa = abi::__cxa_demangle(typeid(states_t).name(), NULL, NULL, &status);
        std::cout << "states_t = " << aa << '\n';
        free(aa);

        /*
        aa = abi::__cxa_demangle(typeid(deduce_events_t<InitStateT>).name(), NULL, NULL, &status);
        std::cout << "events_t = " << aa << '\n';
        free(aa);


        // setup dispatch event functions
        for_each_event<deduce_events_t<InitStateT>>([states, currentState, this]<traits::fsm_event_c EvT>(EvT) {
            _dispatchEventFunc<EvT>[this] = [states, currentState, this](EvT& event) {
                std::visit(
                    [&event, states]<traits::fsm_state_c curr_state_t>(curr_state_t*) {
                        using to_state_t = curr_state_t::trasition_table_t::template find_state_by_event_t<EvT>;
                        if constexpr (std::is_void_v<to_state_t>) {
                            /// throw?!!
                            return;
                        }

                        // exit from current
                        if constexpr (requires(curr_state_t inst) {
                                          { inst.exit(std::declval<EvT>()) };
                                      }) {
                            std::get<curr_state_t>(states).exit(event);
                        } else if constexpr (requires(curr_state_t inst) {
                                                 { inst.exit() };
                                             }) {
                            std::get<curr_state_t>(states).exit();
                        }

                        // transit ...
                        if constexpr (requires(EvT inst) {
                                          { inst.on_transit() };
                                      }) {
                            event.on_transit();
                        }

                        // enter to new
                        if constexpr (requires(to_state_t inst) {
                                          { inst.enter(std::declval<EvT>()) };
                                      }) {
                            std::get<curr_state_t>(states).enter(event);
                        } else if constexpr (requires(to_state_t inst) {
                                                 { inst.enter() };
                                             }) {
                            std::get<curr_state_t>(states).enter();
                        }
                    },
                    currentState);
            };
        });
        */
    }


    template <traits::fsm_event_c EvT>
    auto dispatchEvent(EvT& event)
    {
        _dispatchEventFunc<EvT>[this](event);
    }
};


}  // namespace mcc::fsm