extern int $int$;

enum Enum {OK,NOK};

subint Int {0..1};

interface I
{
  in void return_void();
  in Int return_int();
  in bool return_bool();
  in Enum return_enum(int i, out int j);
  out void foo(int i);

  behaviour
  {
    on return_void: {foo;}
    on return_int: {foo; reply(0);}
    on return_bool: {foo; reply(true);}
    on return_enum: {foo; reply(Enum.OK);}
    on return_enum: {reply(Enum.NOK);}
  }
}

interface II
{
  in void return_void();
  in Int return_int();
  in bool return_bool();
  in Enum return_enum(int i, out int j);
  out void foo(int i);

  behaviour
  {
    bool idle = true;
    [idle] {
      on return_void: {idle = false;}
      on return_int: {idle = false; reply(0);}
      on return_bool: {idle = false; reply(true);}
      on return_enum: {idle = false; reply(Enum.OK);}
      on return_enum: {reply(Enum.NOK);}
    }
    [!idle] {
      on return_void: illegal;
      on return_int: illegal;
      on return_bool: illegal;
      on return_enum: illegal;
      on inevitable: {idle = true; foo;}
    }
  }
}

component C
{
  provides I p_inner;
  requires II r_inner;

  behaviour
  {
    enum TYPE {VOID, BOOL, INT, ENUM};
    TYPE type = TYPE.VOID;

    Int i = 1;
    Enum r = Enum.NOK;

    on p_inner.return_void(): blocking {type = TYPE.VOID; r_inner.return_void();}
    on p_inner.return_bool(): blocking {type = TYPE.BOOL; bool b = r_inner.return_bool();}
    on p_inner.return_int(): blocking {type = TYPE.INT; i = r_inner.return_int();}
    on p_inner.return_enum(i,j): blocking {type = TYPE.ENUM; r = r_inner.return_enum(i,j); if(r.NOK) reply(r);}
    [type.VOID] on r_inner.foo(i): {p_inner.foo(i); p_inner.reply();}
    [type.BOOL] on r_inner.foo(i): {p_inner.foo(i); p_inner.reply(true);}
    [type.INT]  on r_inner.foo(j): {p_inner.foo(j); p_inner.reply(i); i = 1;}
    [type.ENUM] on r_inner.foo(j): {p_inner.foo(j); p_inner.reply(r);}
  }
}

component B
{
  provides I p_proxy_inner;
  requires I r_proxy_inner;

  behaviour
  {
    on p_proxy_inner.return_void(): {r_proxy_inner.return_void();}
    on p_proxy_inner.return_bool(): {bool b = r_proxy_inner.return_bool(); reply(b);}
    on p_proxy_inner.return_int(): {Int i = r_proxy_inner.return_int(); reply(i);}
    on p_proxy_inner.return_enum(i,j): {Enum r = r_proxy_inner.return_enum(i,j); reply(r);}
    on r_proxy_inner.foo(i): p_proxy_inner.foo(i);
  }
}

component shell
{
  provides I p_outer;
  requires II r_outer;

  system
  {
    B b;
    C c;
    p_outer<=>b.p_proxy_inner;
    b.r_proxy_inner<=>c.p_inner;
    c.r_inner<=>r_outer;
  }
}