export module builder;
import <type_traits>;

export template <bool param1 = false, bool param2 = false>
struct Builder;
template <bool enabled>
struct BuildMixin {};

template <>
struct BuildMixin<true> {
  auto build(this auto&& self)
    requires requires { self.p1 + self.p2; }
  {
    return self.p1 + self.p2;
  }
};

template <bool enabled>
struct Param1Mixin {};

template <>
struct Param1Mixin<false> {
  auto fill_param1(this auto&& self)
    requires requires { self.p1; }
  {
    self.p1 = 1;
    return Builder<true, std::remove_reference_t<decltype(self)>::param2_v>(
        self);
  }
};

template <bool enabled>
struct Param2Mixin {};

template <>
struct Param2Mixin<false> {
  auto fill_param2(this auto&& self)
    requires requires { self.p2; }
  {
    self.p2 = 1;
    return Builder<std::remove_reference_t<decltype(self)>::param1_v, true>(
        self);
  }
};

template <bool param1, bool param2>
struct Builder : BuildMixin<param1 && param2>,
                 Param1Mixin<param1>,
                 Param2Mixin<param2> {
  const constinit static auto param1_v = param1;
  const constinit static auto param2_v = param2;
  int p1;
  int p2;
  Builder() : p1(0), p2(0) {}
  Builder(auto&& other) : p1(other.p1), p2(other.p2) {}
};