#pragma once
#include<optional>
#include<vector>
#include<tuple>
#include<hysj/coroutines/builtin/trees.hpp>
#include<hysj/coroutines/void_qua.hpp>

#include<hysj/graphs/depth_first_search.hpp>

#include<hysj/tools/reflection.hpp>
#include<hysj/tools/tuple.hpp>
#include<hysj/tools/types.hpp>
#include<hysj/tools/type_traits.hpp>

#include<hysj/detail/prologue.hpp>
namespace hysj::inline _HYSJ_VERSION_NAMESPACE::graphs{

namespace connected_components{

  #define HYSJ_GRAPHS_CONNECTED_COMPONENTS_EVENT_TAGS \
    (component_begin)                                 \
    (member)                                          \
    (component_end)	

  enum class event_tag : unsigned {
    HYSJ_SPLAT(0,HYSJ_GRAPHS_CONNECTED_COMPONENTS_EVENT_TAGS)
  };
  HYSJ_MIRROR_ENUM(event_tag,
                   HYSJ_GRAPHS_CONNECTED_COMPONENTS_EVENT_TAGS)

  #define HYSJ_LAMBDA(id)                                       \
    using id##_tag_type = constant_t<event_tag::id>;            \
    inline constexpr auto id##_tag = constant_c<event_tag::id>;
  HYSJ_MAP_LAMBDA(HYSJ_GRAPHS_CONNECTED_COMPONENTS_EVENT_TAGS)
  #undef HYSJ_LAMBDA
  
  namespace events{

    template<event_tag T>
    struct component{
      static constexpr constant_t<T> tag{};

      auto operator<=>(const component &) const = default;
      
      friend HYSJ_MIRROR_STRUCT(component);
    };
    using component_begin = component<component_begin_tag>;
    using component_end = component<component_end_tag>;

    template<typename element_id>
    struct member{
      static constexpr member_tag_type tag{};
      element_id element;
      
      auto operator<=>(const member &) const = default;
      
      friend HYSJ_MIRROR_STRUCT(member,element);
    };

  }
  
  template<typename CCInput,typename CCOutput>
  struct bidirectional_dfs_output{
    CCInput cc_input;
    CCOutput cc_output;
    template<typename DFSProtoPromise>
    auto operator()(DFSProtoPromise,const auto &,auto dfs_event)
      -> coroutines::return_object_t<DFSProtoPromise>
    {
      auto &dfs_promise = HYSJ_PROMISE(DFSProtoPromise);

      if constexpr(dfs_event.tag == dfs::root_tag)
        co_await (cc_output(dfs_promise,
                            events::component_begin{}),
                  void_qua<always()>{})();
      if constexpr(dfs_event.tag == any_of(dfs::root_tag,dfs::sprout_tag,
                                           dfs::climb_tag,dfs::frond_tag,
                                           dfs::vine_tag,dfs::liana_tag,
                                           dfs::weed_tag))
        co_await (cc_output(dfs_promise,
                            events::member{ .element = dfs_event.element }),
                  void_qua<always()>{})();
      if constexpr(dfs_event.tag == dfs::palm_tag)
        co_await (cc_output(dfs_promise,
                            events::component_end{}),
                  void_qua<always()>{})();
      co_return;
    }
  };

  
  inline constexpr auto make_bidirectional_dfs_output =
    [](auto cc_input,auto cc_output){
      return 
        combine<0>(
          bidirectional_dfs_output{
            .cc_input = cc_input,
            .cc_output = cc_output
          },
          std::bind_front(coroutines::get_proto_promise,type_c<void>));
    };

  template<typename DFSFactory>
  struct input{
    DFSFactory dfs_factory;

    friend HYSJ_MIRROR_STRUCT(input,dfs_factory);
  };
  

  //FIXME: constrain - jeh
  auto algorithm(auto cc_proto_promise,
                 auto cc_input,
                 auto cc_output){
    return cc_input.dfs_factory(
      cc_proto_promise,
      make_bidirectional_dfs_output(cc_input,cc_output));
  }
  
} //connected_components

namespace cc = connected_components;

} //hysj::graphs
#include<hysj/detail/epilogue.hpp>