package io.github.thatrobin.obscurum.client.renderer;

import io.github.thatrobin.obscurum.Obscurum;
import io.github.thatrobin.obscurum.block_entities.PlinthBlockEntity;
import net.minecraft.client.render.VertexConsumerProvider;
import net.minecraft.client.render.WorldRenderer;
import net.minecraft.client.render.block.entity.BlockEntityRenderer;
import net.minecraft.client.render.block.entity.BlockEntityRendererFactory;
import net.minecraft.client.render.item.ItemRenderer;
import net.minecraft.client.render.model.json.ModelTransformationMode;
import net.minecraft.client.util.math.MatrixStack;
import net.minecraft.item.ItemStack;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Vec3d;
import net.minecraft.util.math.RotationAxis;
import net.minecraft.world.World;

import java.util.Objects;

public class PlinthBlockEntityRenderer implements BlockEntityRenderer<PlinthBlockEntity> {

    private final ItemRenderer itemRenderer;

    public PlinthBlockEntityRenderer(BlockEntityRendererFactory.Context ctx) {
        this.itemRenderer = ctx.getItemRenderer();
    }

    @Override
    public void render(PlinthBlockEntity entity, float tickDelta, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay) {
        if (entity.hasItemInBuffer() || !entity.getTransferringItems().isEmpty()) {
            Vec3d outputPos = entity.getLinkedPos().toCenterPos().subtract(entity.getPos().toCenterPos());
            entity.markDirty();
            if (entity.getStack(0).isEmpty() && entity.getTransferringItems().isEmpty()) {
                return; // Skip rendering if no items
            }

            if (outputPos == null) {
                return;
            }
            double travelTime = entity.getTravelTime();

            // Render the items being transferred
            for (PlinthBlockEntity.ItemTransfer transfer : entity.getTransferringItems()) {
                renderMovingItem(transfer.item, transfer.progress, travelTime, outputPos, tickDelta, matrices, vertexConsumers, light, overlay, entity.getWorld());
            }

            // Render the item in the input buffer if present
            ItemStack bufferItem = entity.getStack(0);
            if (!bufferItem.isEmpty()) {
                renderItem(bufferItem, tickDelta, matrices, vertexConsumers, light, overlay, entity.getWorld());
            }
        }
    }

    private void renderMovingItem(ItemStack stack, int transferProgress, double travelTime, Vec3d outputPos, float tickDelta, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay, World world) {
        if (stack.isEmpty()) {
            return;
        }

        Vec3d offset = new Vec3d(outputPos.getX(), outputPos.getY(), outputPos.getZ());

        double progress = (transferProgress + tickDelta) / travelTime;
        Vec3d pos = PlinthBlockEntity.lerpBlockPos(Vec3d.ZERO, offset, progress);

        matrices.push();
        matrices.translate(pos.x + 0.5, pos.y + 0.85, pos.z + 0.5);
        matrices.multiply(RotationAxis.POSITIVE_Y.rotationDegrees((Objects.requireNonNull(world).getTime() + tickDelta) * 4));
        this.itemRenderer.renderItem(stack, ModelTransformationMode.GROUND, light, overlay, matrices, vertexConsumers, world, 0);
        matrices.pop();
    }

    private void renderItem(ItemStack stack, float tickDelta, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay, World world) {
        if (stack.isEmpty()) {
            return;
        }

        matrices.push();
        matrices.translate(0.5, 0.85, 0.5);
        matrices.multiply(RotationAxis.POSITIVE_Y.rotationDegrees((Objects.requireNonNull(world).getTime() + tickDelta) * 4));
        this.itemRenderer.renderItem(stack, ModelTransformationMode.GROUND, light, overlay, matrices, vertexConsumers, world, 0);
        matrices.pop();
    }

    @Override
    public boolean rendersOutsideBoundingBox(PlinthBlockEntity blockEntity) {
        return true; // Ensure rendering beyond the block's bounds
    }
}