Shadow

import { runMechanicContract } from '@babylonjsmarket/ecs/testing';
import { ShadowComponent, ShadowSystem } from './Shadow';
import { DirectionalLightComponent } from '../DirectionalLight/DirectionalLight.defs';

runMechanicContract({
  name: 'Shadow',
  componentClass: ShadowComponent,
  systemClass: ShadowSystem,
  sampleInput: { castShadow: true, receiveShadow: false },
  events: {
    input: ['meshprimitive.created'],
    // Shadow's output (SHADOW_CASTER_ADDED etc.) only fires once a matching
    // mesh handle and light handle both exist — the full flow is covered by
    // Shadow.test.ts and the scene-level demo, not the generic contract.
  },
  setup({ world, renderer }) {
    // Shadow needs a DirectionalLight already in the world to find the
    // shadow-caster attachment target.
    const lightEntity = world.createEntity();
    const light = new DirectionalLightComponent({
      shadowEnabled: true,
      direction: [-1, -2, -1],
    });
    light.handle = renderer.createDirectionalLight(lightEntity.id, {
      direction: [-1, -2, -1],
      intensity: 1,
      diffuse: [1, 1, 1],
      specular: [1, 1, 1],
    });
    lightEntity.add(light);
  },
});

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

function makeParams(): ShadowParams {
  return {
    darkness: 0.4,
    bias: 0.00005,
    normalBias: 0,
    filteringQuality: 2,
    castShadowsGlobal: 1,
    receiveShadowsGlobal: 1,
  };
}

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

  it('moving the darkness slider fires setParam', () => {
    const setParam = vi.fn();
    const { getAllByRole } = render(() => (
      <ShadowPanel params={makeParams()} setParam={setParam} onReset={vi.fn()} />
    ));
    fireEvent.input(
      (getAllByRole('slider') as HTMLInputElement[])[0],
      { target: { value: '0.8' } },
    );
    expect(setParam).toHaveBeenCalledWith('darkness', 0.8);
  });

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

  it('routes every slider to setParam with its own key', () => {
    // Each slider owns a distinct onChange arrow — drive all six so every
    // setParam edge fires, not just darkness.
    const setParam = vi.fn();
    const { getAllByRole } = render(() => (
      <ShadowPanel params={makeParams()} setParam={setParam} onReset={vi.fn()} />
    ));
    const sliders = getAllByRole('slider') as HTMLInputElement[];
    const keys: Array<keyof ShadowParams> = [
      'darkness',
      'bias',
      'normalBias',
      'filteringQuality',
      'castShadowsGlobal',
      'receiveShadowsGlobal',
    ];
    // Each slider clamps to its own range, so assert the key was routed (not a
    // literal value): the point is every onChange arrow fires.
    sliders.forEach((s) => fireEvent.input(s, { target: { value: '1' } }));
    keys.forEach((k) =>
      expect(setParam).toHaveBeenCalledWith(k, expect.any(Number)),
    );
    expect(setParam).toHaveBeenCalledTimes(keys.length);
  });

  it('labels the Off toggle state and the High filter-quality fallback', () => {
    // castShadowsGlobal at 0 takes formatToggle's "Off" branch; an out-of-range
    // filteringQuality (5) falls through formatFilterQuality's `|| "High"`.
    const params = { ...makeParams(), castShadowsGlobal: 0, filteringQuality: 5 };
    const { container } = render(() => (
      <ShadowPanel params={params} setParam={vi.fn()} onReset={vi.fn()} />
    ));
    expect(container.textContent).toContain('Off');
    expect(container.textContent).toContain('High');
  });
});

import { describe, it, expect, beforeEach, vi } from 'vitest';
import { ShadowComponent, ShadowSystem, ShadowEvents } from './Shadow';
import { DirectionalLightComponent } from '../DirectionalLight/DirectionalLight.defs';
import { DirectionalLightSystem } from '../DirectionalLight/DirectionalLight';
import { MeshPrimitiveComponent } from '../MeshPrimitive/MeshPrimitive.defs';
import { MeshPrimitiveSystem } from '../MeshPrimitive/MeshPrimitive';
import { EventBus, World } from '@babylonjsmarket/ecs';
import { MockRendererAdapter } from '@babylonjsmarket/ecs';

describe('ShadowComponent (core)', () => {
  it('defaults to cast and receive shadows', () => {
    const c = new ShadowComponent();
    expect(c.castShadow).toBe(true);
    expect(c.receiveShadow).toBe(true);
    expect(c.initialized).toBe(false);
  });

  it('accepts overrides', () => {
    const c = new ShadowComponent({ castShadow: false, receiveShadow: false });
    expect(c.castShadow).toBe(false);
    expect(c.receiveShadow).toBe(false);
  });

  it('serialize round-trips', () => {
    const a = new ShadowComponent({ castShadow: true, receiveShadow: false });
    const b = new ShadowComponent(a.serialize());
    expect(b.castShadow).toBe(true);
    expect(b.receiveShadow).toBe(false);
  });
});

describe('ShadowEvents', () => {
  it('defines event names', () => {
    expect(ShadowEvents.SHADOW_ENABLED).toBe('shadow.enabled');
    expect(ShadowEvents.SHADOW_DISABLED).toBe('shadow.disabled');
    expect(ShadowEvents.SHADOW_CASTER_ADDED).toBe('shadow.caster.added');
  });
});

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

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

  it('attaches a shadow caster when a mesh appears for an entity with cast+receive', () => {
    // Light must exist so ShadowSystem can find it.
    const lightEntity = world.createEntity();
    lightEntity.add(new DirectionalLightComponent());

    const box = world.createEntity();
    box.add(new MeshPrimitiveComponent());
    box.add(new ShadowComponent({ castShadow: true, receiveShadow: true }));

    expect(renderer.calls.some((c) => c.method === 'attachShadowCaster')).toBe(true);
    expect(renderer.calls.some((c) => c.method === 'setMeshReceiveShadows' && c.args[1] === true)).toBe(true);
  });

  it('does not attach caster when castShadow is false', () => {
    const lightEntity = world.createEntity();
    lightEntity.add(new DirectionalLightComponent());

    const floor = world.createEntity();
    floor.add(new MeshPrimitiveComponent());
    floor.add(new ShadowComponent({ castShadow: false, receiveShadow: true }));

    expect(renderer.calls.some((c) => c.method === 'attachShadowCaster')).toBe(false);
    expect(renderer.calls.some((c) => c.method === 'setMeshReceiveShadows' && c.args[1] === true)).toBe(true);
  });

  it('emits SHADOW_ENABLED with castShadow/receiveShadow flags', () => {
    const lightEntity = world.createEntity();
    lightEntity.add(new DirectionalLightComponent());

    const spy = vi.fn();
    eventBus.on(ShadowEvents.SHADOW_ENABLED, spy);

    const box = world.createEntity();
    box.add(new MeshPrimitiveComponent());
    box.add(new ShadowComponent({ castShadow: true, receiveShadow: true }));

    expect(spy).toHaveBeenCalledWith(
      expect.objectContaining({ entityId: box.id, castShadow: true, receiveShadow: true }),
    );
  });

  it('emits SHADOW_CASTER_ADDED when a caster is attached', () => {
    const lightEntity = world.createEntity();
    lightEntity.add(new DirectionalLightComponent());

    const spy = vi.fn();
    eventBus.on(ShadowEvents.SHADOW_CASTER_ADDED, spy);

    const box = world.createEntity();
    box.add(new MeshPrimitiveComponent());
    box.add(new ShadowComponent());

    expect(spy).toHaveBeenCalled();
  });

  it('detaches the caster on entity removal', () => {
    const lightEntity = world.createEntity();
    lightEntity.add(new DirectionalLightComponent());

    const box = world.createEntity();
    box.add(new MeshPrimitiveComponent());
    box.add(new ShadowComponent());

    renderer.calls.length = 0;
    world.removeEntity(box);
    expect(renderer.calls.some((c) => c.method === 'detachShadowCaster')).toBe(true);
  });
});

describe('ShadowSystem — meshes created before initialize', () => {
  it('pulls the mesh handle off the component during onInitialize', () => {
    // Build the world and add the shadow-casting entity BEFORE initialize, so
    // MeshPrimitive's onEntityAdded creates the mesh (firing meshprimitive.created)
    // before ShadowSystem.onInitialize subscribes. The init-time loop must recover
    // the already-created handle straight off the MeshPrimitiveComponent.
    const eventBus = new EventBus();
    const renderer = new MockRendererAdapter();
    const world = new World({ eventBus, renderer });
    world.addSystem(new DirectionalLightSystem(eventBus));
    world.addSystem(new ShadowSystem(eventBus));
    world.addSystem(new MeshPrimitiveSystem(eventBus));

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

    const box = world.createEntity();
    const mp = new MeshPrimitiveComponent();
    box.add(mp);
    box.add(new ShadowComponent({ castShadow: true, receiveShadow: true }));
    expect(mp.handle).toBeDefined();

    // Nothing applied yet — apply only runs from onInitialize for pre-existing entities.
    renderer.calls.length = 0;
    world.initialize();

    expect(renderer.calls.some((c) => c.method === 'attachShadowCaster')).toBe(true);
    expect(box.get(ShadowComponent)!.meshHandle).toBe(mp.handle);
    expect(box.get(ShadowComponent)!.initialized).toBe(true);
  });

  it('does not attach a caster when no DirectionalLight has a handle', () => {
    // A ShadowComponent that wants to cast, a mesh present, but no light in the
    // world → findDirectionalLightHandle returns undefined, so no caster attaches.
    // receiveShadow still applies and SHADOW_ENABLED still fires.
    const eventBus = new EventBus();
    const renderer = new MockRendererAdapter();
    const world = new World({ eventBus, renderer });
    world.addSystem(new ShadowSystem(eventBus));
    world.addSystem(new MeshPrimitiveSystem(eventBus));
    world.initialize();

    const enabledSpy = vi.fn();
    eventBus.on(ShadowEvents.SHADOW_ENABLED, enabledSpy);

    const box = world.createEntity();
    box.add(new MeshPrimitiveComponent());
    box.add(new ShadowComponent({ castShadow: true, receiveShadow: true }));

    expect(renderer.calls.some((c) => c.method === 'attachShadowCaster')).toBe(false);
    expect(renderer.calls.some((c) => c.method === 'setMeshReceiveShadows' && c.args[1] === true)).toBe(true);
    expect(enabledSpy).toHaveBeenCalledWith(
      expect.objectContaining({ entityId: box.id, castShadow: true, receiveShadow: true }),
    );
  });
});

describe('ShadowSystem — model takes the caster from the proxy', () => {
  // A vehicle keeps its MeshPrimitive as a hidden gameplay proxy and rides a
  // GLB on top. The renderer skips invisible meshes when drawing the shadow
  // map, so the caster has to move from the proxy to the loaded model or the
  // shadow disappears entirely.
  let eventBus: EventBus;
  let world: World;
  let renderer: MockRendererAdapter;

  beforeEach(() => {
    eventBus = new EventBus();
    renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer });
    world.addSystem(new DirectionalLightSystem(eventBus));
    world.addSystem(new ShadowSystem(eventBus));
    world.addSystem(new MeshPrimitiveSystem(eventBus));
    world.initialize();
    world.createEntity().add(new DirectionalLightComponent());
  });

  it('re-attaches the caster to the GLB handle when mesh.loaded arrives', () => {
    const car = world.createEntity();
    car.add(new MeshPrimitiveComponent({ visible: false }));
    car.add(new ShadowComponent({ castShadow: true, receiveShadow: false }));

    const proxyAttach = renderer.calls.filter((c) => c.method === 'attachShadowCaster');
    expect(proxyAttach).toHaveLength(1);
    const proxyHandle = proxyAttach[0].args[1];

    eventBus.emit('mesh.loaded', {
      entityId: car.id,
      meshId: 'car-glb',
      animationNames: [],
      handle: 'model-handle',
    });

    // The proxy's caster is released...
    expect(renderer.calls.some((c) => c.method === 'detachShadowCaster')).toBe(true);
    // ...and the model's handle takes its place.
    const attaches = renderer.calls.filter((c) => c.method === 'attachShadowCaster');
    expect(attaches).toHaveLength(2);
    expect(attaches[1].args[1]).toBe('model-handle');
    expect(attaches[1].args[1]).not.toBe(proxyHandle);
  });

  it('ignores a mesh.loaded that carries no handle', () => {
    const car = world.createEntity();
    car.add(new MeshPrimitiveComponent());
    car.add(new ShadowComponent());

    eventBus.emit('mesh.loaded', { entityId: car.id, meshId: 'x', animationNames: [] });

    expect(renderer.calls.filter((c) => c.method === 'attachShadowCaster')).toHaveLength(1);
    expect(renderer.calls.some((c) => c.method === 'detachShadowCaster')).toBe(false);
  });

  it('does not let a late primitive steal the caster back from the model', () => {
    const car = world.createEntity();
    car.add(new ShadowComponent());

    eventBus.emit('mesh.loaded', {
      entityId: car.id,
      meshId: 'car-glb',
      animationNames: [],
      handle: 'model-handle',
    });
    // A primitive created after the model must not displace it.
    eventBus.emit('meshprimitive.created', { entityId: car.id, handle: 'proxy-handle' });

    const attaches = renderer.calls.filter((c) => c.method === 'attachShadowCaster');
    expect(attaches).toHaveLength(1);
    expect(attaches[0].args[1]).toBe('model-handle');
  });
});

// @vitest-environment jsdom
/**
 * Shadow.viz.system.test.tsx — coverage for the vizStore-panel debugger wrapper
 * (ShadowDebuggerSystem) and its localStorage param persistence.
 *
 * The pure ShadowDebuggerComponent (defaults / serialize) is covered in
 * Shadow.viz.test.ts and the renderer-free ShadowPanel in Shadow.panel.test.tsx;
 * here we drive the ECS system: init-time discovery + auto-show, late component
 * arrival via onEntityAdded, the activation-key toggle (show/hide events), the
 * panel content factory's setParam/onReset callbacks (which persist to storage),
 * the per-frame visibility sync, teardown, and the load/save storage round-trip
 * including the swallowed error paths.
 */
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { render, fireEvent } from '@solidjs/testing-library';
import { EventBus, World, MockRendererAdapter } from '@babylonjsmarket/ecs';
import {
  ShadowDebuggerComponent,
  ShadowDebuggerSystem,
  ShadowDebuggerEvents,
} from './Shadow.viz';
import { vizStore } from '../_shared/viz';

const PANEL_ID = 'shadow-debugger';
const STORAGE_KEY = 'shadow-debugger-params';

beforeEach(() => {
  vizStore.clear();
  vizStore.setSceneName('default');
  localStorage.clear();
});

afterEach(() => {
  vi.restoreAllMocks();
});

describe('ShadowDebuggerSystem', () => {
  let eventBus: EventBus;
  let world: World;

  function bootstrap() {
    eventBus = new EventBus();
    world = new World({ eventBus, renderer: new MockRendererAdapter() });
    world.addSystem(new ShadowDebuggerSystem(eventBus));
    world.initialize();
  }

  afterEach(() => {
    if (world) world.shutdown();
  });

  it('discovers a debugger present at init and registers the panel', () => {
    eventBus = new EventBus();
    world = new World({ eventBus, renderer: new MockRendererAdapter() });
    world.addSystem(new ShadowDebuggerSystem(eventBus));
    world.createEntity().add(new ShadowDebuggerComponent({ position: 'bottom-left' }));
    world.initialize();

    const panel = vizStore.panels[PANEL_ID];
    expect(panel).toBeDefined();
    expect(panel.title).toBe('Shadow Controls');
    expect(panel.position).toBe('bottom-left');
    expect(panel.titleColor).toBe('#ffa500');
    // Not visible (default) → SHOWN must not have fired at registration.
    expect(panel.visible).toBe(false);
  });

  it('auto-shows the panel and emits SHOWN when the component starts visible', () => {
    // Add the debugger AFTER initialize so registration happens once (via
    // onEntityAdded), exercising the registerPanel `visible` → showPanel + SHOWN path.
    bootstrap();
    const shownSpy = vi.fn();
    eventBus.on(ShadowDebuggerEvents.SHOWN, shownSpy);
    world.createEntity().add(new ShadowDebuggerComponent({ visible: true }));

    expect(vizStore.isVisible(PANEL_ID)).toBe(true);
    expect(shownSpy).toHaveBeenCalledTimes(1);
  });

  it('registers when the debugger arrives after init via onEntityAdded', () => {
    bootstrap();
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();
    world.createEntity().add(new ShadowDebuggerComponent({ position: 'top-left' }));
    expect(vizStore.panels[PANEL_ID]).toBeDefined();
    expect(vizStore.panels[PANEL_ID].position).toBe('top-left');
  });

  it('keeps the first debugger when a second one is added later', () => {
    bootstrap();
    world.createEntity().add(new ShadowDebuggerComponent({ position: 'top-left' }));
    const registerSpy = vi.spyOn(vizStore, 'registerPanel');
    world.createEntity().add(new ShadowDebuggerComponent({ position: 'bottom-right' }));
    expect(registerSpy).not.toHaveBeenCalled();
    expect(vizStore.panels[PANEL_ID].position).toBe('top-left');
  });

  it('toggles the panel with the activation key, mirroring visibility and emitting events', () => {
    bootstrap();
    const dbg = new ShadowDebuggerComponent({ activationKey: 'Digit8', visible: false });
    world.createEntity().add(dbg);

    const shownSpy = vi.fn();
    const hiddenSpy = vi.fn();
    eventBus.on(ShadowDebuggerEvents.SHOWN, shownSpy);
    eventBus.on(ShadowDebuggerEvents.HIDDEN, hiddenSpy);

    expect(vizStore.isVisible(PANEL_ID)).toBe(false);

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

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

  it('ignores keys that are not the activation key', () => {
    bootstrap();
    world.createEntity().add(new ShadowDebuggerComponent({ activationKey: 'Digit8' }));
    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyX' }));
    expect(vizStore.isVisible(PANEL_ID)).toBe(false);
  });

  it('ignores key presses before any debugger component exists', () => {
    bootstrap();
    expect(() =>
      window.dispatchEvent(new KeyboardEvent('keydown', { code: 'Digit8' })),
    ).not.toThrow();
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();
  });

  it("does not double-bind the keyboard listener when registerPanel runs twice", () => {
    // onInitialize finds the component (1st setupKeyboardListener call); a manual
    // second registerPanel would re-enter setupKeyboardListener, whose guard must
    // keep a single listener so one keypress = one toggle.
    bootstrap();
    const dbg = new ShadowDebuggerComponent({ activationKey: 'Digit8' });
    world.createEntity().add(dbg);
    // onEntityAdded already registered + bound. A stray addEventListener-twice would
    // toggle on then off in a single dispatch; assert the net is exactly one toggle.
    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'Digit8' }));
    expect(vizStore.isVisible(PANEL_ID)).toBe(true);
  });

  it('renders panel content whose sliders persist params and reset restores defaults', () => {
    bootstrap();
    world.createEntity().add(new ShadowDebuggerComponent({ visible: true }));

    const panel = vizStore.panels[PANEL_ID];
    const { getAllByRole, getByText } = render(() => panel.content() as never);

    // First slider is Darkness — moving it routes through setParam, which writes
    // the merged params to localStorage under the scene-scoped key.
    fireEvent.input((getAllByRole('slider') as HTMLInputElement[])[0], {
      target: { value: '0.9' },
    });
    let saved = JSON.parse(localStorage.getItem(`${STORAGE_KEY}-default`)!);
    expect(saved.darkness).toBe(0.9);

    // Reset restores the defaults and persists them.
    fireEvent.click(getByText(/reset/i));
    saved = JSON.parse(localStorage.getItem(`${STORAGE_KEY}-default`)!);
    expect(saved.darkness).toBe(0.4);
    expect(saved.filteringQuality).toBe(2);
  });

  it('seeds the store from previously-saved params', () => {
    localStorage.setItem(
      `${STORAGE_KEY}-default`,
      JSON.stringify({ darkness: 0.75 }),
    );
    bootstrap();
    world.createEntity().add(new ShadowDebuggerComponent({ visible: true }));

    const panel = vizStore.panels[PANEL_ID];
    const { getAllByRole } = render(() => panel.content() as never);
    // The Darkness slider reflects the persisted value, not the default 0.4.
    expect((getAllByRole('slider') as HTMLInputElement[])[0].value).toBe('0.75');
  });

  it('syncs component.visible from the panel on update when they diverge', () => {
    bootstrap();
    const dbg = new ShadowDebuggerComponent({ visible: false });
    world.createEntity().add(dbg);

    // Show the panel directly (not through the component) → next update reconciles.
    vizStore.showPanel(PANEL_ID);
    expect(dbg.visible).toBe(false);
    world.update(0.016);
    expect(dbg.visible).toBe(true);

    // A second update with no divergence leaves it untouched.
    world.update(0.016);
    expect(dbg.visible).toBe(true);
  });

  it('onUpdate is a no-op before any debugger exists', () => {
    bootstrap();
    expect(() => world.update(0.016)).not.toThrow();
  });

  it('unregisters the panel and drops the key listener on shutdown', () => {
    bootstrap();
    world.createEntity().add(new ShadowDebuggerComponent({ activationKey: 'Digit8' }));
    expect(vizStore.panels[PANEL_ID]).toBeDefined();

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

    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'Digit8' }));
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();
  });

  it('unregisters the panel when the owning debugger entity is removed', () => {
    bootstrap();
    const e = world.createEntity();
    e.add(new ShadowDebuggerComponent());
    expect(vizStore.panels[PANEL_ID]).toBeDefined();

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

  it('leaves the active panel alone when an unrelated debugger entity is removed', () => {
    bootstrap();
    world.createEntity().add(new ShadowDebuggerComponent({ position: 'top-left' }));
    // A second, never-adopted debugger entity (system already has this.component).
    const other = world.createEntity();
    other.add(new ShadowDebuggerComponent({ position: 'bottom-right' }));
    expect(vizStore.panels[PANEL_ID].position).toBe('top-left');

    world.removeEntity(other);
    expect(vizStore.panels[PANEL_ID]).toBeDefined();
    expect(vizStore.panels[PANEL_ID].position).toBe('top-left');
  });
});

describe('ShadowDebugger param persistence — swallowed storage errors', () => {
  it('returns defaults when reading malformed JSON does not throw', () => {
    // Corrupt the stored blob → JSON.parse throws → loadParamsFromStorage catch
    // returns {} so DEFAULT_PARAMS win and the panel still registers.
    localStorage.setItem(`${STORAGE_KEY}-default`, '{not json');
    const eventBus = new EventBus();
    const world = new World({ eventBus, renderer: new MockRendererAdapter() });
    world.addSystem(new ShadowDebuggerSystem(eventBus));
    world.createEntity().add(new ShadowDebuggerComponent({ visible: true }));
    world.initialize();

    const panel = vizStore.panels[PANEL_ID];
    const { getAllByRole } = render(() => panel.content() as never);
    expect((getAllByRole('slider') as HTMLInputElement[])[0].value).toBe('0.4');
    world.shutdown();
  });

  it('swallows a setItem failure when persisting params', () => {
    const eventBus = new EventBus();
    const world = new World({ eventBus, renderer: new MockRendererAdapter() });
    world.addSystem(new ShadowDebuggerSystem(eventBus));
    world.createEntity().add(new ShadowDebuggerComponent({ visible: true }));
    world.initialize();

    const setItem = vi
      .spyOn(Storage.prototype, 'setItem')
      .mockImplementation(() => {
        throw new Error('quota exceeded');
      });

    const panel = vizStore.panels[PANEL_ID];
    const { getAllByRole } = render(() => panel.content() as never);
    expect(() =>
      fireEvent.input((getAllByRole('slider') as HTMLInputElement[])[0], {
        target: { value: '0.9' },
      }),
    ).not.toThrow();

    setItem.mockRestore();
    world.shutdown();
  });
});

import { describe, it, expect, beforeEach } from 'vitest';
import {
  ShadowDebuggerComponent,
  ShadowDebuggerInput,
  ShadowDebuggerEvents,
} from './Shadow.viz.tsx';

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

  beforeEach(() => {
    component = new ShadowDebuggerComponent({
      visible: true,
      activationKey: 'Digit7',
      position: 'bottom-left',
    });
  });

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

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

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

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

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

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

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

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

    it('should default to Digit8', () => {
      const comp = new ShadowDebuggerComponent();
      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 ShadowDebuggerComponent({ position: 'top-left' });
      expect(comp.position).toBe('top-left');
    });

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

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

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

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

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

  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-left');
    });

    it('should be reconstructable from serialized data', () => {
      const serialized = component.serialize();
      const reconstructed = new ShadowDebuggerComponent(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 ShadowDebuggerComponent();
      const serialized = defaultComp.serialize();
      expect(serialized.visible).toBe(false);
      expect(serialized.activationKey).toBe('Digit8');
      expect(serialized.position).toBe('top-right');
    });

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

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

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

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

describe('ShadowDebuggerSystem 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 ShadowDebuggerSystem exposes
    const expectedParams = {
      darkness: 0.4,
      bias: 0.001,
      normalBias: 0.0,
      filteringQuality: 2,
      castShadowsGlobal: 1,
      receiveShadowsGlobal: 1,
    };

    // Verify structure
    expect(Object.keys(expectedParams)).toHaveLength(6);
    expect(expectedParams.darkness).toBe(0.4);
    expect(expectedParams.bias).toBe(0.001);
    expect(expectedParams.normalBias).toBe(0.0);
    expect(expectedParams.filteringQuality).toBe(2);
    expect(expectedParams.castShadowsGlobal).toBe(1);
    expect(expectedParams.receiveShadowsGlobal).toBe(1);
  });

  it('should have sensible ranges for darkness', () => {
    // Darkness should be between 0 (no shadow) and 1 (full shadow)
    const darkness = 0.4;
    expect(darkness).toBeGreaterThanOrEqual(0);
    expect(darkness).toBeLessThanOrEqual(1);
  });

  it('should have sensible ranges for bias', () => {
    // Bias should be a small positive number
    const bias = 0.001;
    expect(bias).toBeGreaterThanOrEqual(0);
    expect(bias).toBeLessThanOrEqual(0.1);
  });

  it('should have valid filtering quality values', () => {
    // Quality should be 0-3 (None, Low, Medium, High)
    const quality = 2;
    expect(quality).toBeGreaterThanOrEqual(0);
    expect(quality).toBeLessThanOrEqual(3);
  });
});