// Session 43 — depth chart / lineup / cascade foundation. Sources injected.

const svc = require('../../src/services/depthChartService');

describe('getLineup (MLB, injected schedule)', () => {
  const mlbAdapter = {
    async getScheduleWithPitchers() {
      return [{
        home: { team: 'Atlanta Braves', probablePitcher: { name: 'Spencer Strider' } },
        away: { team: 'Philadelphia Phillies', probablePitcher: { name: 'Zack Wheeler' } },
      }];
    },
  };

  it('returns the probable starting pitcher for the team', async () => {
    const r = await svc.getLineup('mlb', 'Atlanta', { mlbAdapter, date: '2026-06-18' });
    expect(r).toHaveLength(1);
    expect(r[0]).toMatchObject({ player: 'Spencer Strider', position: 'SP' });
  });

  it('returns [] when the team is not playing / unknown', async () => {
    expect(await svc.getLineup('mlb', 'Seattle', { mlbAdapter, date: '2026-06-18' })).toEqual([]);
    expect(await svc.getLineup('mlb', '', { mlbAdapter })).toEqual([]);
  });

  it('degrades to [] when the adapter throws', async () => {
    const bad = { async getScheduleWithPitchers() { throw new Error('down'); } };
    expect(await svc.getLineup('mlb', 'Atlanta', { mlbAdapter: bad })).toEqual([]);
  });
});

describe('getDepthChart', () => {
  it('builds positions with starter/backup/third from an injected roster', async () => {
    const chart = await svc.getDepthChart('nba', 'SA', {
      roster: [
        { player: 'Wembanyama', position: 'C', depth: 1 },
        { player: 'Backup Big', position: 'C', depth: 2 },
        { player: 'Vassell', position: 'SG', depth: 1 },
      ],
    });
    const center = chart.positions.find((p) => p.position === 'C');
    expect(center.starter).toBe('Wembanyama');
    expect(center.backup).toBe('Backup Big');
  });

  it('returns a valid empty structure when no roster source', async () => {
    const chart = await svc.getDepthChart('mlb', 'ATL');
    expect(chart).toEqual({ sport: 'mlb', team: 'ATL', positions: [] });
  });
});

describe('getCascadeProjection', () => {
  it('distributes usage to teammates, weighting usage sponges heaviest', async () => {
    const r = await svc.getCascadeProjection('nba', 'Keldon Murray', 'SA', {
      teammates: [
        { player: 'Wembanyama', archetype: 'TORCH' },
        { player: 'Bench Spark', archetype: 'SURGE' },
        { player: 'Glue Guy', archetype: 'CONNECTOR' },
      ],
    });
    expect(r).toHaveLength(3);
    // usage sponge gets the biggest bump
    expect(r[0].player).toBe('Bench Spark');
    expect(r[0].delta.startsWith('+')).toBe(true);
    expect(r[0].reason).toContain('OUT');
  });

  it('returns [] with no teammates / no player', async () => {
    expect(await svc.getCascadeProjection('nba', 'X', 'SA', { teammates: [] })).toEqual([]);
    expect(await svc.getCascadeProjection('nba', '', 'SA')).toEqual([]);
  });
});