DirectionalLight

import { runMechanicContract } from '@babylonjsmarket/ecs/testing';
import {
  DirectionalLightComponent,
  DirectionalLightSystem,
  DirectionalLightEvents,
} from './DirectionalLight';

runMechanicContract({
  name: 'DirectionalLight',
  componentClass: DirectionalLightComponent,
  systemClass: DirectionalLightSystem,
  sampleInput: { intensity: 1.1, direction: [-1, -2, -1] },
  events: {
    output: [DirectionalLightEvents.CREATED],
  },
});

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

function makeParams(): DirectionalLightParams {
  return {
    dirX: -1, dirY: -1, dirZ: -1,
    posX: 0, posY: 10, posZ: 0,
    intensity: 1,
    diffuseR: 1, diffuseG: 1, diffuseB: 1,
    specularR: 1, specularG: 1, specularB: 1,
  };
}

describe('DirectionalLightPanel', () => {
  it('mounts and shows the Direction section', () => {
    const { container } = render(() => (
      <DirectionalLightPanel params={makeParams()} setParam={vi.fn()} onReset={vi.fn()} />
    ));
    expect(container.textContent).toContain('Direction');
    expect(container.textContent).toContain('Intensity');
  });

  it('moving a direction slider calls setParam', () => {
    const setParam = vi.fn();
    const { getAllByRole } = render(() => (
      <DirectionalLightPanel params={makeParams()} setParam={setParam} onReset={vi.fn()} />
    ));
    const slider = (getAllByRole('slider') as HTMLInputElement[])[0];
    fireEvent.input(slider, { target: { value: '0.5' } });
    expect(setParam).toHaveBeenCalledWith('dirX', 0.5);
  });

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

  it('every slider routes to its own param key', () => {
    // Sliders render in declaration order; each must forward to a distinct key.
    const keys: (keyof DirectionalLightParams)[] = [
      'dirX', 'dirY', 'dirZ',
      'posX', 'posY', 'posZ',
      'intensity',
      'diffuseR', 'diffuseG', 'diffuseB',
      'specularR', 'specularG', 'specularB',
    ];
    const setParam = vi.fn();
    const { getAllByRole } = render(() => (
      <DirectionalLightPanel params={makeParams()} setParam={setParam} onReset={vi.fn()} />
    ));
    const sliders = getAllByRole('slider') as HTMLInputElement[];
    expect(sliders).toHaveLength(keys.length);

    sliders.forEach((slider, i) => {
      fireEvent.input(slider, { target: { value: '0.25' } });
      expect(setParam).toHaveBeenNthCalledWith(i + 1, keys[i], 0.25);
    });
  });
});

import { describe, it, expect, beforeEach, vi } from 'vitest';
import {
  DirectionalLightComponent,
  DirectionalLightSystem,
  DirectionalLightEvents,
} from './DirectionalLight';
import { EventBus, World } from '@babylonjsmarket/ecs';
import { MockRendererAdapter } from '@babylonjsmarket/ecs';

describe('DirectionalLightComponent (core)', () => {
  it('defaults to downward-ish normalized direction and position [15, 30, 15]', () => {
    const c = new DirectionalLightComponent();
    const len = Math.hypot(c.direction[0], c.direction[1], c.direction[2]);
    expect(len).toBeCloseTo(1);
    expect(c.position).toEqual([15, 30, 15]);
    expect(c.intensity).toBe(0.8);
    expect(c.diffuse).toEqual([1, 1, 1]);
    expect(c.specular).toEqual([1, 1, 1]);
    expect(c.shadowEnabled).toBe(true);
    expect(c.shadowMapSize).toBe(1024);
    expect(c.autoCreate).toBe(true);
    expect(c.initialized).toBe(false);
    expect(c.handle).toBeUndefined();
  });

  it('normalizes direction when provided', () => {
    const c = new DirectionalLightComponent({ direction: [2, 0, 0] });
    expect(c.direction[0]).toBeCloseTo(1);
    expect(c.direction[1]).toBeCloseTo(0);
    expect(c.direction[2]).toBeCloseTo(0);
  });

  it('accepts full configuration', () => {
    const c = new DirectionalLightComponent({
      direction: [-1, -3, -1],
      position: [10, 20, 10],
      intensity: 1.2,
      diffuse: [0.9, 0.9, 1],
      specular: [0.3, 0.3, 0.3],
      shadowEnabled: false,
      shadowMinZ: 1,
      shadowMaxZ: 200,
      shadowMapSize: 2048,
      autoCreate: false,
    });
    expect(c.intensity).toBe(1.2);
    expect(c.shadowEnabled).toBe(false);
    expect(c.shadowMapSize).toBe(2048);
    expect(c.autoCreate).toBe(false);
    expect(c.position).toEqual([10, 20, 10]);
  });

  it('toSpec produces a DirectionalLightSpec with the shadow sub-spec', () => {
    const c = new DirectionalLightComponent({ shadowMapSize: 512, shadowMaxZ: 300 });
    const spec = c.toSpec();
    expect(spec.shadow?.mapSize).toBe(512);
    expect(spec.shadow?.maxZ).toBe(300);
    expect(spec.shadow?.enabled).toBe(true);
  });

  it('serialize round-trips through the constructor', () => {
    const original = new DirectionalLightComponent({
      direction: [-1, -3, -1],
      position: [10, 20, 10],
      intensity: 0.6,
      diffuse: [1, 1, 0.9],
      shadowEnabled: false,
      autoCreate: false,
    });
    const copy = new DirectionalLightComponent(original.serialize());
    expect(copy.intensity).toBe(0.6);
    expect(copy.shadowEnabled).toBe(false);
    expect(copy.autoCreate).toBe(false);
    expect(copy.position).toEqual([10, 20, 10]);
  });
});

describe('DirectionalLight event names', () => {
  it('defines all standard events', () => {
    expect(DirectionalLightEvents.CREATED).toBe('directionallight.created');
    expect(DirectionalLightEvents.DIRECTION_CHANGED).toBe('directionallight.direction.changed');
    expect(DirectionalLightEvents.INTENSITY_CHANGED).toBe('directionallight.intensity.changed');
    expect(DirectionalLightEvents.COLOR_CHANGED).toBe('directionallight.color.changed');
    expect(DirectionalLightEvents.SHADOW_CREATED).toBe('directionallight.shadow.created');
  });
});

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

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

  it('creates a light through the adapter on entity add', () => {
    const entity = world.createEntity();
    entity.add(new DirectionalLightComponent({ intensity: 0.5 }));
    const call = renderer.calls.find((c) => c.method === 'createDirectionalLight');
    expect(call).toBeDefined();
    expect((call?.args[1] as { intensity: number }).intensity).toBe(0.5);
  });

  it('does not auto-create when autoCreate is false', () => {
    const entity = world.createEntity();
    entity.add(new DirectionalLightComponent({ autoCreate: false }));
    expect(renderer.calls.find((c) => c.method === 'createDirectionalLight')).toBeUndefined();
  });

  it('emits CREATED event', () => {
    const spy = vi.fn();
    eventBus.on(DirectionalLightEvents.CREATED, spy);
    const entity = world.createEntity();
    entity.add(new DirectionalLightComponent());
    expect(spy).toHaveBeenCalledWith(
      expect.objectContaining({
        entityId: entity.id,
        intensity: 0.8,
      }),
    );
  });

  it('CREATED carries the light handle so shadow consumers can attach casters', () => {
    const spy = vi.fn();
    eventBus.on(DirectionalLightEvents.CREATED, spy);
    const entity = world.createEntity();
    const comp = new DirectionalLightComponent();
    entity.add(comp);
    const payload = spy.mock.calls[0][0];
    expect(payload.handle).toBeDefined();
    expect(payload.handle).toBe(comp.handle);
  });

  it('emits SHADOW_CREATED when shadows are enabled', () => {
    const spy = vi.fn();
    eventBus.on(DirectionalLightEvents.SHADOW_CREATED, spy);
    const entity = world.createEntity();
    entity.add(new DirectionalLightComponent({ shadowMapSize: 512 }));
    expect(spy).toHaveBeenCalledWith({ entityId: entity.id, shadowMapSize: 512 });
  });

  it('does not emit SHADOW_CREATED when shadows are disabled', () => {
    const spy = vi.fn();
    eventBus.on(DirectionalLightEvents.SHADOW_CREATED, spy);
    const entity = world.createEntity();
    entity.add(new DirectionalLightComponent({ shadowEnabled: false }));
    expect(spy).not.toHaveBeenCalled();
  });

  it('forwards intensity changes through the adapter', () => {
    const entity = world.createEntity();
    const comp = new DirectionalLightComponent({ intensity: 0.5 });
    entity.add(comp);
    renderer.calls.length = 0;
    comp.intensity = 1.0;
    world.update(0.016);
    expect(renderer.calls.find((c) => c.method === 'updateLightIntensity')?.args[1]).toBe(1.0);
  });

  it('emits DIRECTION_CHANGED when the direction mutates', () => {
    const spy = vi.fn();
    eventBus.on(DirectionalLightEvents.DIRECTION_CHANGED, spy);
    const entity = world.createEntity();
    const comp = new DirectionalLightComponent();
    entity.add(comp);
    comp.direction[0] = 1;
    comp.direction[1] = 0;
    comp.direction[2] = 0;
    world.update(0.016);
    expect(spy).toHaveBeenCalled();
  });

  it('emits COLOR_CHANGED when diffuse or specular mutates', () => {
    const spy = vi.fn();
    eventBus.on(DirectionalLightEvents.COLOR_CHANGED, spy);
    const entity = world.createEntity();
    const comp = new DirectionalLightComponent();
    entity.add(comp);
    comp.diffuse[0] = 0.5;
    world.update(0.016);
    expect(spy).toHaveBeenCalled();
  });

  it('disposes the light on entity removal', () => {
    const entity = world.createEntity();
    entity.add(new DirectionalLightComponent());
    renderer.calls.length = 0;
    world.removeEntity(entity);
    expect(renderer.calls.some((c) => c.method === 'disposeLight')).toBe(true);
  });
});

describe('DirectionalLightSystem — onInitialize back-fills pre-existing entities', () => {
  it('creates lights for entities that exist before the system initializes', () => {
    const eventBus = new EventBus();
    const renderer = new MockRendererAdapter();
    const world = new World({ eventBus, renderer });

    // Entity (with a light component) exists in the world BEFORE the system is
    // added — so onInitialize()'s back-fill loop, not onEntityAdded, must build it.
    const entity = world.createEntity();
    entity.add(new DirectionalLightComponent({ intensity: 0.42 }));
    expect(renderer.calls.find((c) => c.method === 'createDirectionalLight')).toBeUndefined();

    const system = new DirectionalLightSystem(eventBus);
    world.addSystem(system);
    world.initialize();

    const call = renderer.calls.find((c) => c.method === 'createDirectionalLight');
    expect(call).toBeDefined();
    expect((call?.args[1] as { intensity: number }).intensity).toBe(0.42);
    expect(entity.get(DirectionalLightComponent)?.initialized).toBe(true);
  });
});

import { describe, it, expect, beforeEach } from 'vitest';
import {
  DirectionalLightDebuggerComponent,
  DirectionalLightDebuggerInput,
  DirectionalLightDebuggerEvents,
} from './DirectionalLight.viz.tsx';

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

  beforeEach(() => {
    component = new DirectionalLightDebuggerComponent({
      visible: true,
      activationKey: 'Digit7',
      position: 'bottom-right',
      showArrows: false,
    });
  });

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

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

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

  describe('visibility', () => {
    it('should start hidden by default', () => {
      const comp = new DirectionalLightDebuggerComponent();
      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 DirectionalLightDebuggerComponent({ visible: true });
      expect(visibleComp.visible).toBe(true);

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

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

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

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

    it('should default to Digit8', () => {
      const comp = new DirectionalLightDebuggerComponent();
      expect(comp.activationKey).toBe('Digit8');
    });

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

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

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

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

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

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

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

  describe('showArrows', () => {
    it('should accept true', () => {
      const comp = new DirectionalLightDebuggerComponent({ showArrows: true });
      expect(comp.showArrows).toBe(true);
    });

    it('should accept false', () => {
      const comp = new DirectionalLightDebuggerComponent({ showArrows: false });
      expect(comp.showArrows).toBe(false);
    });

    it('should default to true', () => {
      const comp = new DirectionalLightDebuggerComponent();
      expect(comp.showArrows).toBe(true);
    });

    it('should allow changing showArrows', () => {
      component.showArrows = true;
      expect(component.showArrows).toBe(true);
    });
  });

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

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

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

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

  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('Digit7');
      component.activationKey = 'Digit6';
      expect(component.activationKey).toBe('Digit6');
    });

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

    it('should allow showArrows to be modified', () => {
      expect(component.showArrows).toBe(false);
      component.showArrows = true;
      expect(component.showArrows).toBe(true);
    });
  });
});

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

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

describe('DirectionalLightDebuggerSystem 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 DirectionalLightDebuggerSystem exposes
    const expectedParams = {
      dirX: -1,
      dirY: -3,
      dirZ: -1,
      posX: 15,
      posY: 30,
      posZ: 15,
      intensity: 0.8,
      diffuseR: 1,
      diffuseG: 1,
      diffuseB: 1,
      specularR: 1,
      specularG: 1,
      specularB: 1,
    };

    // Verify structure
    expect(Object.keys(expectedParams)).toHaveLength(13);
    expect(expectedParams.dirX).toBe(-1);
    expect(expectedParams.dirY).toBe(-3);
    expect(expectedParams.dirZ).toBe(-1);
    expect(expectedParams.posX).toBe(15);
    expect(expectedParams.posY).toBe(30);
    expect(expectedParams.posZ).toBe(15);
    expect(expectedParams.intensity).toBe(0.8);
    expect(expectedParams.diffuseR).toBe(1);
    expect(expectedParams.diffuseG).toBe(1);
    expect(expectedParams.diffuseB).toBe(1);
    expect(expectedParams.specularR).toBe(1);
    expect(expectedParams.specularG).toBe(1);
    expect(expectedParams.specularB).toBe(1);
  });

  it('should support direction range', () => {
    // Direction components should support negative and positive values
    expect(-10).toBeLessThanOrEqual(-1);
    expect(-1).toBeLessThanOrEqual(10);
  });

  it('should support position range', () => {
    // Position should support a reasonable range for scene coordinates
    expect(-50).toBeLessThanOrEqual(15);
    expect(15).toBeLessThanOrEqual(100);
  });

  it('should support intensity range', () => {
    // Intensity should be non-negative and support values above 1
    expect(0).toBeLessThanOrEqual(0.8);
    expect(0.8).toBeLessThanOrEqual(2);
  });

  it('should support color component range', () => {
    // Color components should be 0-1
    expect(0).toBeLessThanOrEqual(1);
    expect(1).toBeLessThanOrEqual(1);
  });
});

// @vitest-environment jsdom
/**
 * Drives the full DirectionalLightDebuggerSystem (registration, keyboard toggle,
 * per-frame param application, storage persistence, teardown) and renders the
 * registered panel content so its setParam / onReset closures execute.
 *
 * Lives in its own jsdom file because the system reaches for window, localStorage
 * and Solid stores — none of which exist in the default node environment used by
 * DirectionalLight.viz.test.ts.
 */
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import { render, fireEvent, cleanup } from '@solidjs/testing-library';
import { EventBus, World } from '@babylonjsmarket/ecs';
import { MockRendererAdapter } from '@babylonjsmarket/ecs';
import { vizStore } from '../_shared/viz';
import {
  DirectionalLightDebuggerComponent,
  DirectionalLightDebuggerSystem,
  DirectionalLightDebuggerEvents,
} from './DirectionalLight.viz.tsx';
import { DirectionalLightComponent } from './DirectionalLight';

const PANEL_ID = 'directional-light-debugger';
const STORAGE_KEY = 'directional-light-debugger-params';

// Worlds spun up per test; shut them all down afterwards so each system detaches
// its window keydown listener (otherwise stale listeners from prior tests toggle
// the shared panel on every key dispatch).
const liveWorlds: World[] = [];

function freshWorld() {
  const eventBus = new EventBus();
  const renderer = new MockRendererAdapter();
  const world = new World({ eventBus, renderer });
  liveWorlds.push(world);
  return { eventBus, renderer, world };
}

beforeEach(() => {
  localStorage.clear();
  // vizStore is a module-level singleton shared across files; clear() merges
  // rather than replaces, so unregister our panel explicitly for a clean slate.
  vizStore.unregisterPanel(PANEL_ID);
  vizStore.setSceneName('default');
});

afterEach(() => {
  cleanup();
  while (liveWorlds.length) liveWorlds.pop()!.shutdown();
  vizStore.unregisterPanel(PANEL_ID);
});

describe('DirectionalLightDebuggerSystem — panel registration', () => {
  it('registers a panel on initialize and starts hidden by default', () => {
    const { eventBus, world } = freshWorld();
    const entity = world.createEntity();
    entity.add(new DirectionalLightDebuggerComponent());
    world.addSystem(new DirectionalLightDebuggerSystem(eventBus));
    world.initialize();

    expect(vizStore.panels[PANEL_ID]).toBeDefined();
    expect(vizStore.panels[PANEL_ID].title).toBe('Directional Light Controls');
    expect(vizStore.isVisible(PANEL_ID)).toBe(false);
  });

  it('shows the panel and emits SHOWN when the component starts visible', () => {
    const { eventBus, world } = freshWorld();
    const shown = vi.fn();
    eventBus.on(DirectionalLightDebuggerEvents.SHOWN, shown);

    // System first, then the entity — registration runs once via onEntityAdded.
    world.addSystem(new DirectionalLightDebuggerSystem(eventBus));
    world.initialize();
    const entity = world.createEntity();
    entity.add(new DirectionalLightDebuggerComponent({ visible: true, position: 'bottom-left' }));

    expect(vizStore.isVisible(PANEL_ID)).toBe(true);
    expect(vizStore.panels[PANEL_ID].position).toBe('bottom-left');
    expect(shown).toHaveBeenCalledTimes(1);
  });

  it('back-fills a debugger entity that exists before the system initializes', () => {
    // Covers onInitialize()'s entity loop: the component is discovered there.
    const { eventBus, world } = freshWorld();
    const entity = world.createEntity();
    entity.add(new DirectionalLightDebuggerComponent({ visible: true }));
    world.addSystem(new DirectionalLightDebuggerSystem(eventBus));
    world.initialize();

    expect(vizStore.panels[PANEL_ID]).toBeDefined();
    expect(vizStore.isVisible(PANEL_ID)).toBe(true);
  });

  it('does nothing on initialize when no debugger entity is present', () => {
    const { eventBus, world } = freshWorld();
    world.addSystem(new DirectionalLightDebuggerSystem(eventBus));
    world.initialize();
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();
  });

  it('registers the panel when a debugger entity is added after initialize', () => {
    const { eventBus, world } = freshWorld();
    world.addSystem(new DirectionalLightDebuggerSystem(eventBus));
    world.initialize();
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();

    const entity = world.createEntity();
    entity.add(new DirectionalLightDebuggerComponent());
    expect(vizStore.panels[PANEL_ID]).toBeDefined();
  });
});

describe('DirectionalLightDebuggerSystem — panel content closures', () => {
  it('setParam updates the store, mutates local params, and persists to storage', () => {
    const { eventBus, world } = freshWorld();
    const entity = world.createEntity();
    entity.add(new DirectionalLightDebuggerComponent());
    world.addSystem(new DirectionalLightDebuggerSystem(eventBus));
    world.initialize();

    const { getAllByRole } = render(() => vizStore.panels[PANEL_ID].content());
    const firstSlider = (getAllByRole('slider') as HTMLInputElement[])[0]; // dirX
    fireEvent.input(firstSlider, { target: { value: '5' } });

    const saved = JSON.parse(localStorage.getItem(`${STORAGE_KEY}-default`)!);
    expect(saved.dirX).toBe(5);
  });

  it('onReset restores defaults and persists them', () => {
    const { eventBus, world } = freshWorld();
    const entity = world.createEntity();
    entity.add(new DirectionalLightDebuggerComponent());
    world.addSystem(new DirectionalLightDebuggerSystem(eventBus));
    world.initialize();

    const { getAllByRole, getByText } = render(() => vizStore.panels[PANEL_ID].content());
    const sliders = getAllByRole('slider') as HTMLInputElement[];
    fireEvent.input(sliders[6], { target: { value: '1.5' } }); // intensity
    fireEvent.click(getByText(/reset/i));

    const saved = JSON.parse(localStorage.getItem(`${STORAGE_KEY}-default`)!);
    expect(saved.intensity).toBe(0.8); // back to DEFAULT_PARAMS
    expect(saved.dirX).toBe(-1);
  });
});

describe('DirectionalLightDebuggerSystem — keyboard toggle', () => {
  function setup(activationKey = 'Digit8') {
    const ctx = freshWorld();
    const entity = ctx.world.createEntity();
    const comp = new DirectionalLightDebuggerComponent({ activationKey });
    entity.add(comp);
    ctx.world.addSystem(new DirectionalLightDebuggerSystem(ctx.eventBus));
    ctx.world.initialize();
    return { ...ctx, comp };
  }

  it('toggles the panel on the activation key and emits SHOWN then HIDDEN', () => {
    const { eventBus, comp } = setup('Digit8');
    const shown = vi.fn();
    const hidden = vi.fn();
    eventBus.on(DirectionalLightDebuggerEvents.SHOWN, shown);
    eventBus.on(DirectionalLightDebuggerEvents.HIDDEN, hidden);

    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'Digit8' }));
    expect(vizStore.isVisible(PANEL_ID)).toBe(true);
    expect(comp.visible).toBe(true);
    expect(shown).toHaveBeenCalledTimes(1);

    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'Digit8' }));
    expect(vizStore.isVisible(PANEL_ID)).toBe(false);
    expect(comp.visible).toBe(false);
    expect(hidden).toHaveBeenCalledTimes(1);
  });

  it('ignores keys other than the activation key', () => {
    setup('Digit8');
    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'Digit3' }));
    expect(vizStore.isVisible(PANEL_ID)).toBe(false);
  });

  it('the keyboard handler no-ops once the debugger component is gone', () => {
    const { world, entity } = (() => {
      const ctx = freshWorld();
      const e = ctx.world.createEntity();
      e.add(new DirectionalLightDebuggerComponent({ activationKey: 'Digit8' }));
      ctx.world.addSystem(new DirectionalLightDebuggerSystem(ctx.eventBus));
      ctx.world.initialize();
      return { world: ctx.world, entity: e };
    })();

    world.removeEntity(entity); // clears system.component, keeps the keydown listener
    // Handler's early `if (!this.component) return;` guard must swallow the key.
    expect(() => window.dispatchEvent(new KeyboardEvent('keydown', { code: 'Digit8' }))).not.toThrow();
  });
});

describe('DirectionalLightDebuggerSystem — per-frame application', () => {
  it('writes panel params onto every DirectionalLightComponent while visible', () => {
    const { eventBus, world } = freshWorld();

    const lightEntity = world.createEntity();
    const light = new DirectionalLightComponent();
    lightEntity.add(light);

    const dbgEntity = world.createEntity();
    dbgEntity.add(new DirectionalLightDebuggerComponent({ visible: true }));

    const system = new DirectionalLightDebuggerSystem(eventBus);
    world.addSystem(system);
    world.initialize();

    // Drive a param change through the panel, then tick.
    const { getAllByRole } = render(() => vizStore.panels[PANEL_ID].content());
    const sliders = getAllByRole('slider') as HTMLInputElement[];
    fireEvent.input(sliders[6], { target: { value: '2' } }); // intensity
    fireEvent.input(sliders[7], { target: { value: '0.5' } }); // diffuseR

    world.update(0.016);

    expect(light.intensity).toBe(2);
    expect(light.diffuse[0]).toBe(0.5);
    // Direction is re-normalized from the default dir params (-1,-3,-1).
    const len = Math.hypot(light.direction[0], light.direction[1], light.direction[2]);
    expect(len).toBeCloseTo(1);
  });

  it('does not write to lights while the panel is hidden', () => {
    const { eventBus, world } = freshWorld();
    const lightEntity = world.createEntity();
    const light = new DirectionalLightComponent({ intensity: 0.8 });
    lightEntity.add(light);

    const dbgEntity = world.createEntity();
    dbgEntity.add(new DirectionalLightDebuggerComponent({ visible: false }));

    world.addSystem(new DirectionalLightDebuggerSystem(eventBus));
    world.initialize();
    world.update(0.016);

    expect(light.intensity).toBe(0.8); // untouched
  });

  it('syncs the component flag back from the store when the panel is toggled externally', () => {
    const { eventBus, world } = freshWorld();
    const dbgEntity = world.createEntity();
    const comp = new DirectionalLightDebuggerComponent({ visible: false });
    dbgEntity.add(comp);
    world.addSystem(new DirectionalLightDebuggerSystem(eventBus));
    world.initialize();

    vizStore.showPanel(PANEL_ID); // someone else opened the panel
    world.update(0.016);
    expect(comp.visible).toBe(true);
  });

  it('onUpdate is inert before a debugger component exists', () => {
    const { eventBus, world } = freshWorld();
    world.addSystem(new DirectionalLightDebuggerSystem(eventBus));
    world.initialize();
    expect(() => world.update(0.016)).not.toThrow();
  });
});

describe('DirectionalLightDebuggerSystem — storage persistence', () => {
  it('reloads saved params when a fresh system registers the panel', () => {
    localStorage.setItem(`${STORAGE_KEY}-default`, JSON.stringify({ intensity: 1.9, dirX: 4 }));

    const { eventBus, world } = freshWorld();
    const dbgEntity = world.createEntity();
    dbgEntity.add(new DirectionalLightDebuggerComponent({ visible: true }));

    const lightEntity = world.createEntity();
    const light = new DirectionalLightComponent();
    lightEntity.add(light);

    world.addSystem(new DirectionalLightDebuggerSystem(eventBus));
    world.initialize();
    world.update(0.016);

    expect(light.intensity).toBe(1.9); // came from storage, not DEFAULT_PARAMS
  });

  it('tolerates corrupt storage by falling back to defaults', () => {
    localStorage.setItem(`${STORAGE_KEY}-default`, '{not json');
    const { eventBus, world } = freshWorld();
    const dbgEntity = world.createEntity();
    dbgEntity.add(new DirectionalLightDebuggerComponent());
    expect(() => {
      world.addSystem(new DirectionalLightDebuggerSystem(eventBus));
      world.initialize();
    }).not.toThrow();
    expect(vizStore.panels[PANEL_ID]).toBeDefined();
  });

  it('swallows write failures when localStorage.setItem throws', () => {
    const { eventBus, world } = freshWorld();
    const dbgEntity = world.createEntity();
    dbgEntity.add(new DirectionalLightDebuggerComponent());
    world.addSystem(new DirectionalLightDebuggerSystem(eventBus));
    world.initialize();

    const setItem = vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
      throw new Error('quota');
    });
    const { getAllByRole } = render(() => vizStore.panels[PANEL_ID].content());
    const slider = (getAllByRole('slider') as HTMLInputElement[])[0];
    expect(() => fireEvent.input(slider, { target: { value: '3' } })).not.toThrow();
    setItem.mockRestore();
  });
});

describe('DirectionalLightDebuggerSystem — teardown', () => {
  it('unregisters the panel and detaches the keyboard listener on shutdown', () => {
    const { eventBus, world } = freshWorld();
    const dbgEntity = world.createEntity();
    const comp = new DirectionalLightDebuggerComponent({ activationKey: 'Digit8' });
    dbgEntity.add(comp);
    const system = new DirectionalLightDebuggerSystem(eventBus);
    world.addSystem(system);
    world.initialize();
    expect(vizStore.panels[PANEL_ID]).toBeDefined();

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

    // Listener removed: re-show wouldn't fire because the panel is gone, and the
    // key dispatch must not throw on the detached handler.
    expect(() => window.dispatchEvent(new KeyboardEvent('keydown', { code: 'Digit8' }))).not.toThrow();
  });

  it('unregisters the panel when the debugger entity is removed', () => {
    const { eventBus, world } = freshWorld();
    const dbgEntity = world.createEntity();
    dbgEntity.add(new DirectionalLightDebuggerComponent());
    world.addSystem(new DirectionalLightDebuggerSystem(eventBus));
    world.initialize();
    expect(vizStore.panels[PANEL_ID]).toBeDefined();

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

  it('ignores removal of an unrelated entity', () => {
    const { eventBus, world } = freshWorld();
    const dbgEntity = world.createEntity();
    dbgEntity.add(new DirectionalLightDebuggerComponent());
    world.addSystem(new DirectionalLightDebuggerSystem(eventBus));
    world.initialize();

    const other = world.createEntity();
    other.add(new DirectionalLightComponent());
    world.removeEntity(other);

    expect(vizStore.panels[PANEL_ID]).toBeDefined();
  });
});