// SPDX-License-Identifier: BSD-2-Clause
// Copyright (c) 2025 Kirill Dmitrievich
// File: interpolation.cc
// Description: Interpolate components between server frames

#include "client/pch.hh"

#include "client/entity/interpolation.hh"

#include "core/math/constexpr.hh"

#include "shared/entity/head.hh"
#include "shared/entity/transform.hh"
#include "shared/entity/velocity.hh"

#include "shared/world/dimension.hh"

#include "shared/coord.hh"

#include "client/globals.hh"

static void transform_interpolate(float alpha)
{
    auto group = globals::dimension->entities.group<client::TransformIntr>(entt::get<Transform, client::TransformPrev>);

    for(auto [entity, interp, current, previous] : group.each()) {
        interp.angles[0] = glm::mix(previous.angles[0], current.angles[0], alpha);
        interp.angles[1] = glm::mix(previous.angles[1], current.angles[1], alpha);
        interp.angles[2] = glm::mix(previous.angles[2], current.angles[2], alpha);

        // Figure out previous chunk-local floating-point coordinates transformed
        // to the current WorldCoord's chunk domain coordinates; we're interpolating
        // against these instead of using previous.position.local to prevent jittering
        auto previous_shift = coord::to_relative(current.chunk, current.local, previous.chunk, previous.local);
        auto previous_local = current.local + previous_shift;

        interp.chunk.x = current.chunk.x;
        interp.chunk.y = current.chunk.y;
        interp.chunk.z = current.chunk.z;

        interp.local.x = glm::mix(previous_local.x, current.local.x, alpha);
        interp.local.y = glm::mix(previous_local.y, current.local.y, alpha);
        interp.local.z = glm::mix(previous_local.z, current.local.z, alpha);
    }
}

static void head_interpolate(float alpha)
{
    auto group = globals::dimension->entities.group<client::HeadIntr>(entt::get<Head, client::HeadPrev>);

    for(auto [entity, interp, current, previous] : group.each()) {
        interp.angles[0] = glm::mix(previous.angles[0], current.angles[0], alpha);
        interp.angles[1] = glm::mix(previous.angles[1], current.angles[1], alpha);
        interp.angles[2] = glm::mix(previous.angles[2], current.angles[2], alpha);

        interp.offset.x = glm::mix(previous.offset.x, current.offset.x, alpha);
        interp.offset.y = glm::mix(previous.offset.y, current.offset.y, alpha);
        interp.offset.z = glm::mix(previous.offset.z, current.offset.z, alpha);
    }
}

static void velocity_interpolate(float alpha)
{
    auto group = globals::dimension->entities.group<client::VelocityIntr>(entt::get<Velocity, client::VelocityPrev>);

    for(auto [entity, interp, current, previous] : group.each()) {
        interp.value[0] = glm::mix(previous.value[0], current.value[0], alpha);
        interp.value[1] = glm::mix(previous.value[1], current.value[1], alpha);
        interp.value[2] = glm::mix(previous.value[2], current.value[2], alpha);
    }
}

void interpolation::update(void)
{
    if(globals::dimension) {
        auto alpha = static_cast<float>(globals::fixed_accumulator) / static_cast<float>(globals::fixed_frametime_us);
        transform_interpolate(alpha);
        head_interpolate(alpha);
        velocity_interpolate(alpha);
    }
}