server.ts

import express from "express";
import path from "path";
import { createServer as createViteServer } from "vite";

const MOCK_GAMES = [
  {
    id: "g1",
    title: "Cyberpunk 2077",
    publisher: "CD PROJEKT RED",
    imageUrl: "https://images.igdb.com/igdb/image/upload/t_cover_big/co1r7f.jpg"
  },
  {
    id: "g2",
    title: "The Witcher 3: Wild Hunt",
    publisher: "CD PROJEKT RED",
    imageUrl: "https://images.igdb.com/igdb/image/upload/t_cover_big/co1wyy.jpg"
  },
  {
    id: "g3",
    title: "Apex Legends",
    publisher: "Electronic Arts",
    imageUrl: "https://images.igdb.com/igdb/image/upload/t_cover_big/co1x70.jpg"
  },
  {
    id: "g4",
    title: "Destiny 2",
    publisher: "Bungie",
    imageUrl: "https://images.igdb.com/igdb/image/upload/t_cover_big/co1oj8.jpg"
  },
  {
    id: "g5",
    title: "No Man's Sky",
    publisher: "Hello Games",
    imageUrl: "https://images.igdb.com/igdb/image/upload/t_cover_big/co1vyv.jpg"
  },
  {
    id: "g6",
    title: "Baldur's Gate 3",
    publisher: "Larian Studios",
    imageUrl: "https://images.igdb.com/igdb/image/upload/t_cover_big/co670h.jpg"
  },
  {
    id: "g7",
    title: "Starfield",
    publisher: "Bethesda Softworks",
    imageUrl: "https://images.igdb.com/igdb/image/upload/t_cover_big/co6jof.jpg"
  },
  {
    id: "g8",
    title: "Counter-Strike 2",
    publisher: "Valve",
    imageUrl: "https://images.igdb.com/igdb/image/upload/t_cover_big/co6ntt.jpg"
  }
];

import crypto from "crypto";

const authSessions = new Map<string, {
  codeVerifier: string;
  status: 'PENDING' | 'SUCCESS' | 'FAILED';
  tokens?: any;
}>();

let mockSettings = {
  streamResolution: "4K (3840x2160)",
  frameRate: "120 FPS",
  serverLocation: "EU West",
  hdr: true,
  reflex: true
};

async function startServer() {
  const app = express();
  const PORT = 3000;

  app.use(express.json());

  // --- Real Auth Flow ---
  app.get("/api/auth/real/start", (req, res) => {
    const sessionId = crypto.randomUUID();
    const codeVerifier = crypto.randomBytes(32).toString('base64url');

    authSessions.set(sessionId, {
      codeVerifier,
      status: 'PENDING'
    });

    const protocol = req.headers['x-forwarded-proto'] || req.protocol;
    const host = req.headers.host;
    
    // The URL for the QR code
    const mobileLink = `${protocol}://${host}/api/auth/real/mobile?sessionId=${sessionId}`;

    res.json({ sessionId, qrUrl: mobileLink });
  });

  app.get('/api/auth/real/mobile', (req, res) => {
    const { sessionId } = req.query;
    if (!sessionId || !authSessions.has(sessionId as string)) {
      return res.status(400).send("Invalid session");
    }

    const session = authSessions.get(sessionId as string)!;
    const codeChallenge = crypto.createHash('sha256').update(session.codeVerifier).digest('base64url');

    const protocol = req.headers['x-forwarded-proto'] || req.protocol;
    const host = req.headers.host;
    const redirectUri = `${protocol}://${host}/api/auth/real/callback`;

    const params = new URLSearchParams({
      client_id: 'ZU7sPN-miLujMD95LfOQ453IB0AtjM8sMyvgJ9wCXEQ',
      redirect_uri: redirectUri,
      response_type: 'code',
      scope: 'openid consent email tk_client age',
      code_challenge: codeChallenge,
      code_challenge_method: 'S256',
      state: sessionId as string
    });

    res.redirect(`https://login.nvidia.com/authorize?${params.toString()}`);
  });

  app.get('/api/auth/real/callback', async (req, res) => {
    const { code, state, error } = req.query;
    
    if (error || !code || !state) {
      if (state && authSessions.has(state as string)) {
        authSessions.get(state as string)!.status = 'FAILED';
      }
      return res.send(`Authentication failed: ${error}`);
    }

    const session = authSessions.get(state as string);
    if (!session) {
      return res.status(400).send("Session not found or expired");
    }

    const protocol = req.headers['x-forwarded-proto'] || req.protocol;
    const host = req.headers.host;
    const redirectUri = `${protocol}://${host}/api/auth/real/callback`;

    try {
      const tokenRes = await fetch('https://login.nvidia.com/token', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        },
        body: new URLSearchParams({
          client_id: 'ZU7sPN-miLujMD95LfOQ453IB0AtjM8sMyvgJ9wCXEQ',
          grant_type: 'authorization_code',
          code: code as string,
          redirect_uri: redirectUri,
          code_verifier: session.codeVerifier 
        }).toString()
      });

      if (!tokenRes.ok) {
        const err = await tokenRes.text();
        session.status = 'FAILED';
        return res.status(400).send(`Token exchange failed: ${err}`);
      }

      const tokens = await tokenRes.json();
      session.status = 'SUCCESS';
      session.tokens = tokens;

      res.send(`
        <html>
          <head>
            <title>Login Successful</title>
            <meta name="viewport" content="width=device-width, initial-scale=1">
            <style>
              body { font-family: sans-serif; background: #0f1011; color: white; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; }
              .box { text-align: center; background: #1a1c1e; padding: 2rem; border-radius: 12px; }
              h1 { color: #76b900; }
            </style>
          </head>
          <body>
            <div class="box">
              <h1>Login Successful!</h1>
              <p>You can close this tab and return to the TV.</p>
            </div>
          </body>
        </html>
      `);
    } catch (e: any) {
      session.status = 'FAILED';
      res.send(`Token exchange error: ${e.message}`);
    }
  });

  app.get('/api/auth/real/status', (req, res) => {
    const { sessionId } = req.query;
    const session = authSessions.get(sessionId as string);
    if (!session) {
      return res.json({ status: 'NOT_FOUND' });
    }
    res.json({
      status: session.status,
      tokens: session.tokens
    });
  });
  // --- End Real Auth Flow ---

  // --- OpenNOW Backend simulation ---

  // Auth/User state (Mocked for Preview)
  app.get("/api/auth/session", (req, res) => {
    res.json({
      authenticated: true,
      user: {
        username: "PreviewUser_77",
        membership: "Ultimate",
        hoursPlayed: 142
      }
    });
  });

  // Fetch games
  app.get("/api/games/featured", (req, res) => {
    res.json({
      categories: [
        {
          title: "Play It Now",
          games: MOCK_GAMES.slice(0, 4)
        },
        {
          title: "Free-to-Play",
          games: [MOCK_GAMES[2], MOCK_GAMES[3], MOCK_GAMES[7]]
        },
        {
          title: "Popular RPGs",
          games: [MOCK_GAMES[0], MOCK_GAMES[1], MOCK_GAMES[5], MOCK_GAMES[6]]
        }
      ]
    });
  });

  // Stream Settings API
  app.get("/api/settings", (req, res) => {
    res.json(mockSettings);
  });

  app.post("/api/settings", (req, res) => {
    mockSettings = { ...mockSettings, ...req.body };
    res.json({ success: true, settings: mockSettings });
  });

  // CloudMatch Simulation (Launch session)
  app.post("/api/session/launch", (req, res) => {
    const { gameId } = req.body;
    const game = MOCK_GAMES.find(g => g.id === gameId);
    
    if (!game) {
      return res.status(404).json({ error: "Game not found" });
    }

    // Simulate CloudMatch connection negotiation time
    setTimeout(() => {
      res.json({
        success: true,
        sessionUrl: `rtsp://prod.cloudmatchbeta.nvidiagrid.net/v2/session/${gameId}_preview`,
        hardware: "RTX 4080 Super",
        resolution: mockSettings.streamResolution
      });
    }, 1500);
  });

  // --- End OpenNOW backend ---

  // Vite middleware for development
  if (process.env.NODE_ENV !== "production") {
    const vite = await createViteServer({
      server: { middlewareMode: true },
      appType: "spa",
    });
    app.use(vite.middlewares);
  } else {
    const distPath = path.join(process.cwd(), 'dist');
    app.use(express.static(distPath));
    app.get('*all', (req, res) => {
      res.sendFile(path.join(distPath, 'index.html'));
    });
  }

  app.listen(PORT, "0.0.0.0", () => {
    console.log(`OpenNOW TV server running on http://localhost:${PORT}`);
  });
}

startServer();