package io.fortress.quarkus.protobuf;

import io.fortress.quarkus.protobuf.message.Game;
import org.apache.pekko.actor.*;
import org.apache.pekko.event.LoggingAdapter;

import java.time.Duration;
import java.util.*;

/**
 * 多人游戏场景, 优先遵循 Actor 模型原则, 所以内部是不需要锁对象和原子量处理
 *
 */
public class ProtobufFrameScene extends AbstractActor {


    /**
     * 对外的场景容器对象, 用于全局容器化
     */
    public static class ProtobufFrameSceneWrapper {

        final ActorRef actorRef;

        public ProtobufFrameSceneWrapper(ActorRef actorRef) {
            this.actorRef = actorRef;
        }
    }

    /**
     * 坐标地址
     *
     * @param x
     * @param y
     */
    public record Vec2(int x, int y) {
    }

    /**
     * 服务器的核心定时延迟
     */
    public enum Fps {
        Fps15(1000 / 15),
        FPS30(1000 / 30),
        FPS60(1000 / 60),
        ;

        /**
         * 毫秒
         */
        final int value;

        Fps(int value) {
            this.value = value;
        }
    }

    /**
     * 帧更新
     */
    public interface FixedUpdate {
    }

    /**
     * 日志对象
     */
    final LoggingAdapter log = context().system().log();

    /**
     * Actor 核心定时器
     */
    final Scheduler scheduler = context().system().scheduler();

    /**
     * 帧指令列表, 可以考虑采用更高性能的容器工具, 因为帧同步属于高频会做读写处理的功能
     */
    final Map<Integer, List<Game.InputFrame>> frames = new LinkedHashMap<>();

    /**
     * 加入场景的所有玩家, Key = 玩家唯一标识(可以考虑换成Long之类), Value = Actor 地址
     */
    final Map<String, ActorRef> actors = new LinkedHashMap<>();

    /**
     * 服务端定时器帧率
     */
    final Fps fps;


    /**
     * 帧率定时器
     */
    final Cancellable timer;


    /**
     * 当前的服务帧
     */
    int frame = 0;


    /**
     * 角色坐标列表快照
     */
    final Map<ActorRef, Vec2> positions = new HashMap<>();


    /**
     * 构造方法
     *
     * @param fps 帧率配置
     */
    public ProtobufFrameScene(Fps fps) {
        this.fps = fps;
        this.timer = scheduler.scheduleAtFixedRate(
                Duration.ofMillis(fps.value),
                Duration.ofMillis(fps.value),
                getSelf(),
                new FixedUpdate() {
                    //ignore
                },
                context().dispatcher(),
                ActorRef.noSender()
        );
    }


    /**
     * Actor 关闭回调
     */
    @Override
    public void postStop() {
        if (Objects.nonNull(this.timer)) this.timer.cancel();
    }

    /**
     * 事件绑定
     *
     * @return Receive
     */
    @Override
    public Receive createReceive() {
        return receiveBuilder()
                .match(Game.JoinScene.class, (e) -> !actors.containsKey(e.getSessionId()), (event) -> {
                    actors.put(event.getSessionId(), getSender());
                    positions.put(getSender(), new Vec2(1, 1));// 初始化坐标地址

                    // 广播玩家加入场景
                    actors.forEach((key, value) -> value.tell(event, getSelf()));
                })
                .match(Game.LeaveScene.class, (e) -> {
                    actors.remove(e.getSessionId());

                    // 广播玩家离开场景
                    actors.forEach((key, value) -> value.tell(e, getSelf()));
                })
                .match(Game.InitFrame.class, (e) -> {
                    ActorRef sender = getSender();
                    Vec2 vec2 = positions.get(sender);

                    // 打包返回的初始化事件
                    var message = Game
                            .InitFrame
                            .newBuilder()
                            .setFrame(frame)
                            .setX(Objects.isNull(vec2) ? 0 : vec2.x)
                            .setY(Objects.isNull(vec2) ? 0 : vec2.y)
                            .build();
                    getSender().tell(message, getSelf());
                })
                .match(Game.InputFrame.class, this::onInputFrame)
                .match(FixedUpdate.class, this::onFixedUpdate)
                .build();
    }

    /**
     * 帧更新方法
     */
    private void onFixedUpdate(FixedUpdate ignore) {
        long frameTime = System.currentTimeMillis(); // 记录毫秒帧时间戳

        // 收集本帧所有玩家的输入
        List<Game.InputFrame> inputs = frames.remove(frame);
        if (Objects.isNull(inputs)) {
            // 若没有输入，用空列表
            inputs = Collections.emptyList();
        }

        // 按照不同业务类型这里采用不同处理方式:
        // - 主流帧同步: 服务端不运行客户端业务逻辑, 仅负责输入转发和帧号管理, 依赖客户端逻辑的确定性保证状态一致
        // - 增强型帧同步: 服务端选择性运行核心逻辑(如防作弊校验、全局事件), 客户端仍运行完整逻辑, 通过双重计算确保安全性
        // 这里更新玩家的坐标信息, 这部分其实更需要抽离单独的同步方法调用, 因为实际上游戏逻辑并不仅仅要处理位置信息, 还有体积碰撞等
        for (Game.InputFrame input : inputs) {
            ActorRef actor = actors.get(input.getSessionId());
            if (Objects.nonNull(actor)) {

                // 更新角色坐标, 用来校正玩家是否到达地图最大尺寸
                Vec2 pos = positions.get(actor);
                Vec2 newPos = new Vec2(pos.x + input.getDirection(), pos.y);
                positions.put(actor, newPos);
            }
        }


        // 有参与的 Actor 才需要构建发送, 生成 Protobuf 广播给所有人
        if (!actors.isEmpty()) {
            var builder = Game
                    .Frames
                    .newBuilder()
                    .setFrame(frame)
                    .setTimestamp(frameTime);
            for (Game.InputFrame input : inputs) {
                builder.addFrames(input);
            }
            var message = builder.build();
            for (ActorRef actor : actors.values()) {
                actor.tell(message, getSelf());
            }
        }


        // 序列帧递增
        frame = frame + 1;

        // 值回滚成0
        if (frame == Integer.MAX_VALUE) frame = 0;
    }

    /**
     * 追加当前帧数行为
     *
     * @param f 玩家提交的帧
     */
    private void onInputFrame(Game.InputFrame f) {
        int value = f.getFrame(); // 获取客户端提交的序列帧
        if (value == frame || value == (frame + 1)) {
            // 需要判断游戏的逻辑是否成立
            var opt = onLogicUpdate(f);
            if (opt.isEmpty()) {
                log.warning("Validated logical update for frame " + f.getFrame());
            } else {
                // 允许当前帧或者下一帧的指令通过, 写入目前的等待定期发送的更新方法
                frames.computeIfAbsent(value, k -> new ArrayList<>()).add(f);
            }
        } else {
            log.warning("Invalid frame value: {}, session: {}", value, f.getSessionId());
        }
    }

    /**
     * 游戏输入逻辑判断
     *
     * @param f 玩家提交的帧
     * @return 逻辑返回的 Optional
     */
    private Optional<Game.InputFrame> onLogicUpdate(Game.InputFrame f) {

        // 移动方向是否合法(-1, 0, 1)
        var direction = f.getDirection();
        if (direction < -1 || direction > 1) {
            f.toBuilder().setDirection(0).build(); // 修正为静止
        }

        // 可能需要在这里判断是否允许到达地图最大位置

        return Optional.of(f);
    }

}