import com.google.protobuf.ByteString;
import com.google.protobuf.InvalidProtocolBufferException;
import me.meteorcat.game.protobuf.EchoBytesCommand;
import me.meteorcat.game.protobuf.EchoStringCommand;

import java.nio.charset.StandardCharsets;
import java.util.Arrays;

/**
 * Pekko Protobuf 消息
 */
public class PekkoProtobufMessage {


    /**
     * 服务入口
     */
    public static void main(String[] args) {
        String message = "Hello.World"; // 文本
        byte[] messageBytes = message.getBytes(StandardCharsets.UTF_8); // 二进制

        // 打包成文本
        EchoStringCommand.Builder stringBuilder = EchoStringCommand.newBuilder();
        stringBuilder.setTick(100);
        stringBuilder.setData(message);

        // 文本构建成二进制数据传输
        EchoStringCommand stringCommand = stringBuilder.build();
        byte[] stringBytes = stringCommand.toByteArray();

        try {
            // 二进制转回结构体
            EchoStringCommand newStringCommand = EchoStringCommand.parseFrom(stringBytes);

            // 打印数据
            System.out.printf("文本消息信息: %s, 结构体: {%s}%n", Arrays.toString(stringBytes), newStringCommand);
        } catch (InvalidProtocolBufferException e) {
            // 解析错误拦截
            System.err.println(e.getMessage());
        }


        // 打包成二进制
        EchoBytesCommand.Builder bytesBuilder = EchoBytesCommand.newBuilder();
        bytesBuilder.setTick(101);
        bytesBuilder.setData(ByteString.copyFrom(messageBytes));

        // 二进制打包等待传输
        EchoBytesCommand bytesCommand = bytesBuilder.build();
        byte[] bytes = bytesCommand.toByteArray();

        try {
            // 二进制转回结构体
            EchoBytesCommand newBytesCommand = EchoBytesCommand.parseFrom(bytes);

            // 打印数据
            System.out.printf("二进制消息信息: %s, 结构体: {%s}%n", Arrays.toString(bytes), newBytesCommand);
        } catch (InvalidProtocolBufferException e) {
            // 解析错误拦截
            System.err.println(e.getMessage());
        }

    }
}

import me.meteorcat.game.protobuf.PlayerEntity;
import org.apache.pekko.actor.*;
import org.apache.pekko.event.Logging;
import org.apache.pekko.event.LoggingAdapter;
import scala.concurrent.ExecutionContextExecutor;

import java.io.IOException;
import java.time.Duration;
import java.util.Objects;

/**
 * Pekko Protobuf 示例
 */
public class PekkoProtobufExample {

    /**
     * 服务入口
     */
    public static void main(String[] args) throws IOException {

        // 构建 Actor 系统
        ActorSystem system = ActorSystem.create("pekko-protobuf");

        // 挂载 Actor 服务
        ActorRef actorRef = system.actorOf(PekkoPlayerManager.props(), "player-manager");

        // 这里采用任意输入回车中断监听, 如果未做任何键盘操作则是保持运行
        System.out.println("Press RETURN to stop...");
        int ignore = System.in.read();
        system.terminate();
    }


    /**
     * Pekko 玩家实体挂载
     */
    public static class PekkoPlayerManager extends AbstractActor {


        /**
         * 日志对象
         */
        final LoggingAdapter log = Logging.getLogger(getContext().getSystem(), this);


        /**
         * 调度器
         */
        final ExecutionContextExecutor dispatcher = getContext().getDispatcher();

        /**
         * 定时器
         */
        final Scheduler scheduler = getContext().getSystem().getScheduler();


        /**
         * 玩家实体
         */
        PlayerEntity entity;


        /**
         * 取消定时落地任务句柄
         */
        final Cancellable store;


        /**
         * 取消体力增长任务句柄
         */
        final Cancellable stamina;

        /**
         * 保存玩家实体的命令
         */
        private record StoreCommand() {

            private static StoreCommand self;

            public static StoreCommand getInstance() {
                if (Objects.isNull(self)) self = new StoreCommand();
                return self;
            }
        }

        /**
         * 体力值|疲劳值增长的命令
         */
        private record StaminaCommand() {
            private static StaminaCommand self;

            public static StaminaCommand getInstance() {
                if (Objects.isNull(self)) self = new StaminaCommand();
                return self;
            }
        }


        /**
         * 私有构建
         */
        private PekkoPlayerManager(PlayerEntity entity, Duration storeDuration, Duration staminaDuration) {
            this.entity = entity;
            this.store = scheduler.scheduleAtFixedRate(
                    storeDuration, // 初始延迟
                    storeDuration, // 间隔延迟
                    getSelf(), // 目标 Actor
                    StoreCommand.getInstance(), // 发送的消息
                    dispatcher,
                    ActorRef.noSender());

            this.stamina = scheduler.scheduleAtFixedRate(
                    staminaDuration, // 初始延迟
                    staminaDuration, // 间隔延迟
                    getSelf(), // 目标 Actor
                    StaminaCommand.getInstance(), // 发送的消息
                    dispatcher,
                    ActorRef.noSender());
        }

        /**
         * 静态构建
         */
        public static Props props() {

            // 一般是数据库加载的上来的, 这里直接写死模拟已经从数据加载
            PlayerEntity.Builder builder = PlayerEntity.newBuilder();
            builder.setUid(10001);
            builder.setSid(1);
            builder.setRid(100);
            builder.setNickname("MeteorCat");
            builder.setUptime(System.currentTimeMillis());


            // 构建的时候塞入玩家实体, 之后 Actor 读写就是基于内存上面 PlayerEntity 对象处理
            // 这里假设 30s 落地一次数据库实体, 每 10s 增加一点体力值|疲劳值
            return Props.create(PekkoPlayerManager.class, () -> new PekkoPlayerManager(
                    builder.build(),
                    Duration.ofSeconds(30),
                    Duration.ofSeconds(10)
            ));
        }


        /**
         * 初始化 Actor 回调
         */
        @Override
        public void preStart() {
            log.info("玩家挂载: {}", entity);

        }

        /**
         * 退出 Actor 回调
         */
        @Override
        public void postStop() {
            // 取消定时任务
            if (Objects.nonNull(store)) store.cancel();
            if (Objects.nonNull(stamina)) stamina.cancel();

            // 最后触发保存实体对象
            if (Objects.nonNull(entity)) storeEntity(StoreCommand.getInstance());

        }

        /**
         * Actor 状态机监控处理, 防止单条消息处理失败导致 Actor 崩溃
         */
        @Override
        public SupervisorStrategy supervisorStrategy() {
            return new OneForOneStrategy(
                    3,// 单条消息异常重试次数
                    Duration.ofSeconds(10), // 重试窗口时间
                    throwable -> {
                        log.warning(throwable, "玩家消息处理异常");
                        // 异常时重启 Actor, 内部的 entity 会保留
                        return SupervisorStrategy.restart();
                    }
            );
        }

        /**
         * 消息拦截
         */
        @Override
        public Receive createReceive() {
            return receiveBuilder()
                    .match(StoreCommand.class, this::storeEntity)
                    .match(StaminaCommand.class, this::staminaCommand)
                    .build();
        }

        /**
         * 增长体力值 +1
         */
        private void staminaCommand(StaminaCommand ignore) {
            // 这里加个限制, 超过100点直接不需要增长的, 一般策划才会配置
            if (this.entity.getStamina() >= 100) return;
            log.info("玩家体力增长");

            // 注意: Entity 实体只允许直接替换整个对象而不能修改其中某个值, 所以需要重新构建成 Builder
            PlayerEntity.Builder builder = entity.toBuilder();
            builder.setStamina(this.entity.getStamina() + 1); // 增长
            this.entity = builder.build();
        }


        /**
         * 触发保存玩家实体
         */
        private void storeEntity(StoreCommand ignore) {
            log.info("保存玩家角色实体成功");
            long now = System.currentTimeMillis();
            long offset = now - entity.getUptime(); // 登陆时间偏差值
            long online = offset + entity.getOnline(); // 最终的在线时间


            // 更新在线时间和更新时间
            // 注意: Entity 实体只允许直接替换整个对象而不能修改其中某个值, 所以需要重新构建成 Builder
            PlayerEntity.Builder builder = entity.toBuilder();
            builder.setUptime(now);
            builder.setOnline(online);

            // 其他修改

            // 最后重新构建成 entity
            this.entity = builder.build();
            log.info("保存实体成功: {}", this.entity);
        }
    }
}