import { BatchedMesh, BufferGeometry, Color, Material, Matrix4, Mesh, MeshStandardMaterial, Object3D, RawShaderMaterial } from "three";

import { isDevEnvironment, showBalloonError } from "../engine/debug/index.js";
import { Gizmos } from "../engine/engine_gizmos.js";
import { $instancingAutoUpdateBounds, $instancingRenderer, NEED_UPDATE_INSTANCE_KEY } from "../engine/engine_instancing.js";
import { Context } from "../engine/engine_setup.js";
import { getParam, makeIdFromRandomWords } from "../engine/engine_utils.js";
import { NEEDLE_progressive } from "../engine/extensions/index.js";
import { GameObject } from "./Component.js";
import type { Renderer } from "./Renderer.js";

const debugInstancing = getParam("debuginstancing");

declare class InstancingSetupArgs {
    rend: Renderer;
    foundMeshes: number;
    useMatrixWorldAutoUpdate: boolean;
};

/**
 * Handles instancing for Needle Engine.
 */
export class InstancingHandler {
    static readonly instance: InstancingHandler = new InstancingHandler();

    /** This is the initial instance count when creating a new instancing structure.    
     * Override this and the number of max instances that you expect for a given object.
     * The larger the value the more objects can be added without having to resize but it will also consume more memory.    
     * (The instancing mesh renderer will grow x2 if the max instance count is reached)
     * @default 4
     * @returns The initial instance count
     * */
    static getStartInstanceCount = (_obj: Object3D) => {
        return 4;
    };

    public objs: InstancedMeshRenderer[] = [];

    public setup(renderer: Renderer, obj: Object3D, context: Context, handlesArray: InstanceHandle[] | null, args: InstancingSetupArgs, level: number = 0)
        : InstanceHandle[] | null {

        // make sure setting casting settings are applied so when we add the mesh to the InstancedMesh we can ask for the correct cast shadow setting
        renderer.applySettings(obj);
        const res = this.tryCreateOrAddInstance(obj, context, args);
        if (res) {
            if (handlesArray === null) handlesArray = [];
            handlesArray.push(res);
            // load texture lods
            NEEDLE_progressive.assignTextureLOD(res.renderer.material, 0);

            // Load mesh lods
            // TODO: technically for multi meshes we do this work multiple times (we search for meshes in children and then use the renderer sharedMeshes... that doesnt make sense)
            for (let i = 0; i < renderer.sharedMeshes.length; i++) {
                const mesh = renderer.sharedMeshes[i];
                const geometry = mesh.geometry;
                NEEDLE_progressive.assignMeshLOD(mesh, 0).then(lod => {
                    if (lod && renderer.activeAndEnabled && geometry != lod) {
                        res.setGeometry(lod);
                    }
                });
            }
        }

        else if (level <= 0 && obj.type !== "Mesh") {
            const nextLevel = level + 1;
            for (const ch of obj.children) {
                handlesArray = this.setup(renderer, ch, context, handlesArray, args, nextLevel);
            }
        }

        if (level === 0) {
            // For multi material objects we only want to track the root object's matrix
            if (args.useMatrixWorldAutoUpdate && handlesArray && handlesArray.length >= 0) {
                this.autoUpdateInstanceMatrix(obj);
            }
        }

        return handlesArray;
    }

    private tryCreateOrAddInstance(obj: Object3D, context: Context, args: InstancingSetupArgs): InstanceHandle | null {
        if (obj.type === "Mesh") {
            const index = args.foundMeshes;
            args.foundMeshes += 1;
            if (!args.rend.enableInstancing) return null;
            if (args.rend.enableInstancing === true) {
                // instancing is enabled globally
                // continue....
            }
            else {
                if (index >= args.rend.enableInstancing.length) {
                    if (debugInstancing) console.error("Something is wrong with instance setup", obj, args.rend.enableInstancing, index);
                    return null;
                }
                if (!args.rend.enableInstancing[index]) {
                    // instancing is disabled
                    // console.log("Instancing is disabled", obj);
                    return null;
                }
            }
            // instancing is enabled:
            const mesh = obj as Mesh;
            // const geo = mesh.geometry as BufferGeometry;
            const mat = mesh.material as Material;

            for (const i of this.objs) {
                if (!i.canAdd(mesh.geometry, mat)) continue;
                const handle = i.addInstance(mesh);
                return handle;
            }
            let maxInstances = InstancingHandler.getStartInstanceCount(obj);
            if (!maxInstances || maxInstances < 0) {
                maxInstances = 4;
            }
            let name = obj.name;
            if (!name?.length) name = makeIdFromRandomWords();
            const i = new InstancedMeshRenderer(name, mesh.geometry, mat, maxInstances, context);
            this.objs.push(i);
            const handle = i.addInstance(mesh);
            return handle;
        }
        return null;
    }

    private autoUpdateInstanceMatrix(obj: Object3D) {
        const original = obj.matrixWorld["multiplyMatrices"].bind(obj.matrixWorld);
        const previousMatrix: Matrix4 = obj.matrixWorld.clone();
        const matrixChangeWrapper = (a: Matrix4, b: Matrix4) => {
            const newMatrixWorld = original(a, b);
            if (obj[NEED_UPDATE_INSTANCE_KEY] || previousMatrix.equals(newMatrixWorld) === false) {
                previousMatrix.copy(newMatrixWorld)
                obj[NEED_UPDATE_INSTANCE_KEY] = true;
            }
            return newMatrixWorld;
        };
        obj.matrixWorld["multiplyMatrices"] = matrixChangeWrapper;
        // wrap matrixWorldNeedsUpdate
        // let originalMatrixWorldNeedsUpdate = obj.matrixWorldNeedsUpdate;
        // Object.defineProperty(obj, "matrixWorldNeedsUpdate", {
        //     get: () => {
        //         return originalMatrixWorldNeedsUpdate;
        //     },
        //     set: (value: boolean) => {
        //         if(value) console.warn("SET MATRIX WORLD NEEDS UPDATE");
        //         originalMatrixWorldNeedsUpdate = value;
        //     }
        // });
    }
}

/**
 * The instance handle is used to interface with the mesh that is rendered using instancing.
 */
export class InstanceHandle {

    static readonly all: InstanceHandle[] = [];

    /** The name of the object */
    get name(): string {
        return this.object.name;
    }
    get isActive() {
        return this.__instanceIndex >= 0;
    }
    get vertexCount() {
        return this.object.geometry.attributes.position.count;
    }
    get maxVertexCount() {
        // we get the max of the estimated MAX lod vertex count and the actual vertex count
        return Math.max(this.meshInformation.vertexCount, this.vertexCount);
    }
    get reservedVertexCount() {
        return this.__reservedVertexRange;
    }
    get indexCount() {
        return this.object.geometry.index ? this.object.geometry.index.count : 0;
    }
    get maxIndexCount() {
        // we get the max of the estimated MAX lod index count and the actual index count
        return Math.max(this.meshInformation.indexCount, this.indexCount);
    }
    get reservedIndexCount() {
        return this.__reservedIndexRange;
    }

    /** The object that is being instanced */
    readonly object: Mesh;

    /** The instancer/BatchedMesh that is rendering this object*/
    readonly renderer: InstancedMeshRenderer;

    /** @internal */
    __instanceIndex: number = -1;
    /** @internal */
    __reservedVertexRange: number = 0;
    /** @internal */
    __reservedIndexRange: number = 0;
    __geometryIndex: number = -1;

    /** The mesh information of the object - this tries to also calculate the LOD info */
    readonly meshInformation: MeshInformation;

    constructor(originalObject: Mesh, instancer: InstancedMeshRenderer) {
        this.__instanceIndex = -1;
        this.object = originalObject;
        this.renderer = instancer;
        originalObject[$instancingRenderer] = instancer;
        // TODO: this doesn't have LOD information *yet* in some cases - hence we can not rely on it for the max vertex counts
        this.meshInformation = getMeshInformation(originalObject.geometry);
        InstanceHandle.all.push(this);
    }

    /** Calculates the mesh information again
     * @returns true if the vertex count or index count has changed
     */
    updateMeshInformation(): boolean {
        const newMeshInformation = getMeshInformation(this.object.geometry);
        const oldVertexCount = this.meshInformation.vertexCount;
        const oldIndexCount = this.meshInformation.indexCount;
        Object.assign(this.meshInformation, newMeshInformation);
        return oldVertexCount !== this.meshInformation.vertexCount || oldIndexCount !== this.meshInformation.indexCount;
    }

    /** Updates the matrix from the rendered object. Will also call updateWorldMatrix internally */
    updateInstanceMatrix(updateChildren: boolean = false, updateMatrix: boolean = true) {
        if (this.__instanceIndex < 0) return;
        if (updateMatrix) this.object.updateWorldMatrix(true, updateChildren);
        this.renderer.updateInstance(this.object.matrixWorld, this.__instanceIndex);
    }
    /** Updates the matrix of the instance */
    setMatrix(matrix: Matrix4) {
        if (this.__instanceIndex < 0) return;
        this.renderer.updateInstance(matrix, this.__instanceIndex);
    }

    /** Can be used to change the geometry of this instance */
    setGeometry(geo: BufferGeometry) {
        if (this.__geometryIndex < 0) return false;

        const self = this;

        if (this.vertexCount > this.__reservedVertexRange) {
            return handleInvalidRange(`Instancing: Can not update geometry (${this.name}), reserved vertex range is too small: ${this.__reservedVertexRange.toLocaleString()} < ${this.vertexCount.toLocaleString()} vertices for ${this.name}`);

        }
        if (this.indexCount > this.__reservedIndexRange) {
            return handleInvalidRange(`Instancing: Can not update geometry (${this.name}), reserved index range is too small: ${this.__reservedIndexRange.toLocaleString()} < ${this.indexCount.toLocaleString()} indices for ${this.name}`);
        }


        return this.renderer.updateGeometry(geo, this.__geometryIndex);

        function handleInvalidRange(error: string): boolean {
            if (self.updateMeshInformation()) {
                // Gizmos.DrawWireSphere(self.object.worldPosition, .5, 0xff0000, 5);
                self.renderer.remove(self, true);
                // Gizmos.DrawWireSphere(self.object.worldPosition, .5, 0x33ff00, 5);
                // self.object.scale.multiplyScalar(10);
                if (self.renderer.add(self)) {
                    return true;
                }
            }
            if (isDevEnvironment() || debugInstancing) {
                console.error(error);
            }
            return false;
        }
    }

    /** Adds this object to the instancing renderer (effectively activating instancing) */
    add() {
        if (this.__instanceIndex >= 0) return;
        this.renderer.add(this);
        GameObject.markAsInstancedRendered(this.object, true);
    }

    /** Removes this object from the instancing renderer 
     * @param delete_ If true, the instance handle will be removed from the global list
    */
    remove(delete_: boolean) {
        if (this.__instanceIndex < 0) return;
        this.renderer.remove(this, delete_);
        GameObject.markAsInstancedRendered(this.object, false);
        if (delete_) {
            const i = InstanceHandle.all.indexOf(this);
            if (i >= 0) {
                InstanceHandle.all.splice(i, 1);
            }
        }
    }
}

class InstancedMeshRenderer {
    /** The three instanced mesh
     * @link https://threejs.org/docs/#api/en/objects/InstancedMesh
     */
    get batchedMesh() {
        return this._batchedMesh;
    }
    get visible(): boolean {
        return this._batchedMesh.visible;
    }
    set visible(val: boolean) {
        this._batchedMesh.visible = val;
    }
    get castShadow(): boolean {
        return this._batchedMesh.castShadow;
    }
    set castShadow(val: boolean) {
        this._batchedMesh.castShadow = val;
    }
    set receiveShadow(val: boolean) {
        this._batchedMesh.receiveShadow = val;
    }

    /** If true, the instancer is allowed to grow when the max instance count is reached */
    allowResize: boolean = true;

    /** The name of the instancer */
    name: string = "";

    /** The added geometry */
    readonly geometry: BufferGeometry;

    /** The material used for the instanced mesh */
    readonly material: Material;

    /** The current number of instances */
    get count(): number { return this._currentInstanceCount; }

    /** Update the bounding box and sphere of the instanced mesh 
     * @param box If true, update the bounding box
     * @param sphere If true, update the bounding sphere
    */
    updateBounds(box: boolean = true, sphere: boolean = true) {
        this._needUpdateBounds = false;
        if (box)
            this._batchedMesh.computeBoundingBox();
        if (sphere)
            this._batchedMesh.computeBoundingSphere();
        if (debugInstancing && this._batchedMesh.boundingSphere) {
            const sphere = this._batchedMesh.boundingSphere;
            // const worldPos = this._batchedMesh.worldPosition.add(sphere.center);
            // const worldRadius = sphere!.radius;
            Gizmos.DrawWireSphere(sphere.center, sphere.radius, 0x00ff00);
        }
    }

    private _context: Context;
    private _batchedMesh: BatchedMesh;
    private _handles: (InstanceHandle | null)[] = [];
    private readonly _geometryIds: Map<BufferGeometry, number> = new Map();
    private _maxInstanceCount: number;

    private _currentInstanceCount = 0;
    private _currentVertexCount = 0;
    private _currentIndexCount = 0;

    private _maxVertexCount: number;
    private _maxIndexCount: number;

    private static nullMatrix: Matrix4 = new Matrix4();

    /** Check if the geometry can be added to this instancer
     * @param geometry The geometry to check
     * @param material The material of the geometry
     * @returns true if the geometry can be added
     */
    canAdd(geometry: BufferGeometry, material: Material): boolean {

        if (this._maxVertexCount > 10_000_000) return false;

        // The material instance must match
        // perhaps at some point later we *could* check if it's the same shader and properties but this would be risky
        if (material !== this.material) {
            const canMergeMaterial = false;
            // if (material.type === this.material.type) {
            //     switch (material.type) {
            //         case "MeshStandardMaterial":
            //             // check if the material properties are the same
            //             const m0 = this.material as MeshStandardMaterial;
            //             const m1 = material as MeshStandardMaterial;
            //             if(m0.map !== m1.map) return false;
            //             // if(m0.color.equals(m1.color) === false) return false;
            //             if(m0.roughness !== m1.roughness) return false;
            //             if(m0.metalness !== m1.metalness) return false;
            //             if(m0.envMap !== m1.envMap) return false;
            //             if(m0.envMapIntensity !== m1.envMapIntensity) return false;
            //             if(m0.lightMap !== m1.lightMap) return false;
            //             if(m0.lightMapIntensity !== m1.lightMapIntensity) return false;
            //             if(m0.aoMap !== m1.aoMap) return false;
            //             if(m0.aoMapIntensity !== m1.aoMapIntensity) return false;
            //             if(m0.emissive.equals(m1.emissive) === false) return false;
            //             if(m0.emissiveIntensity !== m1.emissiveIntensity) return false;
            //             if(m0.emissiveMap !== m1.emissiveMap) return false;
            //             if(m0.bumpMap !== m1.bumpMap) return false;
            //             if(m0.bumpScale !== m1.bumpScale) return false;
            //             if(m0.normalMap !== m1.normalMap) return false;
            //             if(m0.normalScale.equals(m1.normalScale) === false) return false;
            //             if(m0.displacementMap !== m1.displacementMap) return false;
            //             if(m0.displacementScale !== m1.displacementScale) return false;
            //             if(m0.displacementBias !== m1.displacementBias) return false;
            //             if(m0.roughnessMap !== m1.roughnessMap) return false;
            //             if(m0.metalnessMap !== m1.metalnessMap) return false;
            //             if(m0.alphaMap !== m1.alphaMap) return false;
            //             if(m0.envMapIntensity !== m1.envMapIntensity) return false;
            //             canMergeMaterial = true;
            //             break;
            //     }
            // }
            if (!canMergeMaterial) {
                return false;
            }
        }

        // if(this.geometry !== _geometry) return false;

        // console.log(geometry.name, geometry.uuid);

        if (!this.validateGeometry(geometry)) return false;

        // const validationMethod = this.inst["_validateGeometry"];
        // if (!validationMethod) throw new Error("InstancedMesh does not have a _validateGeometry method");
        // try {
        //     validationMethod.call(this.inst, _geometry);
        // }
        // catch (err) {
        //     // console.error(err);
        //     return false;
        // }

        const hasSpace = !this.mustGrow(geometry);
        if (hasSpace) return true;
        if (this.allowResize) return true;

        return false;
    }

    private _needUpdateBounds: boolean = false;
    private _debugMaterial: MeshStandardMaterial | null = null;

    constructor(name: string, geo: BufferGeometry, material: Material, initialMaxCount: number, context: Context) {
        this.name = name;
        this.geometry = geo;
        this.material = material;
        this._context = context;
        this._maxInstanceCount = Math.max(2, initialMaxCount);
        if (debugInstancing) {
            this._debugMaterial = createDebugMaterial();
        }
        const estimate = this.tryEstimateVertexCountSize(this._maxInstanceCount, [geo], initialMaxCount);
        this._maxVertexCount = estimate.vertexCount;
        this._maxIndexCount = estimate.indexCount;
        this._batchedMesh = new BatchedMesh(this._maxInstanceCount, this._maxVertexCount, this._maxIndexCount, this._debugMaterial ?? this.material);
        // this.inst = new InstancedMesh(geo, material, count);
        this._batchedMesh[$instancingAutoUpdateBounds] = true;
        // this.inst.count = 0;
        this._batchedMesh.visible = true;
        this._context.scene.add(this._batchedMesh);

        // Not handled by RawShaderMaterial, so we need to set the define explicitly.
        // Edge case: theoretically some users of the material could use it in an
        // instanced fashion, and some others not. In that case, the material would not
        // be able to be shared between the two use cases. We could probably add a
        // onBeforeRender call for the InstancedMesh and set the define there.
        // Same would apply if we support skinning - 
        // there we would have to split instanced batches so that the ones using skinning
        // are all in the same batch.
        if (material instanceof RawShaderMaterial) {
            material.defines["USE_INSTANCING"] = true;
            material.needsUpdate = true;
        }

        context.pre_render_callbacks.push(this.onBeforeRender);
        context.post_render_callbacks.push(this.onAfterRender);

        if (debugInstancing) {
            console.log(`Instanced renderer created with ${this._maxInstanceCount} instances, ${this._maxVertexCount} max vertices and ${this._maxIndexCount} max indices for \"${name}\"`)
        }
    }

    dispose() {
        if (debugInstancing) console.warn("Dispose instanced renderer", this.name);
        this._context.scene.remove(this._batchedMesh);
        this._batchedMesh.dispose();
        this._batchedMesh = null as any;
        this._handles = [];
    }

    addInstance(obj: Mesh): InstanceHandle | null {

        const handle = new InstanceHandle(obj, this);

        if (obj.castShadow === true && this._batchedMesh.castShadow === false) {
            this._batchedMesh.castShadow = true;
        }
        if (obj.receiveShadow === true && this._batchedMesh.receiveShadow === false) {
            this._batchedMesh.receiveShadow = true;
        }

        try {
            this.add(handle);
        }
        catch (e) {
            console.error(`Failed adding mesh to instancing (object name: \"${obj.name}\", instances: ${this._currentInstanceCount.toLocaleString()}/${this._maxInstanceCount.toLocaleString()}, vertices: ${this._currentVertexCount.toLocaleString()}/${this._maxVertexCount.toLocaleString()}, indices: ${this._currentIndexCount.toLocaleString()}/${this._maxIndexCount.toLocaleString()})\n`, e);
            if (isDevEnvironment()) {
                showBalloonError("Failed instancing mesh. See the browser console for details.");
                debugger;
            }
            return null;
        }

        return handle;
    }


    add(handle: InstanceHandle) {
        const geo = handle.object.geometry as BufferGeometry;

        if (!geo || !geo.attributes) {
            console.error("Cannot add object to instancing without geometry", handle.name);
            return false;
        }

        if (this.mustGrow(geo)) {
            if (this.allowResize) {
                this.grow(geo);
            }
            else {
                console.error("Cannot add instance, max count reached", this.name, this.count, this._maxInstanceCount);
                return false;
            }
        }

        handle.object.updateWorldMatrix(true, true);
        this.addGeometry(handle);
        this._handles[handle.__instanceIndex] = handle;
        this._currentInstanceCount += 1;

        this.markNeedsUpdate();

        if (this._currentInstanceCount > 0)
            this._batchedMesh.visible = true;

        return true;
    }

    remove(handle: InstanceHandle, delete_: boolean) {
        if (!handle) {
            return;
        }
        if (handle.__instanceIndex < 0 || this._handles[handle.__instanceIndex] != handle || this._currentInstanceCount <= 0) {
            // console.warn("Cannot remove instance, handle is invalid", handle.name);
            return;
        }

        this.removeGeometry(handle, delete_);
        this._handles[handle.__instanceIndex] = null;
        handle.__instanceIndex = -1;

        if (this._currentInstanceCount > 0) {
            this._currentInstanceCount -= 1;
        }

        if (this._currentInstanceCount <= 0)
            this._batchedMesh.visible = false;

        this.markNeedsUpdate();
    }

    updateInstance(mat: Matrix4, index: number) {
        this._batchedMesh.setMatrixAt(index, mat);
        this.markNeedsUpdate();
    }

    updateGeometry(geo: BufferGeometry, geometryIndex: number): boolean {
        if (!this.validateGeometry(geo)) {
            return false;
        }

        if (this.mustGrow()) {
            this.grow(geo);
        }
        if (debugInstancing)
            console.debug("[Instancing] UPDATE GEOMETRY at " + geometryIndex, this._batchedMesh["_geometryCount"], geo.name, getMeshInformation(geo), geo.attributes.position.count, geo.index ? geo.index.count : 0);

        this._batchedMesh.setGeometryAt(geometryIndex, geo);
        // for LOD mesh updates we need to make sure to save the geometry index
        this._geometryIds.set(geo, geometryIndex);
        this.markNeedsUpdate();
        return true;
    }

    private onBeforeRender = () => {
        // ensure the instanced mesh is rendered / has correct layers
        this._batchedMesh.layers.enableAll();

        if (this._needUpdateBounds && this._batchedMesh[$instancingAutoUpdateBounds] === true) {
            if (debugInstancing === "verbose") console.log("Update instancing bounds", this.name, this._batchedMesh.matrixWorldNeedsUpdate);
            this.updateBounds();
        }
    }

    private onAfterRender = () => {
        // hide the instanced mesh again when its not being rendered (for raycasting we still use the original object)
        this._batchedMesh.layers.disableAll();
    }

    private validateGeometry(geometry: BufferGeometry): boolean {
        const batchGeometry = this.geometry;

        for (const attributeName in batchGeometry.attributes) {
            if (attributeName === "batchId") {
                continue;
            }
            if (!geometry.hasAttribute(attributeName)) {
                if (isDevEnvironment())
                    console.warn(`BatchedMesh: Added geometry missing "${attributeName}". All geometries must have consistent attributes.`);
                // geometry.setAttribute(attributeName, batchGeometry.getAttribute(attributeName).clone());
                return false;
                // throw new Error(`BatchedMesh: Added geometry missing "${attributeName}". All geometries must have consistent attributes.`);
            }
            // const srcAttribute = geometry.getAttribute(attributeName);
            // const dstAttribute = batchGeometry.getAttribute(attributeName);
            // if (srcAttribute.itemSize !== dstAttribute.itemSize || srcAttribute.normalized !== dstAttribute.normalized) {
            //     if (debugInstancing) throw new Error('BatchedMesh: All attributes must have a consistent itemSize and normalized value.');
            //     return false;
            // }
        }
        return true;
    }

    private markNeedsUpdate() {
        if (debugInstancing === "verbose") {
            console.warn("Marking instanced mesh dirty", this.name);
        }
        this._needUpdateBounds = true;
        // this.inst.instanceMatrix.needsUpdate = true;
    }

    /**
     * @param geo The geometry to add (if none is provided it means the geometry is already added and just updated)
     */
    private mustGrow(geo?: BufferGeometry): boolean {
        if (this.count >= this._maxInstanceCount) return true;
        if (!geo || !geo.attributes) return false;
        const meshInfo = getMeshInformation(geo);
        const newVertexCount = meshInfo.vertexCount;
        const newIndexCount = meshInfo.indexCount;
        return this._currentVertexCount + newVertexCount > this._maxVertexCount || this._currentIndexCount + newIndexCount > this._maxIndexCount;
    }

    private grow(geometry: BufferGeometry) {
        const growFactor = 2;
        const newSize = Math.ceil(this._maxInstanceCount * growFactor);

        // create a new BatchedMesh instance
        const estimatedSpace = this.tryEstimateVertexCountSize(newSize, [geometry]);// geometry.attributes.position.count;
        // const indices = geometry.index ? geometry.index.count : 0;
        const newMaxVertexCount = Math.max(this._maxVertexCount, estimatedSpace.vertexCount);
        const newMaxIndexCount = Math.max(this._maxIndexCount, estimatedSpace.indexCount, Math.ceil(this._maxVertexCount * growFactor));

        if (debugInstancing) {
            const geometryInfo = getMeshInformation(geometry);
            console.warn(`[Instancing] Growing Buffer\nMesh: \"${this.name}${geometry.name?.length ? "/" + geometry.name : ""}\"\n${geometryInfo.vertexCount} vertices, ${geometryInfo.indexCount} indices\nMax count ${this._maxInstanceCount} → ${newSize}\nMax vertex count ${this._maxVertexCount} -> ${newMaxVertexCount}\nMax index count ${this._maxIndexCount} -> ${newMaxIndexCount}`);
            this._debugMaterial = createDebugMaterial();
        }
        else if (isDevEnvironment()) {
            console.debug(`[Instancing] Growing Buffer\nMesh: \"${this.name}${geometry.name?.length ? "/" + geometry.name : ""}\"\nMax count ${this._maxInstanceCount} → ${newSize}\nMax vertex count ${this._maxVertexCount} -> ${newMaxVertexCount}\nMax index count ${this._maxIndexCount} -> ${newMaxIndexCount}`);
        }

        this._maxVertexCount = newMaxVertexCount;
        this._maxIndexCount = newMaxIndexCount;
        const newInst = new BatchedMesh(newSize, this._maxVertexCount, this._maxIndexCount, this._debugMaterial ?? this.material);
        newInst.layers = this._batchedMesh.layers;
        newInst.castShadow = this._batchedMesh.castShadow;
        newInst.receiveShadow = this._batchedMesh.receiveShadow;
        newInst.visible = this._batchedMesh.visible;
        newInst[$instancingAutoUpdateBounds] = this._batchedMesh[$instancingAutoUpdateBounds];
        newInst.matrixAutoUpdate = this._batchedMesh.matrixAutoUpdate;
        newInst.matrixWorldNeedsUpdate = this._batchedMesh.matrixWorldNeedsUpdate;
        newInst.matrixAutoUpdate = this._batchedMesh.matrixAutoUpdate;
        newInst.matrixWorld.copy(this._batchedMesh.matrixWorld);
        newInst.matrix.copy(this._batchedMesh.matrix);

        // dispose the old batched mesh
        this._batchedMesh.dispose();
        this._batchedMesh.removeFromParent();
        this._geometryIds.clear();

        this._batchedMesh = newInst;
        this._maxInstanceCount = newSize;

        // since we have a new batched mesh we need to re-add all the instances
        // fixes https://linear.app/needle/issue/NE-5711

        // add current instances to new instanced mesh
        const original = [...this._handles];
        this._handles = [];
        for (const handle of original) {
            if (handle && handle.__instanceIndex >= 0) {
                this.addGeometry(handle);
                this._handles[handle.__instanceIndex] = handle;
            }
        }

        this._context.scene.add(newInst);
    }

    private tryEstimateVertexCountSize(newMaxInstances: number, _newGeometries?: BufferGeometry[], newGeometriesFactor: number = 1): MeshInformation {
        /** Used geometries and how many instances use them  */
        const usedGeometries = new Map<BufferGeometry, MeshInformation & { count: number }>();
        for (const handle of this._handles) {
            if (handle && handle.__instanceIndex >= 0 && handle.object.geometry) {
                if (!usedGeometries.has(handle.object.geometry as BufferGeometry)) {
                    const data = getMeshInformation(handle.object.geometry as BufferGeometry);
                    const meshinfo = { count: 1, ...data };
                    usedGeometries.set(handle.object.geometry as BufferGeometry, meshinfo);
                }
                else {
                    const entry = usedGeometries.get(handle.object.geometry as BufferGeometry)!;
                    entry.count += 1;
                }

            }
        }

        // then calculate the total vertex count
        let totalVertices = 0;
        let totalIndices = 0;
        // let maxVertices = 0;
        for (const [_geo, data] of usedGeometries) {
            totalVertices += data.vertexCount * data.count;
            totalIndices += data.indexCount * data.count;
            // maxVertices = Math.max(maxVertices, geo.attributes.position.count * count);
        }
        // we calculate the average to make an educated guess of how many vertices will be needed with the new buffer count
        const averageVerts = Math.ceil(totalVertices / Math.max(1, this._currentInstanceCount));
        let maxVertexCount = averageVerts * newMaxInstances;
        const averageIndices = Math.ceil(totalIndices / Math.max(1, this._currentInstanceCount));
        let maxIndexCount = averageIndices * newMaxInstances * 2;

        // if new geometries are provided we *know* that they will be added
        // so we make sure to include them in the calculation
        if (_newGeometries) {
            for (const geo of _newGeometries) {
                const meshinfo = getMeshInformation(geo);
                if (meshinfo != null) {
                    maxVertexCount += meshinfo.vertexCount * newGeometriesFactor;
                    maxIndexCount += meshinfo.indexCount * newGeometriesFactor;
                }

            }
        }

        return { vertexCount: maxVertexCount, indexCount: maxIndexCount };
    }


    private addGeometry(handle: InstanceHandle) {

        const obj = handle.object;
        const geo = obj.geometry as BufferGeometry;
        if (!geo) {
            // if the geometry is null we cannot add it
            return;
        }

        // otherwise add more geometry / instances
        let geometryId = this._geometryIds.get(geo);
        if (geometryId === undefined || geometryId === null) {
            if (debugInstancing)
                console.debug(`[Instancing] > ADD NEW GEOMETRY \"${handle.name} (${geo.name}; ${geo.uuid})\"\n${this._currentInstanceCount} instances, ${handle.maxVertexCount} max vertices, ${handle.maxIndexCount} max indices`);

            geometryId = this._batchedMesh.addGeometry(geo, handle.maxVertexCount, handle.maxIndexCount);
            this._geometryIds.set(geo, geometryId);
        }
        else {
            if (debugInstancing === "verbose") console.log(`[Instancing] > ADD INSTANCE \"${handle.name}\"\nGEOMETRY_ID=${geometryId}\n${this._currentInstanceCount} instances`);
        }
        this._currentVertexCount += handle.maxVertexCount;
        this._currentIndexCount += handle.maxIndexCount;
        const i = this._batchedMesh.addInstance(geometryId);
        handle.__geometryIndex = geometryId;
        handle.__instanceIndex = i;
        handle.__reservedVertexRange = handle.maxVertexCount;
        handle.__reservedIndexRange = handle.maxIndexCount;
        this._batchedMesh.setMatrixAt(i, handle.object.matrixWorld);
        if (debugInstancing)
            console.debug(`[Instancing] > ADDED INSTANCE \"${handle.name}\"\nGEOMETRY_ID=${geometryId}\n${this._currentInstanceCount} instances\nIndex: ${handle.__instanceIndex}`);

    }


    private removeGeometry(handle: InstanceHandle, _del: boolean) {
        if (handle.__instanceIndex < 0) {
            console.warn("Cannot remove geometry, instance index is invalid", handle.name);
            return;
        }
        // deleteGeometry is currently not useable since there's no optimize method
        // https://github.com/mrdoob/three.js/issues/27985
        // if (del)
        //     this.inst.deleteGeometry(handle.__instanceIndex);
        // else 
        // this._batchedMesh.setVisibleAt(handle.__instanceIndex, false);
        if(debugInstancing) {
            console.debug(`[Instancing] < REMOVE INSTANCE \"${handle.name}\" at [${handle.__instanceIndex}]\nGEOMETRY_ID=${handle.__geometryIndex}\n${this._currentInstanceCount} instances\nIndex: ${handle.__instanceIndex}`);
        }
        this._batchedMesh.deleteInstance(handle.__instanceIndex);
    }
}

declare type BucketInfo = {
    geometryIndex: number;
    vertexCount: number;
    indexCount: number;
}

declare type MeshInformation = {
    vertexCount: number;
    indexCount: number;
}

function getMeshInformation(geo: BufferGeometry): MeshInformation {
    if (!geo) {
        if (isDevEnvironment()) console.error("Cannot get mesh information from null geometry");
        return { vertexCount: 0, indexCount: 0 };
    }
    let vertexCount = geo.attributes?.position?.count || 0;
    let indexCount = geo.index ? geo.index.count : 0;
    const lodInfo = NEEDLE_progressive.getMeshLODInformation(geo);
    if (lodInfo) {
        const lod0 = lodInfo.lods[0];
        let lod0Count = lod0.vertexCount;
        let lod0IndexCount = lod0.indexCount;
        // add some wiggle room: https://linear.app/needle/issue/NE-4505
        const extra = Math.min(200, Math.ceil(lod0Count * .05));
        lod0Count += extra;
        lod0IndexCount += 20;
        vertexCount = Math.max(vertexCount, lod0Count);
        indexCount = Math.max(indexCount, lod0IndexCount);
    }
    vertexCount = Math.ceil(vertexCount);
    indexCount = Math.ceil(indexCount);
    return { vertexCount, indexCount };
}

function createDebugMaterial() {
    const mat = new MeshStandardMaterial({ color: new Color(Math.random(), Math.random(), Math.random()) });
    mat.emissive = mat.color;
    mat.emissiveIntensity = .3;
    if (getParam("wireframe"))
        mat.wireframe = true;
    return mat;
}