/**
 * Resolution route integration test — uses a real ESPN NBA box score
 * fetched from
 *   https://site.api.espn.com/apis/site/v2/sports/basketball/nba/summary?event=401859964
 *
 * Workflow:
 *   1. Mock supabase to return three fake unresolved props that match
 *      players in the real fixture.
 *   2. Drive the resolution route with the real box-score JSON.
 *   3. Assert the actual stats were extracted correctly and the
 *      hit/miss/push verdict matches what the line + direction imply.
 */

const fs = require('fs');
const path = require('path');

process.env.VYNDR_INTERNAL_KEY = 'int-test-key';
process.env.NODE_ENV = 'test';

// Capture writes the route makes for assertion.
const mockState = {
  unresolved: [],
  inserts: [],
  updates: [],
};

jest.mock('../../src/utils/supabase', () => ({
  getSupabaseServiceClient: () => ({
    from(table) {
      const ctx = { table };
      const proxy = {
        select() { return proxy; },
        eq() { return proxy; },
        in() { return Promise.resolve({ error: null }); },
        is() { return Promise.resolve({ data: mockState.unresolved, error: null }); },
        insert(rows) {
          mockState.inserts.push({ table, rows });
          return Promise.resolve({ error: null });
        },
        update(patch) {
          mockState.updates.push({ table, patch });
          // chain to .eq()/.in() — both close out the call with a resolved promise.
          return {
            eq() { return Promise.resolve({ error: null }); },
            in() { return Promise.resolve({ error: null }); },
          };
        },
      };
      return proxy;
    },
  }),
}));

// Distribution services — stubbed configured=false so side effects are no-ops.
jest.mock('../../src/services/distribution/webPush', () => ({
  configured: () => false,
  sendPushToSport: async () => ({ ok: true, sent: 0 }),
}));
jest.mock('../../src/services/distribution/telegram', () => ({
  configured: () => false,
  postToTelegram: async () => ({ ok: true }),
}));
jest.mock('../../src/services/distribution/discord', () => ({
  webhookFor: () => null,
  postToDiscord: async () => ({ ok: true }),
}));

const express = require('express');
const gradingRoutes = require('../../src/routes/grading');

const fixture = JSON.parse(fs.readFileSync(
  path.join(__dirname, '..', 'fixtures', 'nba-boxscore-sample.json'),
  'utf8',
));

// Find a couple of real athletes in the fixture so we can build deterministic
// fake unresolved props. The first team's first athlete is OG Anunoby in the
// saved sample; selecting two players from the fixture removes any need to
// hand-author expected stats — we read them straight from the box.
function pickAthletes(box, n) {
  const out = [];
  for (const team of box.boxscore.players) {
    for (const a of team.statistics[0].athletes) {
      out.push({
        id: String(a.athlete.id),
        name: a.athlete.displayName,
        stats: a.stats,
        starter: !!a.starter,
      });
      if (out.length === n) return out;
    }
  }
  return out;
}

const [p1, p2, p3] = pickAthletes(fixture, 3);
// labels: ['MIN','PTS','FG','3PT','FT','REB','AST','TO','STL','BLK',...]
const p1Points = Number(p1.stats[1]);
const p2Rebounds = Number(p2.stats[5]);
const p3PRA = Number(p3.stats[1]) + Number(p3.stats[5]) + Number(p3.stats[6]);

function makeApp() {
  const app = express();
  app.use(express.json({ limit: '2mb' }));
  app.use('/api/grading', gradingRoutes);
  return app;
}

function request(app, method, url, body, headers = {}) {
  return new Promise((resolve, reject) => {
    const http = require('http');
    const server = app.listen(0, '127.0.0.1', () => {
      const port = server.address().port;
      const data = body ? JSON.stringify(body) : '';
      const req = http.request({
        host: '127.0.0.1',
        port,
        path: url,
        method,
        headers: { 'Content-Type': 'application/json', ...headers },
      }, (res) => {
        const chunks = [];
        res.on('data', (c) => chunks.push(c));
        res.on('end', () => {
          server.close();
          const raw = Buffer.concat(chunks).toString('utf8');
          let parsed; try { parsed = JSON.parse(raw); } catch { parsed = raw; }
          resolve({ status: res.statusCode, body: parsed });
        });
      });
      req.on('error', (err) => { server.close(); reject(err); });
      if (data) req.write(data);
      req.end();
    });
  });
}

beforeEach(() => {
  mockState.unresolved = [];
  mockState.inserts = [];
  mockState.updates = [];
});

describe('POST /api/grading/resolve — auth', () => {
  test('rejects without key', async () => {
    const app = makeApp();
    const res = await request(app, 'POST', '/api/grading/resolve', { gameId: 'g', sport: 'nba' });
    expect(res.status).toBe(401);
  });

  test('rejects from non-loopback (handled in real-world by Express trust proxy)', async () => {
    // We can't easily spoof a non-loopback IP locally; auth covers the
    // primary defense. Leaving this stub so the dependency on the IP check
    // is visible if anyone ever rips it out.
    expect(typeof gradingRoutes.__helpers.requireInternal).toBe('function');
  });
});

describe('POST /api/grading/resolve — real ESPN box', () => {
  test('resolves three props against the real box score, returning correct verdicts', async () => {
    mockState.unresolved = [
      { id: 'gh-1', player_id: p1.id, player_name: p1.name, stat_type: 'points', line: p1Points - 0.5, direction: 'over', grade: 'A-', sport: 'nba', projection: p1Points },
      { id: 'gh-2', player_id: p2.id, player_name: p2.name, stat_type: 'rebounds', line: p2Rebounds + 0.5, direction: 'under', grade: 'B+', sport: 'nba', projection: p2Rebounds },
      { id: 'gh-3', player_id: p3.id, player_name: p3.name, stat_type: 'pts_reb_ast', line: p3PRA + 0.5, direction: 'over', grade: 'C', sport: 'nba', projection: p3PRA },
    ];

    const app = makeApp();
    const res = await request(app, 'POST', '/api/grading/resolve',
      { gameId: '401859964', sport: 'nba', boxScore: fixture },
      { 'X-VYNDR-Internal-Key': 'int-test-key' },
    );

    expect(res.status).toBe(200);
    expect(res.body.resolved + res.body.voided).toBe(3);

    // p1: line is points - 0.5, direction over → actual > line → HIT
    const r1 = res.body.results.find((r) => r.id === 'gh-1');
    expect(r1.actual_value).toBe(p1Points);
    expect(r1.result).toBe('hit');

    // p2: line is rebounds + 0.5, direction under → actual < line → HIT
    const r2 = res.body.results.find((r) => r.id === 'gh-2');
    expect(r2.actual_value).toBe(p2Rebounds);
    expect(r2.result).toBe('hit');

    // p3: combo over, line is sum + 0.5 → actual < line → MISS
    const r3 = res.body.results.find((r) => r.id === 'gh-3');
    expect(r3.actual_value).toBe(p3PRA);
    expect(r3.result).toBe('miss');
  });

  test('marks DNP as void with correction_note', async () => {
    mockState.unresolved = [
      { id: 'dnp', player_id: '999999999', player_name: 'Phantom Player', stat_type: 'points', line: 10.5, direction: 'over', grade: 'C', sport: 'nba' },
    ];
    const app = makeApp();
    const res = await request(app, 'POST', '/api/grading/resolve',
      { gameId: '401859964', sport: 'nba', boxScore: fixture },
      { 'X-VYNDR-Internal-Key': 'int-test-key' },
    );
    expect(res.status).toBe(200);
    expect(res.body.voided).toBe(1);
    expect(res.body.results[0].result).toBe('void');
  });

  test('void: true marks all unresolved props', async () => {
    mockState.unresolved = [
      { id: 'vp-1', player_id: '1', player_name: 'A', stat_type: 'points', line: 10, direction: 'over', grade: 'B', sport: 'nba' },
      { id: 'vp-2', player_id: '2', player_name: 'B', stat_type: 'points', line: 12, direction: 'under', grade: 'C', sport: 'nba' },
    ];
    const app = makeApp();
    const res = await request(app, 'POST', '/api/grading/resolve',
      { gameId: 'pp-game', sport: 'nba', void: true, reason: 'postponed' },
      { 'X-VYNDR-Internal-Key': 'int-test-key' },
    );
    expect(res.status).toBe(200);
    expect(res.body.voided).toBe(2);
  });
});

describe('calculateStat unit cases', () => {
  const { calculateStat } = gradingRoutes.__helpers ?? {};
  const { getSportConfig } = require('../../src/config/sports');

  test('NBA points (index)', () => {
    expect(calculateStat([null, '25', null, null, null], 'points', getSportConfig('nba'))).toBe(25);
  });

  test('NBA threes_made parses makes-attempts string', () => {
    expect(calculateStat([null, null, null, '3-7'], 'threes_made', getSportConfig('nba'))).toBe(3);
    expect(calculateStat([null, null, null, ''], 'threes_made', getSportConfig('nba'))).toBe(0);
    expect(calculateStat([null, null, null, null], 'threes_made', getSportConfig('nba'))).toBe(0);
  });

  test('NBA pts_reb_ast combo', () => {
    const stats = [];
    stats[1] = 22; stats[5] = 9; stats[6] = 5;
    expect(calculateStat(stats, 'pts_reb_ast', getSportConfig('nba'))).toBe(36);
  });

  test('MLB totalBases (mlbField)', () => {
    expect(calculateStat({ totalBases: 4 }, 'totalBases', getSportConfig('mlb'))).toBe(4);
  });

  test('MLB inningsPitched parses "5.1" → 5.33', () => {
    expect(calculateStat({ inningsPitched: '5.1' }, 'inningsPitched', getSportConfig('mlb'))).toBeCloseTo(5.333, 2);
  });

  test('NFL passing_yards (category + field)', () => {
    expect(calculateStat({ passing: { passingYards: 287 } }, 'passing_yards', getSportConfig('nfl'))).toBe(287);
  });

  test('defensive — undefined/null/empty all return 0', () => {
    expect(calculateStat(undefined, 'points', getSportConfig('nba'))).toBe(0);
    expect(calculateStat([], 'points', getSportConfig('nba'))).toBe(0);
    expect(calculateStat({ inningsPitched: null }, 'inningsPitched', getSportConfig('mlb'))).toBe(0);
  });
});