MeshPrimitive

import { runMechanicContract } from '@babylonjsmarket/ecs/testing';
import {
  MeshPrimitiveComponent,
  MeshPrimitiveSystem,
  MeshPrimitiveEvents,
  MeshPrimitiveInputEvents,
} from './MeshPrimitive';

runMechanicContract({
  name: 'MeshPrimitive',
  componentClass: MeshPrimitiveComponent,
  systemClass: MeshPrimitiveSystem,
  sampleInput: { primitive: 'box', width: 2 },
  events: {
    input: [
      MeshPrimitiveInputEvents.SET_POSITION,
      MeshPrimitiveInputEvents.SET_COLOR,
      MeshPrimitiveInputEvents.SET_VISIBLE,
      MeshPrimitiveInputEvents.DISPOSE,
    ],
    output: [MeshPrimitiveEvents.CREATED],
  },
  makeInputPayload(event) {
    switch (event) {
      case MeshPrimitiveInputEvents.SET_POSITION:
        return { entityId: 'target', x: 1, y: 2, z: 3 };
      case MeshPrimitiveInputEvents.SET_COLOR:
        return { entityId: 'target', r: 1, g: 0, b: 0 };
      case MeshPrimitiveInputEvents.SET_VISIBLE:
        return { entityId: 'target', visible: false };
      case MeshPrimitiveInputEvents.DISPOSE:
        return { entityId: 'target' };
      default:
        return { entityId: 'target' };
    }
  },
});

// @vitest-environment jsdom
import { describe, it, expect, vi } from 'vitest';
import { render, fireEvent } from '@solidjs/testing-library';
import { MeshPrimitivePanel, type MeshPrimitiveParams } from './MeshPrimitive.panel';

function makeParams(): MeshPrimitiveParams {
  return { scaleX: 1, scaleY: 1, scaleZ: 1, visibility: 1 };
}

describe('MeshPrimitivePanel', () => {
  it('mounts and shows Scale X', () => {
    const { container } = render(() => (
      <MeshPrimitivePanel params={makeParams()} setParam={vi.fn()} onReset={vi.fn()} />
    ));
    expect(container.textContent).toContain('Scale X');
  });

  it('moving Scale X fires setParam with scaleX key', () => {
    const setParam = vi.fn();
    const { getAllByRole } = render(() => (
      <MeshPrimitivePanel params={makeParams()} setParam={setParam} onReset={vi.fn()} />
    ));
    fireEvent.input(
      (getAllByRole('slider') as HTMLInputElement[])[0],
      { target: { value: '2.5' } },
    );
    expect(setParam).toHaveBeenCalledWith('scaleX', 2.5);
  });

  it('moving Scale Y / Scale Z / Visibility fires setParam with the matching key', () => {
    const setParam = vi.fn();
    const { getAllByRole } = render(() => (
      <MeshPrimitivePanel params={makeParams()} setParam={setParam} onReset={vi.fn()} />
    ));
    const sliders = getAllByRole('slider') as HTMLInputElement[];
    // sliders: [scaleX, scaleY, scaleZ, visibility]
    fireEvent.input(sliders[1], { target: { value: '2' } });
    expect(setParam).toHaveBeenCalledWith('scaleY', 2);
    fireEvent.input(sliders[2], { target: { value: '3' } });
    expect(setParam).toHaveBeenCalledWith('scaleZ', 3);
    fireEvent.input(sliders[3], { target: { value: '0.5' } });
    expect(setParam).toHaveBeenCalledWith('visibility', 0.5);
  });

  it('Reset fires onReset', () => {
    const onReset = vi.fn();
    const { getByText } = render(() => (
      <MeshPrimitivePanel params={makeParams()} setParam={vi.fn()} onReset={onReset} />
    ));
    fireEvent.click(getByText(/reset/i));
    expect(onReset).toHaveBeenCalled();
  });
});

import { describe, it, expect, beforeEach, vi } from 'vitest';
import {
  MeshPrimitiveComponent,
  MeshPrimitiveSystem,
  MeshPrimitiveEvents,
  MeshPrimitiveInputEvents,
  type PrimitiveType,
} from './MeshPrimitive';
import { EventBus, World } from '@babylonjsmarket/ecs';
import { MockRendererAdapter } from '@babylonjsmarket/ecs';

describe('MeshPrimitiveComponent (core)', () => {
  it('defaults to box primitive with unit dimensions', () => {
    const c = new MeshPrimitiveComponent();
    expect(c.primitive).toBe('box');
    expect(c.width).toBe(1);
    expect(c.height).toBe(1);
    expect(c.depth).toBe(1);
    expect(c.autoCreate).toBe(true);
    expect(c.visible).toBe(true);
    expect(c.isCreated).toBe(false);
    expect(c.handle).toBeUndefined();
  });

  it('position defaults to [0,0,0] as a tuple', () => {
    const c = new MeshPrimitiveComponent();
    expect(c.position).toEqual([0, 0, 0]);
    expect(Array.isArray(c.position)).toBe(true);
  });

  it('accepts position as a tuple', () => {
    const c = new MeshPrimitiveComponent({ position: [1, 2, 3] });
    expect(c.position).toEqual([1, 2, 3]);
  });

  it('accepts position as a Vector3-like object (legacy callers)', () => {
    const c = new MeshPrimitiveComponent({ position: { x: 4, y: 5, z: 6 } });
    expect(c.position).toEqual([4, 5, 6]);
  });

  it('falls back to the default when an object lacks numeric x/y/z', () => {
    // Non-array, non-Vector3-like object → toVec3 final fallback branch.
    const c = new MeshPrimitiveComponent({
      position: { x: 'nope' } as unknown as { x: number; y: number; z: number },
    });
    expect(c.position).toEqual([0, 0, 0]);
  });

  it('falls back to the default for a wrong-length array', () => {
    const c = new MeshPrimitiveComponent({
      rotation: [1, 2] as unknown as [number, number, number],
    });
    expect(c.rotation).toEqual([0, 0, 0]);
  });

  it('handle setter writes through to the runtime slot read by the getter', () => {
    const c = new MeshPrimitiveComponent();
    expect(c.handle).toBeUndefined();
    const fake = { __id: 'mesh-1' } as never;
    c.handle = fake;
    expect(c.handle).toBe(fake);
    c.handle = undefined;
    expect(c.handle).toBeUndefined();
  });

  it('accepts color shorthand, mapping to material.diffuse', () => {
    const c = new MeshPrimitiveComponent({ color: [1, 0, 0] });
    expect(c.material?.diffuse).toEqual([1, 0, 0]);
  });

  it('accepts full material config using legacy key names', () => {
    const c = new MeshPrimitiveComponent({
      material: {
        diffuseColor: [1, 0, 0],
        specularColor: [0, 1, 0],
        emissiveColor: [0, 0, 1],
        alpha: 0.5,
      },
    });
    expect(c.material?.diffuse).toEqual([1, 0, 0]);
    expect(c.material?.specular).toEqual([0, 1, 0]);
    expect(c.material?.emissive).toEqual([0, 0, 1]);
    expect(c.material?.alpha).toBe(0.5);
  });

  it('toPrimitiveSpec returns a spec matching the component state', () => {
    const c = new MeshPrimitiveComponent({
      primitive: 'sphere',
      diameter: 2,
      segments: 48,
    });
    const spec = c.toPrimitiveSpec();
    expect(spec.kind).toBe('sphere');
    expect(spec.diameter).toBe(2);
    expect(spec.segments).toBe(48);
  });

  it('accepts every primitive type', () => {
    const types: PrimitiveType[] = [
      'box', 'sphere', 'cylinder', 'capsule', 'plane', 'ground', 'torus', 'disc',
    ];
    for (const kind of types) {
      const c = new MeshPrimitiveComponent({ primitive: kind });
      expect(c.primitive).toBe(kind);
    }
  });

  it('serialize round-trips through the constructor', () => {
    const original = new MeshPrimitiveComponent({
      primitive: 'cylinder',
      position: [1, 2, 3],
      rotation: [0.1, 0.2, 0.3],
      height: 3,
      diameterTop: 1,
      diameterBottom: 2,
      tessellation: 48,
      color: [0.5, 0.5, 0.5],
      visible: false,
    });
    const copy = new MeshPrimitiveComponent(original.serialize());
    expect(copy.primitive).toBe('cylinder');
    expect(copy.position).toEqual([1, 2, 3]);
    expect(copy.rotation).toEqual([0.1, 0.2, 0.3]);
    expect(copy.height).toBe(3);
    expect(copy.diameterTop).toBe(1);
    expect(copy.tessellation).toBe(48);
    expect(copy.material?.diffuse).toEqual([0.5, 0.5, 0.5]);
    expect(copy.visible).toBe(false);
  });
});

describe('MeshPrimitive event name constants', () => {
  it('output event names', () => {
    expect(MeshPrimitiveEvents.CREATED).toBe('meshprimitive.created');
    expect(MeshPrimitiveEvents.MATERIAL_APPLIED).toBe('meshprimitive.material.applied');
    expect(MeshPrimitiveEvents.DISPOSED).toBe('meshprimitive.disposed');
  });

  it('input event names', () => {
    expect(MeshPrimitiveInputEvents.CREATE).toBe('meshprimitive.create');
    expect(MeshPrimitiveInputEvents.SET_POSITION).toBe('meshprimitive.position.set');
    expect(MeshPrimitiveInputEvents.SET_SCALE).toBe('meshprimitive.scale.set');
    expect(MeshPrimitiveInputEvents.SET_COLOR).toBe('meshprimitive.color.set');
    expect(MeshPrimitiveInputEvents.SET_VISIBLE).toBe('meshprimitive.visible.set');
    expect(MeshPrimitiveInputEvents.DISPOSE).toBe('meshprimitive.dispose');
  });
});

describe('MeshPrimitiveSystem — adapter integration', () => {
  let eventBus: EventBus;
  let world: World;
  let renderer: MockRendererAdapter;
  let system: MeshPrimitiveSystem;

  beforeEach(() => {
    eventBus = new EventBus();
    renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer });
    system = new MeshPrimitiveSystem(eventBus);
    world.addSystem(system);
    world.initialize();
  });

  it('query requires MeshPrimitiveComponent', () => {
    expect((system as unknown as { query: unknown }).query).toEqual({
      required: [MeshPrimitiveComponent],
    });
  });

  it('auto-creates a mesh on entity add, storing handle and marking created', () => {
    const entity = world.createEntity();
    const comp = new MeshPrimitiveComponent({ primitive: 'sphere', diameter: 2 });
    entity.add(comp);
    expect(comp.isCreated).toBe(true);
    expect(comp.handle).toBeDefined();
    const createCall = renderer.calls.find((c) => c.method === 'createMesh');
    expect(createCall).toBeDefined();
    expect((createCall?.args[1] as { kind: string }).kind).toBe('sphere');
  });

  it('does not create when autoCreate is false', () => {
    const entity = world.createEntity();
    const comp = new MeshPrimitiveComponent({ autoCreate: false });
    entity.add(comp);
    expect(comp.isCreated).toBe(false);
    expect(renderer.calls.find((c) => c.method === 'createMesh')).toBeUndefined();
  });

  it('emits CREATED event with entityId, primitive, and handle', () => {
    const spy = vi.fn();
    eventBus.on(MeshPrimitiveEvents.CREATED, spy);
    const entity = world.createEntity();
    entity.add(new MeshPrimitiveComponent({ primitive: 'box' }));
    expect(spy).toHaveBeenCalledWith(
      expect.objectContaining({
        entityId: entity.id,
        primitive: 'box',
        handle: expect.anything(),
      }),
    );
  });

  it('emits MATERIAL_APPLIED when a material is provided', () => {
    const spy = vi.fn();
    eventBus.on(MeshPrimitiveEvents.MATERIAL_APPLIED, spy);
    const entity = world.createEntity();
    entity.add(new MeshPrimitiveComponent({ color: [1, 0, 0] }));
    expect(spy).toHaveBeenCalledWith({ entityId: entity.id });
  });

  it('applies initial position through the adapter', () => {
    const entity = world.createEntity();
    entity.add(new MeshPrimitiveComponent({ position: [5, 10, 15] }));
    const posCall = renderer.calls.find((c) => c.method === 'setMeshPosition');
    expect(posCall).toBeDefined();
    expect(posCall?.args.slice(1)).toEqual([5, 10, 15]);
  });

  it('applies initial rotation through the adapter', () => {
    const entity = world.createEntity();
    entity.add(new MeshPrimitiveComponent({ rotation: [0.1, 0.2, 0.3] }));
    const rotCall = renderer.calls.find((c) => c.method === 'setMeshRotation');
    expect(rotCall).toBeDefined();
    expect(rotCall?.args.slice(1)).toEqual([0.1, 0.2, 0.3]);
  });

  it('applies initial visibility through the adapter', () => {
    const entity = world.createEntity();
    entity.add(new MeshPrimitiveComponent({ visible: false }));
    const visCall = renderer.calls.find((c) => c.method === 'setMeshVisible');
    expect(visCall?.args[1]).toBe(false);
  });

  it('SET_POSITION event updates the component and forwards to the adapter', () => {
    const entity = world.createEntity();
    const comp = new MeshPrimitiveComponent();
    entity.add(comp);
    renderer.calls.length = 0;
    eventBus.emit(MeshPrimitiveInputEvents.SET_POSITION, {
      entityId: entity.id,
      x: 20,
      y: 30,
      z: 40,
    });
    expect(comp.position).toEqual([20, 30, 40]);
    const posCall = renderer.calls.find((c) => c.method === 'setMeshPosition');
    expect(posCall?.args.slice(1)).toEqual([20, 30, 40]);
  });

  it('SET_COLOR event updates material.diffuse and forwards to the adapter', () => {
    const entity = world.createEntity();
    const comp = new MeshPrimitiveComponent({ color: [1, 1, 1] });
    entity.add(comp);
    renderer.calls.length = 0;
    eventBus.emit(MeshPrimitiveInputEvents.SET_COLOR, {
      entityId: entity.id,
      r: 1,
      g: 0,
      b: 0,
    });
    expect(comp.material?.diffuse).toEqual([1, 0, 0]);
    const colorCall = renderer.calls.find((c) => c.method === 'setMeshColor');
    expect(colorCall?.args.slice(1)).toEqual([1, 0, 0]);
  });

  it('SET_VISIBLE event forwards to the adapter', () => {
    const entity = world.createEntity();
    const comp = new MeshPrimitiveComponent();
    entity.add(comp);
    renderer.calls.length = 0;
    eventBus.emit(MeshPrimitiveInputEvents.SET_VISIBLE, {
      entityId: entity.id,
      visible: false,
    });
    expect(comp.visible).toBe(false);
    const visCall = renderer.calls.find((c) => c.method === 'setMeshVisible');
    expect(visCall?.args[1]).toBe(false);
  });

  it('CREATE event re-creates the mesh with updated params', () => {
    const entity = world.createEntity();
    const comp = new MeshPrimitiveComponent({ primitive: 'box', autoCreate: false });
    entity.add(comp);
    renderer.calls.length = 0;
    eventBus.emit(MeshPrimitiveInputEvents.CREATE, {
      entityId: entity.id,
      primitive: 'sphere',
      diameter: 10,
      color: [1, 0, 0],
    });
    expect(comp.primitive).toBe('sphere');
    expect(comp.diameter).toBe(10);
    expect(comp.material?.diffuse).toEqual([1, 0, 0]);
    expect(renderer.calls.find((c) => c.method === 'createMesh')).toBeDefined();
  });

  it('CREATE event disposes the prior mesh before re-creating', () => {
    const entity = world.createEntity();
    // autoCreate: true → first mesh exists, handle is set.
    const comp = new MeshPrimitiveComponent({ primitive: 'box' });
    entity.add(comp);
    const firstHandle = comp.handle;
    expect(firstHandle).toBeDefined();
    renderer.calls.length = 0;
    eventBus.emit(MeshPrimitiveInputEvents.CREATE, {
      entityId: entity.id,
      primitive: 'sphere',
      width: 2,
      height: 3,
      depth: 4,
    });
    // The existing handle is disposed before the new createMesh.
    const disposeIdx = renderer.calls.findIndex((c) => c.method === 'disposeMesh');
    const createIdx = renderer.calls.findIndex((c) => c.method === 'createMesh');
    expect(disposeIdx).toBeGreaterThanOrEqual(0);
    expect(createIdx).toBeGreaterThan(disposeIdx);
    expect(comp.primitive).toBe('sphere');
    expect(comp.width).toBe(2);
    expect(comp.height).toBe(3);
    expect(comp.depth).toBe(4);
  });

  it('SET_SCALE event is accepted as a no-op (scale not in adapter yet)', () => {
    const entity = world.createEntity();
    const comp = new MeshPrimitiveComponent();
    entity.add(comp);
    renderer.calls.length = 0;
    expect(() => {
      eventBus.emit(MeshPrimitiveInputEvents.SET_SCALE, {
        entityId: entity.id,
        x: 2,
        y: 2,
        z: 2,
      });
    }).not.toThrow();
    // No adapter scale method exists, so nothing is forwarded.
    expect(renderer.calls).toHaveLength(0);
  });

  it('defers creation when no renderer is attached', () => {
    const entity = world.createEntity();
    // Drop the renderer so createPrimitive hits its early return.
    (world as unknown as { renderer?: unknown }).renderer = undefined;
    const comp = new MeshPrimitiveComponent({ primitive: 'box' });
    entity.add(comp);
    expect(comp.isCreated).toBe(false);
    expect(comp.handle).toBeUndefined();
  });

  it('exposes the raw mesh via getMeshObject on a babylon-kind adapter', () => {
    const rawMesh = { name: 'raw-babylon-mesh' };
    const babylonish = renderer as unknown as {
      kind: string;
      getMeshObject?: (h: unknown) => unknown;
    };
    babylonish.kind = 'babylon';
    babylonish.getMeshObject = () => rawMesh;
    const spy = vi.fn();
    eventBus.on(MeshPrimitiveEvents.CREATED, spy);
    const entity = world.createEntity();
    entity.add(new MeshPrimitiveComponent({ primitive: 'box' }));
    expect(spy).toHaveBeenCalledWith(
      expect.objectContaining({ entityId: entity.id, mesh: rawMesh }),
    );
  });

  it('DISPOSE event asks the adapter to dispose the mesh', () => {
    const entity = world.createEntity();
    const comp = new MeshPrimitiveComponent();
    entity.add(comp);
    const disposedSpy = vi.fn();
    eventBus.on(MeshPrimitiveEvents.DISPOSED, disposedSpy);
    renderer.calls.length = 0;
    eventBus.emit(MeshPrimitiveInputEvents.DISPOSE, { entityId: entity.id });
    expect(renderer.calls.some((c) => c.method === 'disposeMesh')).toBe(true);
    expect(comp.handle).toBeUndefined();
    expect(comp.isCreated).toBe(false);
    expect(disposedSpy).toHaveBeenCalledWith({ entityId: entity.id });
  });

  it('entity removal disposes the underlying mesh', () => {
    const entity = world.createEntity();
    entity.add(new MeshPrimitiveComponent());
    renderer.calls.length = 0;
    world.removeEntity(entity);
    expect(renderer.calls.some((c) => c.method === 'disposeMesh')).toBe(true);
  });

  it('ignores events for unknown entity IDs without throwing', () => {
    expect(() => {
      eventBus.emit(MeshPrimitiveInputEvents.SET_POSITION, {
        entityId: 'ghost',
        x: 1,
        y: 2,
        z: 3,
      });
    }).not.toThrow();
  });

  it('onUpdate is a no-op', () => {
    expect(() => world.update(16)).not.toThrow();
  });

  it('creates pending primitives for entities that existed before system initialization', () => {
    const eb = new EventBus();
    const r = new MockRendererAdapter();
    const w = new World({ eventBus: eb, renderer: r });
    const entity = w.createEntity();
    const comp = new MeshPrimitiveComponent({ autoCreate: true });
    entity.add(comp);
    // No system yet — no handle
    expect(comp.handle).toBeUndefined();
    const s = new MeshPrimitiveSystem(eb);
    w.addSystem(s);
    w.initialize();
    expect(comp.handle).toBeDefined();
    expect(comp.isCreated).toBe(true);
  });

  it('onInitialize creates meshes for entities backfilled while no renderer was attached', () => {
    const eb = new EventBus();
    const r = new MockRendererAdapter();
    const w = new World({ eventBus: eb, renderer: r });
    // Drop the renderer so the backfill (addSystem → addEntity → onEntityAdded)
    // defers creation, leaving comp.autoCreate && !isCreated at initialize time.
    (w as unknown as { renderer?: unknown }).renderer = undefined;
    const entity = w.createEntity();
    const comp = new MeshPrimitiveComponent({ autoCreate: true });
    entity.add(comp);
    const s = new MeshPrimitiveSystem(eb);
    w.addSystem(s); // world not initialized yet → onEntityAdded runs but defers (no renderer)
    expect(comp.isCreated).toBe(false);
    // Re-attach the renderer, then initialize → onInitialize loop creates it.
    (w as unknown as { renderer?: unknown }).renderer = r;
    w.initialize();
    expect(comp.isCreated).toBe(true);
    expect(comp.handle).toBeDefined();
    expect(r.calls.some((c) => c.method === 'createMesh')).toBe(true);
  });
});

describe('MeshPrimitiveSystem — park-aware (pooling)', () => {
  let eventBus: EventBus;
  let renderer: MockRendererAdapter;
  let world: World;

  beforeEach(() => {
    eventBus = new EventBus();
    renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer, detectRaces: false });
    world.addSystem(new MeshPrimitiveSystem(eventBus));
    world.initialize();
  });

  it('deactivating keeps the mesh (hide, no dispose) and reactivating reuses it', () => {
    const e = world.createEntity();
    const comp = new MeshPrimitiveComponent({ primitive: 'sphere', position: [1, 1, 1] });
    e.add(comp);
    const handle = comp.handle;
    expect(handle).toBeDefined();
    const created = renderer.calls.filter((c) => c.method === 'createMesh').length;

    // Park: removed from play.
    e.active = false;
    expect(comp.handle).toBe(handle); // kept, not disposed
    expect(renderer.calls.some((c) => c.method === 'disposeMesh')).toBe(false);

    // The hide is queued like the restore. A spawner that sweeps a pooled
    // entity and immediately reuses it does both in ONE frame, and writing
    // each as it happens puts two systems on one handle — the race. Recording
    // the net and writing once from our own update resolves it.
    expect(
      renderer.calls.some((c) => c.method === 'setMeshVisible' && c.args[1] === false),
    ).toBe(false);
    world.update(1 / 60);
    expect(
      renderer.calls.some((c) => c.method === 'setMeshVisible' && c.args[1] === false),
    ).toBe(true);

    // Unpark: reused, not recreated.
    comp.position = [7, 0, 7];
    e.active = true;
    expect(comp.handle).toBe(handle);
    expect(renderer.calls.filter((c) => c.method === 'createMesh').length).toBe(created);

    // The pose restore is QUEUED, not written from the reactivation hook —
    // that hook runs inside whichever system triggered the acquire, and writing
    // there both misattributes the call and can collide with the owning
    // system's own write in the same frame. It flushes from our own update.
    expect(
      renderer.calls.some(
        (c) => c.method === 'setMeshPosition' && c.args[1] === 7 && c.args[3] === 7,
      ),
    ).toBe(false);

    world.update(1 / 60);
    expect(
      renderer.calls.some(
        (c) => c.method === 'setMeshPosition' && c.args[1] === 7 && c.args[3] === 7,
      ),
    ).toBe(true);
    expect(
      renderer.calls.some((c) => c.method === 'setMeshVisible' && c.args[1] === true),
    ).toBe(true);
  });

  it('truly removing (destroy) disposes the mesh', () => {
    const e = world.createEntity();
    e.add(new MeshPrimitiveComponent({ primitive: 'box' }));
    renderer.calls.length = 0;
    world.removeEntity(e); // not pooled → destroy
    expect(renderer.calls.some((c) => c.method === 'disposeMesh')).toBe(true);
  });
});

// @vitest-environment jsdom
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { render } from '@solidjs/testing-library';
import { EventBus, World, MockRendererAdapter } from '@babylonjsmarket/ecs';
import {
  MeshPrimitiveDebuggerComponent,
  MeshPrimitiveDebuggerInput,
  MeshPrimitiveDebuggerEvents,
  MeshPrimitiveDebuggerSystem,
} from './MeshPrimitive.viz.tsx';
import { MeshPrimitiveComponent, MeshPrimitiveSystem } from './MeshPrimitive';
import { vizStore } from '../_shared/viz';

const PANEL_ID = 'mesh-primitive-debugger';
const STORAGE_PREFIX = 'mesh-primitive-debugger-params';

describe('MeshPrimitiveDebuggerComponent', () => {
  let component: MeshPrimitiveDebuggerComponent;

  beforeEach(() => {
    component = new MeshPrimitiveDebuggerComponent({
      visible: true,
      activationKey: 'Digit8',
      position: 'top-right',
    });
  });

  describe('constructor', () => {
    it('should initialize with provided values', () => {
      expect(component.visible).toBe(true);
      expect(component.activationKey).toBe('Digit8');
      expect(component.position).toBe('top-right');
    });

    it('should use defaults when no data provided', () => {
      const defaultComponent = new MeshPrimitiveDebuggerComponent();
      expect(defaultComponent.visible).toBe(false);
      expect(defaultComponent.activationKey).toBe('');
      expect(defaultComponent.position).toBe('top-left');
    });

    it('should initialize with partial data', () => {
      const partialComponent = new MeshPrimitiveDebuggerComponent({
        visible: true,
      });
      expect(partialComponent.visible).toBe(true);
      expect(partialComponent.activationKey).toBe('');
      expect(partialComponent.position).toBe('top-left');
    });
  });

  describe('visibility', () => {
    it('should start hidden by default', () => {
      const comp = new MeshPrimitiveDebuggerComponent();
      expect(comp.visible).toBe(false);
    });

    it('should allow toggling visibility', () => {
      component.visible = false;
      expect(component.visible).toBe(false);
      component.visible = true;
      expect(component.visible).toBe(true);
    });

    it('should respect visible flag from constructor', () => {
      const visibleComp = new MeshPrimitiveDebuggerComponent({ visible: true });
      expect(visibleComp.visible).toBe(true);

      const hiddenComp = new MeshPrimitiveDebuggerComponent({ visible: false });
      expect(hiddenComp.visible).toBe(false);
    });
  });

  describe('activation key', () => {
    it('should accept valid keyboard codes', () => {
      const comp = new MeshPrimitiveDebuggerComponent({ activationKey: 'KeyP' });
      expect(comp.activationKey).toBe('KeyP');
    });

    it('should accept function keys', () => {
      const comp = new MeshPrimitiveDebuggerComponent({ activationKey: 'F9' });
      expect(comp.activationKey).toBe('F9');
    });

    it('should accept digit keys', () => {
      const comp = new MeshPrimitiveDebuggerComponent({ activationKey: 'Digit9' });
      expect(comp.activationKey).toBe('Digit9');
    });

    it("should default to '' (auto-assigned by the viz layer)", () => {
      const comp = new MeshPrimitiveDebuggerComponent();
      expect(comp.activationKey).toBe('');
    });

    it('should allow changing activation key', () => {
      component.activationKey = 'F10';
      expect(component.activationKey).toBe('F10');
    });
  });

  describe('position', () => {
    it('should accept top-left', () => {
      const comp = new MeshPrimitiveDebuggerComponent({ position: 'top-left' });
      expect(comp.position).toBe('top-left');
    });

    it('should accept top-right', () => {
      const comp = new MeshPrimitiveDebuggerComponent({ position: 'top-right' });
      expect(comp.position).toBe('top-right');
    });

    it('should accept bottom-left', () => {
      const comp = new MeshPrimitiveDebuggerComponent({ position: 'bottom-left' });
      expect(comp.position).toBe('bottom-left');
    });

    it('should accept bottom-right', () => {
      const comp = new MeshPrimitiveDebuggerComponent({ position: 'bottom-right' });
      expect(comp.position).toBe('bottom-right');
    });

    it('should default to top-left', () => {
      const comp = new MeshPrimitiveDebuggerComponent();
      expect(comp.position).toBe('top-left');
    });

    it('should allow changing position', () => {
      component.position = 'bottom-left';
      expect(component.position).toBe('bottom-left');
    });
  });

  describe('serialization', () => {
    it('should serialize to object', () => {
      const serialized = component.serialize();
      expect(serialized.visible).toBe(true);
      expect(serialized.activationKey).toBe('Digit8');
      expect(serialized.position).toBe('top-right');
    });

    it('should be reconstructable from serialized data', () => {
      const serialized = component.serialize();
      const reconstructed = new MeshPrimitiveDebuggerComponent(serialized);
      expect(reconstructed.visible).toBe(component.visible);
      expect(reconstructed.activationKey).toBe(component.activationKey);
      expect(reconstructed.position).toBe(component.position);
    });

    it('should serialize default values correctly', () => {
      const defaultComp = new MeshPrimitiveDebuggerComponent();
      const serialized = defaultComp.serialize();
      expect(serialized.visible).toBe(false);
      expect(serialized.activationKey).toBe('');
      expect(serialized.position).toBe('top-left');
    });

    it('should only include serializable properties', () => {
      const serialized = component.serialize();
      expect(serialized).toHaveProperty('visible');
      expect(serialized).toHaveProperty('activationKey');
      expect(serialized).toHaveProperty('position');
      expect(Object.keys(serialized).length).toBe(3);
    });
  });

  describe('state management', () => {
    it('should allow visibility to be modified', () => {
      expect(component.visible).toBe(true);
      component.visible = false;
      expect(component.visible).toBe(false);
    });

    it('should allow activationKey to be modified', () => {
      expect(component.activationKey).toBe('Digit8');
      component.activationKey = 'Digit7';
      expect(component.activationKey).toBe('Digit7');
    });

    it('should allow position to be modified', () => {
      expect(component.position).toBe('top-right');
      component.position = 'bottom-left';
      expect(component.position).toBe('bottom-left');
    });
  });
});

describe('MeshPrimitiveDebuggerEvents', () => {
  it('should define SHOWN event', () => {
    expect(MeshPrimitiveDebuggerEvents.SHOWN).toBe('meshprimitivedebugger.shown');
  });

  it('should define HIDDEN event', () => {
    expect(MeshPrimitiveDebuggerEvents.HIDDEN).toBe('meshprimitivedebugger.hidden');
  });
});

describe('MeshPrimitiveDebuggerSystem params', () => {
  // Note: Full system testing requires BabylonJS Scene context
  // These tests verify the param structure

  it('should have expected default param structure', () => {
    // These are the params that MeshPrimitiveDebuggerSystem exposes
    const expectedParams = {
      scaleX: 1,
      scaleY: 1,
      scaleZ: 1,
      visibility: 1,
    };

    // Verify structure
    expect(Object.keys(expectedParams)).toHaveLength(4);
    expect(expectedParams.scaleX).toBe(1);
    expect(expectedParams.scaleY).toBe(1);
    expect(expectedParams.scaleZ).toBe(1);
    expect(expectedParams.visibility).toBe(1);
  });
});

describe('MeshPrimitiveDebuggerSystem — viz integration', () => {
  let eventBus: EventBus;
  let world: World;
  let renderer: MockRendererAdapter;
  let system: MeshPrimitiveDebuggerSystem;

  beforeEach(() => {
    eventBus = new EventBus();
    renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer });
    system = new MeshPrimitiveDebuggerSystem(eventBus);
    world.addSystem(system);
    // The MeshPrimitiveSystem gives MeshPrimitiveComponents a live renderer
    // handle — without it the debugger's onUpdate loop has nothing to toggle.
    world.addSystem(new MeshPrimitiveSystem(eventBus));
  });

  afterEach(() => {
    // The system manages a shared vizStore singleton + persists to
    // localStorage. Shut the world down so any per-system state is torn
    // down (mirrors the cross-test-leak fix), then wipe shared state.
    world.shutdown();
    vizStore.clear();
    localStorage.clear();
  });

  /** Add an entity carrying the debugger component; returns both. */
  function addDebugger(input?: MeshPrimitiveDebuggerInput) {
    const entity = world.createEntity();
    const comp = new MeshPrimitiveDebuggerComponent(input);
    entity.add(comp);
    return { entity, comp };
  }

  describe('panel registration on initialize', () => {
    it('does not register a panel when no debugger entity exists', () => {
      world.initialize();
      expect(vizStore.panels[PANEL_ID]).toBeUndefined();
    });

    it('registers a panel when a debugger entity is present at initialize', () => {
      addDebugger({ activationKey: 'Digit8', position: 'top-right' });
      world.initialize();

      const panel = vizStore.panels[PANEL_ID];
      expect(panel).toBeDefined();
      expect(panel.title).toBe('Mesh Primitive Controls');
      expect(panel.position).toBe('top-right');
      expect(panel.titleColor).toBe('#9f4aff');
    });

    it('honours the component visible flag when registering', () => {
      addDebugger({ visible: true });
      world.initialize();
      expect(vizStore.isVisible(PANEL_ID)).toBe(true);
    });

    it('registers hidden by default', () => {
      addDebugger();
      world.initialize();
      expect(vizStore.isVisible(PANEL_ID)).toBe(false);
    });
  });

  describe('onEntityAdded', () => {
    it('registers the panel when the debugger entity is added after initialize', () => {
      world.initialize();
      expect(vizStore.panels[PANEL_ID]).toBeUndefined();

      addDebugger({ position: 'bottom-left' });
      const panel = vizStore.panels[PANEL_ID];
      expect(panel).toBeDefined();
      expect(panel.position).toBe('bottom-left');
    });

    it('ignores a second debugger entity once one is bound', () => {
      world.initialize();
      const { comp: first } = addDebugger({ position: 'top-left' });
      // Second add should not re-register / re-bind.
      addDebugger({ position: 'bottom-right' });

      // Panel still reflects the first component's position.
      expect(vizStore.panels[PANEL_ID].position).toBe('top-left');
      // And the bound component is the first one.
      expect((system as unknown as { component: unknown }).component).toBe(first);
    });
  });

  describe('onUpdate — visibility sync', () => {
    it('mirrors panel visibility back onto the component', () => {
      const { comp } = addDebugger({ visible: false });
      world.initialize();

      vizStore.showPanel(PANEL_ID);
      world.update(16);
      expect(comp.visible).toBe(true);

      vizStore.hidePanel(PANEL_ID);
      world.update(16);
      expect(comp.visible).toBe(false);
    });

    it('does nothing on update when no debugger component is bound', () => {
      world.initialize();
      expect(() => world.update(16)).not.toThrow();
    });
  });

  describe('onUpdate — applying params to mesh primitives', () => {
    it('sets mesh visibility on every primitive while the panel is visible', () => {
      addDebugger({ visible: true });
      world.initialize();

      const entity = world.createEntity();
      const prim = new MeshPrimitiveComponent({ primitive: 'box' });
      entity.add(prim);
      expect(prim.handle).toBeDefined();

      renderer.calls.length = 0;
      world.update(16);

      const visCalls = renderer.calls.filter((c) => c.method === 'setMeshVisible');
      expect(visCalls.length).toBeGreaterThan(0);
      // Default visibility param is 1 (> 0.5) → visible true.
      expect(visCalls.every((c) => c.args[1] === true)).toBe(true);
    });

    it('does not touch meshes while the panel is hidden', () => {
      addDebugger({ visible: false });
      world.initialize();

      const entity = world.createEntity();
      entity.add(new MeshPrimitiveComponent({ primitive: 'box' }));

      renderer.calls.length = 0;
      world.update(16);

      expect(renderer.calls.find((c) => c.method === 'setMeshVisible')).toBeUndefined();
    });

    it('skips primitive entities that have no live handle', () => {
      addDebugger({ visible: true });
      world.initialize();

      const entity = world.createEntity();
      // autoCreate:false → no handle is ever produced.
      entity.add(new MeshPrimitiveComponent({ primitive: 'box', autoCreate: false }));

      renderer.calls.length = 0;
      expect(() => world.update(16)).not.toThrow();
      expect(renderer.calls.find((c) => c.method === 'setMeshVisible')).toBeUndefined();
    });
  });

  describe('teardown', () => {
    it('unregisters the panel on shutdown', () => {
      addDebugger();
      world.initialize();
      expect(vizStore.panels[PANEL_ID]).toBeDefined();

      world.shutdown();
      expect(vizStore.panels[PANEL_ID]).toBeUndefined();
    });

    it('unregisters the panel and unbinds when the debugger entity is removed', () => {
      const { entity } = addDebugger();
      world.initialize();
      expect(vizStore.panels[PANEL_ID]).toBeDefined();

      world.removeEntity(entity);
      expect(vizStore.panels[PANEL_ID]).toBeUndefined();
      expect((system as unknown as { component: unknown }).component).toBeNull();
    });

    it('leaves the panel alone when a non-bound entity is removed', () => {
      addDebugger();
      world.initialize();

      // A bare entity (no debugger component) being removed must not
      // tear down the panel.
      const other = world.createEntity();
      world.removeEntity(other);
      expect(vizStore.panels[PANEL_ID]).toBeDefined();
    });
  });

  describe('persisted params storage', () => {
    it('loads previously saved params from localStorage on registration', () => {
      localStorage.setItem(
        `${STORAGE_PREFIX}-${vizStore.sceneName}`,
        JSON.stringify({ visibility: 0 })
      );
      addDebugger({ visible: true });
      world.initialize();

      const entity = world.createEntity();
      entity.add(new MeshPrimitiveComponent({ primitive: 'box' }));

      renderer.calls.length = 0;
      world.update(16);

      const visCalls = renderer.calls.filter((c) => c.method === 'setMeshVisible');
      // Saved visibility 0 (< 0.5) → visible false.
      expect(visCalls.length).toBeGreaterThan(0);
      expect(visCalls.every((c) => c.args[1] === false)).toBe(true);
    });

    it('tolerates corrupt stored params', () => {
      localStorage.setItem(`${STORAGE_PREFIX}-${vizStore.sceneName}`, 'not json');
      addDebugger();
      expect(() => world.initialize()).not.toThrow();
      expect(vizStore.panels[PANEL_ID]).toBeDefined();
    });
  });

  describe('panel content factory', () => {
    function renderPanelContent() {
      addDebugger();
      world.initialize();
      const content = vizStore.panels[PANEL_ID].content;
      return render(() => content() as Element);
    }

    it('renders the MeshPrimitivePanel sliders', () => {
      const { getByText, unmount } = renderPanelContent();
      expect(getByText('Scale X')).toBeTruthy();
      expect(getByText('Visibility')).toBeTruthy();
      unmount();
    });

    it('persists a param change through setParam', () => {
      const { container, unmount } = renderPanelContent();
      const slider = container.querySelector('input[type="range"]') as HTMLInputElement;
      expect(slider).toBeTruthy();

      slider.value = '3';
      slider.dispatchEvent(new Event('input', { bubbles: true }));

      const saved = JSON.parse(
        localStorage.getItem(`${STORAGE_PREFIX}-${vizStore.sceneName}`) ?? '{}'
      );
      expect(saved.scaleX).toBe(3);
      unmount();
    });

    it('swallows storage errors when saving a param change', () => {
      const { container, unmount } = renderPanelContent();
      const slider = container.querySelector('input[type="range"]') as HTMLInputElement;

      const original = Storage.prototype.setItem;
      Storage.prototype.setItem = () => {
        throw new Error('quota exceeded');
      };
      try {
        expect(() => {
          slider.value = '2';
          slider.dispatchEvent(new Event('input', { bubbles: true }));
        }).not.toThrow();
      } finally {
        Storage.prototype.setItem = original;
      }
      unmount();
    });

    it('resets params to defaults via the reset button', () => {
      const { getByText, unmount } = renderPanelContent();

      // First mutate a param so reset is observable.
      const slider = document.querySelector('input[type="range"]') as HTMLInputElement;
      slider.value = '4';
      slider.dispatchEvent(new Event('input', { bubbles: true }));

      const resetBtn = getByText(/reset/i);
      resetBtn.dispatchEvent(new MouseEvent('click', { bubbles: true }));

      const saved = JSON.parse(
        localStorage.getItem(`${STORAGE_PREFIX}-${vizStore.sceneName}`) ?? '{}'
      );
      expect(saved.scaleX).toBe(1);
      expect(saved.scaleY).toBe(1);
      expect(saved.scaleZ).toBe(1);
      expect(saved.visibility).toBe(1);
      unmount();
    });
  });
});