package akka;

import akka.actor.typed.*;
import akka.actor.typed.javadsl.*;

import java.util.UUID;

public class JavaAkkaTest {
  public static void main(String[] args) {
    ActorRef<String> mainApp = ActorSystem.create(MainApp.create(), "MainApp");
    mainApp.tell("start");
    mainApp.tell("stop"); // 关闭父Actor时会先关闭所有子Actor
  }
}

/**
 * 一般来说都需要创建一个MainApp，用于启动其他的Actor
 */
class MainApp extends AbstractBehavior<String> {

  static Behavior<String> create() {
    return Behaviors.setup(MainApp::new);
  }

  private MainApp(ActorContext<String> context) {
    super(context);
  }

  @Override
  public Receive<String> createReceive() {
    return newReceiveBuilder()
      .onMessageEquals("start", this::onStart)
      .onMessageEquals("stop", this::onStop)
      .onSignal(PostStop.class, postStop -> {
        System.out.println("MainApp stopped");
        return this;
      })
      .build();
  }

  private Behavior<String> onStart() {
    for (int i = 0; i < 100; i++) {
      String name = UUID.randomUUID().toString();
      // ActorRef<Integer> actorA = getContext().spawn(ActorA.create(name), name); // 直接创建子代
      ActorRef<Integer> actorA = getContext().spawn(Behaviors.supervise(ActorA.create(name)).onFailure(SupervisorStrategy.restart()), name); // 创建并监督子代，当失败时（出现未捕获到的异常）立即重新启动
      actorA.tell(1);
    }
    return this;
  }

  private Behavior<String> onStop() {
    return Behaviors.stopped();
  }
}

/**
 * 创建一个Actor需要继承AbstractBehavior<T>
 */
class ActorA extends AbstractBehavior<Integer> {

  /**
   * 提供一个静态方法，用来创建该Actor
   *
   * @param msg 可以向该Actor的构造方法传递各种参数
   * @return 返回创建好的Actor
   */
  static Behavior<Integer> create(String msg) {
    return Behaviors.setup(actorContext -> new ActorA(actorContext, msg));
  }

  // Actor内部的成员变量
  private String msg;

  /**
   * 初始化该Actor
   * 这里可以私有化，对外只保留create方法
   *
   * @param context Actor上下文
   * @param msg     初始化成员变量
   */
  private ActorA(ActorContext<Integer> context, String msg) {
    super(context);
    this.msg = msg;
  }

  /**
   * 内部的一些执行逻辑
   */
  private void show() {
    System.out.println(this.getContext().getSelf() + "::" + this.msg);
  }

  /**
   * 定义收到消息时的处理行为
   *
   * @return
   */
  @Override
  public Receive<Integer> createReceive() {
    return newReceiveBuilder()
      .onAnyMessage(this::behaviorHandler) // handler: JFunction[T, Behavior[T]]  表示处理T类型的值，返回Behavior[T]
      .onSignal(PostStop.class, postStop -> this.beforeClose()) // handler: JFunction[M, Behavior[T]]  表示处理M类型的值，返回Behavior[T]
      .build();
  }

  /**
   * 可以针对不同的message，定义不同的处理handler
   *
   * @param i 传参
   * @return 返回一个Actor
   */
  private Behavior<Integer> behaviorHandler(Integer i) {
    while (i-- > 0) {
      this.show();
    }

    // return Behaviors.empty();
    // return this;

    // 停止Actor，建议用这种该方法
    return Behaviors.stopped();
  }

  private Behavior<Integer> beforeClose() {
    System.out.println("ActorA stopped");
    return this;
  }
}