#include <gtest/gtest.h>
#include <folly/Utility.h>
#include <folly/lang/CustomizationPoint.h>
#include <folly/functional/Invoke.h>
template<class T>
struct Tag {
};

template<class T>
constexpr auto tag_c = Tag<T>{};
namespace A
{
struct FooCpo {
 template<typename T>
 auto operator()(Tag<T> t) const
     noexcept(folly::is_nothrow_tag_invocable_v<FooCpo, Tag<T> >)
     -> folly::tag_invoke_result_t<FooCpo, Tag<T>> {
   return folly::tag_invoke(*this, t);
 }
};
struct BarCpo {
     template<typename A>
     auto operator()(A&&a ) const
         noexcept(folly::is_nothrow_tag_invocable_v<BarCpo, A>)
         -> folly::tag_invoke_result_t<BarCpo, A> {
       return folly::tag_invoke(*this, (A&&)a);
     }
};
FOLLY_DEFINE_CPO(BarCpo, doathing)
FOLLY_DEFINE_CPO(FooCpo, dosomething)
}

namespace B
{
struct FooCpo {
 template<typename A>
 auto operator()(Tag<A> t) const
     noexcept(folly::is_nothrow_tag_invocable_v<FooCpo, Tag<A> >)
     -> folly::tag_invoke_result_t<FooCpo, Tag<A>> {
   return folly::tag_invoke(*this, t);
 }
};
FOLLY_DEFINE_CPO(FooCpo, dosomething)
}
namespace My
{
class SomeClass
{
  friend void tag_invoke(folly::cpo_t<A::dosomething>, Tag<SomeClass>)
  { std::cout << "A someclass\n";
  }
  friend void tag_invoke(folly::cpo_t<A::doathing>, const  SomeClass& some)
  { std::cout << "A doathing someclass\n";
  }
  friend void tag_invoke(folly::cpo_t<B::dosomething>, Tag<SomeClass>)
  { std::cout << "B someclass\n";
  }
};

}

TEST(cpo, basic)
{
  My::SomeClass c;
  A::doathing(c);
}
TEST(cpo, advance)
{
  A::dosomething(tag_c<My::SomeClass>);
  B::dosomething(tag_c<My::SomeClass>);
}