import { runMechanicContract } from '@babylonjsmarket/ecs/testing'
import { LineOfSightComponent, LineOfSightSystem } from './LineOfSight'
import { MeshPrimitiveComponent } from '../MeshPrimitive/MeshPrimitive.core'

runMechanicContract({
  name: 'LineOfSight',
  componentClass: LineOfSightComponent,
  systemClass: LineOfSightSystem,
  sampleInput: { fov: 180, interval: 1 },
  // The system reads its sibling MeshPrimitive for the viewer position.
  companions: [MeshPrimitiveComponent],
  events: {
    // Listens for the debug-rays toggle. ACQUIRED/LOST only fire once a tagged
    // target exists and visibility flips — out of scope for the bare contract.
    input: ['lineofsight.debugrays.set'],
  },
  makeInputPayload: () => ({ enabled: true }),
})

import { describe, it, expect } from 'vitest'
import {
  LineOfSightComponent,
  hasLineOfSight,
  inSightCone,
  rayReaches,
  rayFanEndpoints,
} from './LineOfSight.core'

describe('LineOfSightComponent', () => {
  it('applies defaults', () => {
    const c = new LineOfSightComponent()
    expect(c.targetTag).toBe('player')
    expect(c.fov).toBe(220)
    expect(c.range).toBe(32)
    expect(c.rayCount).toBe(3)
    expect(c.blockRadius).toBe(0.6)
    expect(c.interval).toBe(1.5)
  })

  it('serialize round-trips', () => {
    const a = new LineOfSightComponent({ targetTag: 'hero', fov: 90, range: 12, rayCount: 1, blockRadius: 1, interval: 0.5 })
    const b = new LineOfSightComponent(a.serialize())
    expect(b.targetTag).toBe('hero')
    expect(b.fov).toBe(90)
    expect(b.range).toBe(12)
    expect(b.rayCount).toBe(1)
    expect(b.blockRadius).toBe(1)
    expect(b.interval).toBe(0.5)
  })
})

describe('inSightCone', () => {
  // Viewer at origin facing +X.
  it('sees a target dead ahead', () => {
    expect(inSightCone(0, 0, 1, 0, 10, 0, 220, 100)).toBe(true)
  })

  it('does not see a target behind it (outside the cone)', () => {
    expect(inSightCone(0, 0, 1, 0, -10, 0, 220, 100)).toBe(false)
  })

  it('does not see a target beyond range', () => {
    expect(inSightCone(0, 0, 1, 0, 50, 0, 220, 30)).toBe(false)
  })

  it('is omnidirectional when facing is unknown (zero vector)', () => {
    expect(inSightCone(0, 0, 0, 0, -10, 0, 90, 100)).toBe(true)
  })

  it('is omnidirectional at fov >= 360', () => {
    expect(inSightCone(0, 0, 1, 0, -10, 0, 360, 100)).toBe(true)
  })

  it('respects a narrow cone', () => {
    // 40° cone (half 20°): a target ~45° off-axis is outside.
    expect(inSightCone(0, 0, 1, 0, 10, 10, 40, 100)).toBe(false)
    expect(inSightCone(0, 0, 1, 0, 10, 0, 40, 100)).toBe(true)
  })
})

describe('rayFanEndpoints', () => {
  it('returns one centre endpoint for a single ray', () => {
    const ends = rayFanEndpoints(0, 0, 10, 0, 1, 0.6)
    expect(ends).toHaveLength(1)
    expect(ends[0]![0]).toBeCloseTo(10, 5)
    expect(ends[0]![1]).toBeCloseTo(0, 5)
  })

  it('fans rayCount endpoints across the target width', () => {
    const ends = rayFanEndpoints(0, 0, 10, 0, 3, 0.6)
    expect(ends).toHaveLength(3)
    // Perpendicular to +X sightline is ±Z; spread spans [-0.6, +0.6].
    expect(ends[0]![1]).toBeCloseTo(-0.6, 5)
    expect(ends[2]![1]).toBeCloseTo(0.6, 5)
  })
})

describe('rayReaches', () => {
  it('reaches with no occluders', () => {
    expect(rayReaches(0, 0, 10, 0, [], 0.6)).toBe(true)
  })

  it('is blocked by an occluder on the line', () => {
    expect(rayReaches(0, 0, 10, 0, [{ x: 5, z: 0 }], 0.6)).toBe(false)
  })

  it('passes an occluder off to the side', () => {
    expect(rayReaches(0, 0, 10, 0, [{ x: 5, z: 3 }], 0.6)).toBe(true)
  })

  it('is blocked by a wall box across the line', () => {
    expect(rayReaches(0, 0, 10, 0, [], 0.6, [{ minX: 4, maxX: 6, minZ: -2, maxZ: 2 }])).toBe(false)
  })
})

describe('hasLineOfSight', () => {
  // Viewer at origin facing +X toward a target at (10,0); wide cone + range so
  // these isolate occlusion unless stated.
  const los = (occluders: { x: number; z: number }[], rays = 3, boxes: { minX: number; maxX: number; minZ: number; maxZ: number }[] = []) =>
    hasLineOfSight(0, 0, 1, 0, 10, 0, occluders, rays, 0.6, 360, 100, boxes)

  it('is clear with no occluders', () => {
    expect(los([])).toBe(true)
  })

  it('is blocked by a robot on the sightline', () => {
    expect(los([{ x: 5, z: 0 }])).toBe(false)
  })

  it('peeks past a blocker edge with the fan but not a single ray', () => {
    const grazing = [{ x: 5, z: 0.45 }]
    expect(los(grazing, 3)).toBe(true)
    expect(los(grazing, 1)).toBe(false)
  })

  it('is blocked by a full-height wall across the sightline', () => {
    expect(los([], 3, [{ minX: 4, maxX: 6, minZ: -2, maxZ: 2 }])).toBe(false)
  })

  it('fails when the target is outside the FOV cone', () => {
    // Facing +X but target behind, with a real (non-360) cone.
    expect(hasLineOfSight(0, 0, 1, 0, -10, 0, [], 3, 0.6, 220, 100)).toBe(false)
  })

  it('fails when the target is beyond range', () => {
    expect(hasLineOfSight(0, 0, 1, 0, 50, 0, [], 3, 0.6, 360, 30)).toBe(false)
  })
})

import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
import { EventBus, World, MockRendererAdapter } from '@babylonjsmarket/ecs'
import { LineOfSightSystem } from './LineOfSight'
import { LineOfSightEvents, LineOfSightInputEvents } from './LineOfSight.core'
import { LineOfSightComponent } from './LineOfSight.core'
import { MeshPrimitiveComponent } from '../MeshPrimitive/MeshPrimitive.core'

describe('LineOfSightSystem', () => {
  let eventBus: EventBus
  let world: World
  let renderer: MockRendererAdapter
  let acquired: string[]
  let lost: string[]

  beforeEach(() => {
    // random()=0 → the per-entity check timer starts at 0 and fires on frame 1.
    vi.spyOn(Math, 'random').mockReturnValue(0)
    eventBus = new EventBus()
    renderer = new MockRendererAdapter()
    world = new World({ eventBus, renderer })
    world.addSystem(new LineOfSightSystem(eventBus))
    world.initialize()
    acquired = []
    lost = []
    eventBus.on(LineOfSightEvents.ACQUIRED, (d: { entityId: string }) => acquired.push(d.entityId))
    eventBus.on(LineOfSightEvents.LOST, (d: { entityId: string }) => lost.push(d.entityId))
  })

  afterEach(() => vi.restoreAllMocks())

  function makePlayer(pos: [number, number, number]) {
    const e = world.createEntity()
    const m = new MeshPrimitiveComponent({ primitive: 'capsule', position: pos })
    m.handle = renderer.createMesh(e.id, m.toPrimitiveSpec())
    e.add(m)
    e.addTag('player')
    return e
  }

  function makeSeer(pos: [number, number, number]) {
    const e = world.createEntity()
    const m = new MeshPrimitiveComponent({ primitive: 'sphere', diameter: 1.2, position: pos })
    m.handle = renderer.createMesh(e.id, m.toPrimitiveSpec())
    e.add(m)
    e.add(new LineOfSightComponent({ fov: 360, range: 100, blockRadius: 0.6 }))
    return e
  }

  it('emits acquired when the target is in clear view', () => {
    makePlayer([5, 0.8, 0])
    const seer = makeSeer([0, 0.5, 0])
    world.update(0.016)
    expect(acquired).toContain(seer.id)
    expect(lost).not.toContain(seer.id)
  })

  it('emits lost when another body blocks the sightline', () => {
    makePlayer([10, 0.8, 0])
    makeSeer([5, 0.5, 0]) // blocker, squarely between
    const blocked = makeSeer([0, 0.5, 0])
    world.update(0.016)
    expect(lost).toContain(blocked.id)
  })

  it('updates facing from movement delta as the seer moves', () => {
    makePlayer([5, 0.8, 0])
    const seer = makeSeer([0, 0.5, 0])
    world.update(0.016) // first frame seeds facing px/pz

    // Move the seer enough that the movement delta exceeds the 1e-3 threshold,
    // exercising the facing-normalization branch.
    const m = seer.get(MeshPrimitiveComponent)!
    m.position[0] = 2
    m.position[2] = 1
    world.update(0.016)

    // Sanity: it still sees the player (range/fov are wide open here).
    expect(acquired).toContain(seer.id)
    expect(lost).not.toContain(seer.id)
  })

  it('draws ray helper line systems only when toggled on', () => {
    makePlayer([5, 0.8, 0])
    makeSeer([0, 0.5, 0])
    world.update(0.016)
    expect(renderer.calls.some((c) => c.method === 'createLineSystem')).toBe(false)

    eventBus.emit(LineOfSightInputEvents.SET_DEBUG_RAYS, { enabled: true })
    world.update(0.016)
    expect(renderer.calls.some((c) => c.method === 'createLineSystem')).toBe(true)

    // Toggling off disposes them.
    eventBus.emit(LineOfSightInputEvents.SET_DEBUG_RAYS, { enabled: false })
    world.update(0.016)
    expect(renderer.calls.some((c) => c.method === 'disposeLineSystem')).toBe(true)
  })
})

// @vitest-environment jsdom
/**
 * Tests for the LineOfSight debug panel host.
 *
 * The panel is published as a declarative `PanelSpec` on the EventBus
 * (`VizEvents.PANEL_REGISTERED`) — there is no Solid/JSX rendered here — so we
 * capture the emitted spec and drive every binding's get/set to cover the
 * `all`/`first`/`setAll` query closures and both the populated and fallback
 * (no-component) paths.
 */
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import {
  EventBus,
  World,
  MockRendererAdapter,
  type ControlSpec,
  type PanelSpec,
  type SliderSpec,
  type ToggleSpec,
} from '@babylonjsmarket/ecs';
import { VizEvents } from '@babylonjsmarket/viz';
import {
  LineOfSightDebuggerComponent,
  LineOfSightDebuggerSystem,
} from './LineOfSight.viz.tsx';
import { LineOfSightComponent, LineOfSightInputEvents } from './LineOfSight.core';

// ---------------------------------------------------------------------------
// Component
// ---------------------------------------------------------------------------

describe('LineOfSightDebuggerComponent', () => {
  it('uses defaults when no data provided', () => {
    const c = new LineOfSightDebuggerComponent();
    expect(c.panelId).toBe('line-of-sight');
    expect(c.visible).toBe(false);
    expect(c.activationKey).toBe('');
    expect(c.position).toBe('top-right');
  });

  it('honours provided input', () => {
    const c = new LineOfSightDebuggerComponent({
      visible: true,
      activationKey: 'Digit5',
      position: 'bottom-left',
    });
    expect(c.visible).toBe(true);
    expect(c.activationKey).toBe('Digit5');
    expect(c.position).toBe('bottom-left');
    // panelId is fixed regardless of input.
    expect(c.panelId).toBe('line-of-sight');
  });

  it('round-trips through serialize()', () => {
    const c = new LineOfSightDebuggerComponent({
      visible: true,
      activationKey: 'Digit5',
      position: 'bottom-right',
    });
    const serialized = c.serialize();
    expect(serialized).toEqual({
      panelId: 'line-of-sight',
      visible: true,
      activationKey: 'Digit5',
      position: 'bottom-right',
    });
    const restored = new LineOfSightDebuggerComponent(serialized);
    expect(restored.visible).toBe(c.visible);
    expect(restored.activationKey).toBe(c.activationKey);
    expect(restored.position).toBe(c.position);
  });

  it('serializes default values', () => {
    const serialized = new LineOfSightDebuggerComponent().serialize();
    expect(serialized).toEqual({
      panelId: 'line-of-sight',
      visible: false,
      activationKey: '',
      position: 'top-right',
    });
  });
});

// ---------------------------------------------------------------------------
// System / spec
// ---------------------------------------------------------------------------

/** Flatten a panel spec's sections to a single control list. */
function controls(spec: PanelSpec): ControlSpec[] {
  return spec.sections.flatMap((s) => s.controls);
}

function findSlider(spec: PanelSpec, label: string): SliderSpec {
  const ctrl = controls(spec).find(
    (c): c is SliderSpec => c.kind === 'slider' && c.label === label,
  );
  if (!ctrl) throw new Error(`slider not found: ${label}`);
  return ctrl;
}

function findToggle(spec: PanelSpec, label: string): ToggleSpec {
  const ctrl = controls(spec).find(
    (c): c is ToggleSpec => c.kind === 'toggle' && c.label === label,
  );
  if (!ctrl) throw new Error(`toggle not found: ${label}`);
  return ctrl;
}

describe('LineOfSightDebuggerSystem', () => {
  let eventBus: EventBus;
  let world: World;
  let registered: PanelSpec[];
  let unregistered: string[];

  beforeEach(() => {
    eventBus = new EventBus();
    world = new World({ eventBus, renderer: new MockRendererAdapter() });
    registered = [];
    unregistered = [];
    eventBus.on(VizEvents.PANEL_REGISTERED, (d: { spec: PanelSpec }) =>
      registered.push(d.spec),
    );
    eventBus.on(VizEvents.PANEL_UNREGISTERED, (d: { id: string }) =>
      unregistered.push(d.id),
    );
  });

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

  /** Register the panel with N line-of-sight entities present, return its spec. */
  function bootPanel(
    losInputs: ConstructorParameters<typeof LineOfSightComponent>[0][] = [],
    debuggerInput = {},
  ): PanelSpec {
    for (const input of losInputs) {
      world.createEntity().add(new LineOfSightComponent(input));
    }
    world.addSystem(new LineOfSightDebuggerSystem(eventBus));
    world
      .createEntity()
      .add(new LineOfSightDebuggerComponent(debuggerInput));
    world.initialize();
    world.update(0.016);
    expect(registered.length).toBeGreaterThan(0);
    return registered[registered.length - 1];
  }

  it('publishes a panel spec on the bus once the config entity exists', () => {
    const spec = bootPanel([{}]);
    expect(spec.id).toBe('line-of-sight');
    expect(spec.title).toBe('Line of Sight');
    expect(spec.titleColor).toBe('#7fd0ff');
    expect(spec.sections.map((s) => s.title)).toEqual(['Vision', 'Debug']);
  });

  it('applies the config component position / activationKey / visibility', () => {
    const spec = bootPanel([{}], {
      position: 'bottom-left',
      activationKey: 'Digit5',
      visible: true,
    });
    expect(spec.position).toBe('bottom-left');
    expect(spec.activationKey).toBe('Digit5');
    expect(spec.visibleByDefault).toBe(true);
  });

  it('reads slider values from the first live LineOfSight component', () => {
    const spec = bootPanel([
      {
        fov: 180,
        range: 40,
        rayCount: 5,
        blockRadius: 1.2,
        interval: 2,
      },
      { fov: 90 }, // a second (pooled) enemy — first() must read the first one
    ]);
    expect(findSlider(spec, 'FOV (deg)').bind.get()).toBe(180);
    expect(findSlider(spec, 'range').bind.get()).toBe(40);
    expect(findSlider(spec, 'ray count').bind.get()).toBe(5);
    expect(findSlider(spec, 'block radius').bind.get()).toBe(1.2);
    expect(findSlider(spec, 'check interval (s)').bind.get()).toBe(2);
  });

  it('writes slider values to ALL live LineOfSight components', () => {
    const spec = bootPanel([{}, {}]);
    const losComps = world
      .getEntitiesWithComponent(LineOfSightComponent)
      .map((e) => e.get(LineOfSightComponent)!);
    expect(losComps).toHaveLength(2);

    findSlider(spec, 'FOV (deg)').bind.set!(120);
    findSlider(spec, 'range').bind.set!(50);
    findSlider(spec, 'ray count').bind.set!(4.6); // Math.round() applied
    findSlider(spec, 'block radius').bind.set!(0.9);
    findSlider(spec, 'check interval (s)').bind.set!(3);

    for (const c of losComps) {
      expect(c.fov).toBe(120);
      expect(c.range).toBe(50);
      expect(c.rayCount).toBe(5); // round(4.6)
      expect(c.blockRadius).toBe(0.9);
      expect(c.interval).toBe(3);
    }
  });

  it('falls back to defaults when no LineOfSight component exists', () => {
    // Register the panel with NO LineOfSight entities — first() returns the
    // fallback for every getter and setAll() iterates an empty list (no-op).
    const spec = bootPanel([]);
    expect(findSlider(spec, 'FOV (deg)').bind.get()).toBe(220);
    expect(findSlider(spec, 'range').bind.get()).toBe(32);
    expect(findSlider(spec, 'ray count').bind.get()).toBe(3);
    expect(findSlider(spec, 'block radius').bind.get()).toBe(0.6);
    expect(findSlider(spec, 'check interval (s)').bind.get()).toBe(1.5);

    // setAll on an empty list must not throw.
    expect(() => findSlider(spec, 'FOV (deg)').bind.set!(99)).not.toThrow();
  });

  it('show-rays toggle reads/writes drawRays and emits SET_DEBUG_RAYS', () => {
    const spec = bootPanel([{}]);
    const toggle = findToggle(spec, 'show rays');

    const events: Array<{ enabled: boolean }> = [];
    eventBus.on(LineOfSightInputEvents.SET_DEBUG_RAYS, (d: { enabled: boolean }) =>
      events.push(d),
    );

    expect(toggle.bind.get()).toBe(false);

    toggle.bind.set!(true);
    expect(toggle.bind.get()).toBe(true);
    expect(events).toEqual([{ enabled: true }]);

    toggle.bind.set!(false);
    expect(toggle.bind.get()).toBe(false);
    expect(events).toEqual([{ enabled: true }, { enabled: false }]);
  });

  it('binds carry persist keys for localStorage round-tripping', () => {
    const spec = bootPanel([{}]);
    expect(findSlider(spec, 'FOV (deg)').bind.persist).toBe('fov');
    expect(findSlider(spec, 'range').bind.persist).toBe('range');
    expect(findSlider(spec, 'ray count').bind.persist).toBe('rayCount');
    expect(findSlider(spec, 'block radius').bind.persist).toBe('blockRadius');
    expect(findSlider(spec, 'check interval (s)').bind.persist).toBe('interval');
    expect(findToggle(spec, 'show rays').bind.persist).toBe('showRays');
  });

  it('unpublishes the panel on world shutdown', () => {
    bootPanel([{}]);
    expect(unregistered).toEqual([]);
    world.shutdown();
    expect(unregistered).toEqual(['line-of-sight']);
  });
});