1
import db from '@/lib/db';
2
import { streamers } from '@/lib/schema';
3
import { NextResponse } from 'next/server';
4
import { getTwitchToken } from '../utils';
5

6
async function validateToken(token: string) {
7
  const response = await fetch('https://id.twitch.tv/oauth2/validate', {
8
    headers: {
9
      Authorization: `OAuth ${token}`,
10
    },
11
  });
12

13
  if (!response.ok) {
14
    console.error('Token validation failed:', await response.text());
15
    return false;
16
  }
17

18
  return true;
19
}
20

21
async function fetchStreamerBatch(usernames: string[], initialToken: string) {
22
  let token = initialToken;
23
  const isValid = await validateToken(token);
24
  if (!isValid) {
25
    console.log('Token invalid, attempting to get new token...');
26
    token = await getTwitchToken();
27
    if (!token) {
28
      throw new Error(
29
        'Failed to get new Twitch token after validation failure'
30
      );
31
    }
32
  }
33

34
  const queryString = usernames.map((name) => `user_login=${name}`).join('&');
35

36
  console.log(
37
    `Attempting Twitch API call with token: ${token.substring(0, 10)}...`
38
  );
39

40
  const response = await fetch(
41
    `https://api.twitch.tv/helix/streams?${queryString}`,
42
    {
43
      headers: {
44
        'Client-ID': process.env.TWITCH_CLIENT_ID!,
45
        Authorization: `Bearer ${token}`,
46
      },
47
      cache: 'no-store',
48
    }
49
  );
50

51
  if (!response.ok) {
52
    const errorText = await response.text();
53
    throw new Error(
54
      `Twitch API error: ${response.status} - ${errorText}. Client ID: ${process.env.TWITCH_CLIENT_ID?.substring(0, 5)}...`
55
    );
56
  }
57

58
  return (await response.json()).data;
59
}
60

61
export async function GET(request: Request) {
62
  try {
63
    const [allStreamers, token] = await Promise.all([
64
      db
65
        .select({
66
          id: streamers.id,
67
          name: streamers.name,
68
          twitchUrl: streamers.twitchUrl,
69
          isSweat: streamers.isSweat,
70
          avatarUrl: streamers.avatarUrl,
71
        })
72
        .from(streamers),
73
      getTwitchToken(),
74
    ]);
75

76
    if (!token) {
77
      console.error('Token retrieval failed');
78
      throw new Error(
79
        'Failed to get Twitch token - token is null or undefined'
80
      );
81
    }
82

83
    const usernames = allStreamers
84
      .map((streamer) => streamer.twitchUrl?.split('/').pop())
85
      .filter((username): username is string => !!username);
86

87
    const OPTIMIZED_BATCH_SIZE = 100;
88
    const batchPromises = Array.from(
89
      { length: Math.ceil(usernames.length / OPTIMIZED_BATCH_SIZE) },
90
      (_, i) => {
91
        const start = i * OPTIMIZED_BATCH_SIZE;
92
        const batchUsernames = usernames.slice(
93
          start,
94
          start + OPTIMIZED_BATCH_SIZE
95
        );
96
        return fetchStreamerBatch(batchUsernames, token);
97
      }
98
    );
99

100
    const streamDataArrays = await Promise.all(batchPromises);
101
    const streamData = streamDataArrays.flat();
102

103
    const streamDataMap = new Map(
104
      streamData.map((stream) => [stream.user_login.toLowerCase(), stream])
105
    );
106

107
    const liveStreamers = allStreamers
108
      .map((streamer) => {
109
        if (!streamer.twitchUrl) {
110
          return null;
111
        }
112

113
        const twitchUsername = streamer.twitchUrl
114
          .split('/')
115
          .pop()
116
          ?.toLowerCase();
117
        if (!twitchUsername) {
118
          return null;
119
        }
120

121
        const twitchData = streamDataMap.get(twitchUsername);
122
        if (!twitchData) {
123
          return null;
124
        }
125

126
        return {
127
          id: streamer.id,
128
          name: streamer.name,
129
          twitchUrl: streamer.twitchUrl,
130
          isSweat: streamer.isSweat,
131
          avatarUrl: streamer.avatarUrl,
132
          viewerCount: twitchData.viewer_count,
133
          live: twitchData.type === 'live',
134
          gameName: twitchData.game_name,
135
        };
136
      })
137
      .filter(
138
        (streamer): streamer is NonNullable<typeof streamer> =>
139
          streamer !== null
140
      );
141

142
    return NextResponse.json(liveStreamers, {
143
      headers: {
144
        'Cache-Control': 'public, s-maxage=300, stale-while-revalidate=60',
145
      },
146
    });
147
  } catch (error) {
148
    console.error('Detailed error in streamer fetch:', error);
149
    return NextResponse.json(
150
      {
151
        error:
152
          error instanceof Error
153
            ? error.message
154
            : 'Failed to fetch streamer status',
155
      },
156
      { status: 500 }
157
    );
158
  }
159
}