// Create the Game model
const Game = mongoose.model('Game', gameSchema);

// Serve static files from the public directory
app.use(express.static(path.join(__dirname, 'public')));

const proxyAddress = 'http://localhost:8080/';
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";

// A function that returns a modified URL for .ts and .wbp files
function getSegmentURL(targetURL) {
  const baseURL = getBaseURL();
  return baseURL + 'segment/' + targetURL.replace('https://', '');
}

// A function that returns a modified URL for .m3u8 files
function getPlaylistURL(targetURL) {
  const baseURL = getBaseURL();
  return baseURL + 'proxy/' + targetURL.replace('https://', '');
}
function getKeyURL(targetURL) {
     const baseURL = getBaseURL();
  return baseURL + 'key/' + targetURL.replace('https://', '')
}

function getHeadersForDomain(domain) {
  const defaultHeaders = {
    'accept': '*/*',
    'accept-encoding': 'gzip, deflate, br',
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36',
    'sec-ch-ua': '"Chromium";v="116", "Not)A;Brand";v="24", "Brave";v="116"',
    'sec-ch-ua-mobile': '?0',
    'sec-ch-ua-platform': 'Windows',
    'sec-fetch-dest': 'empty',
    'sec-fetch-mode': 'cors',
    'sec-fetch-site': 'cross-site',
    'sec-gpc': '1',
  };

  switch(domain) {
    case 'ddy1.cdndac.lol':
    case 'ddy2.cdndac.lol':
    case 'ddy3.cdndac.lol':
        case 'ddy4.cdndac.lol':
        case 'ddy5.cdndac.lol':
        case 'ddh1.cdndac.lol':
    //... other ddy domains
      return {
        ...defaultHeaders,
        'origin': 'https://ddhwebcast4k.xyz',
        'referer': 'https://ddhwebcast4k.xyz/',
      };

    case 'ed-t1.edghst.me':
    case 'ed-t2.edghst.me':
    case 'ed-t3.edghst.me':
    case 'ed-t4.edghst.me':
    case 'ed-n1.edghst.me':
        case 'ed-c1.edghst.me':
      return {
        ...defaultHeaders,
        'origin': 'https://www.nolive.me',
        'referer': 'https://www.nolive.me/',
                'Accept-Encoding': 'identity'
      };
        case 'aes128.seckeyserv.me':
            return {
                ...defaultHeaders,
        'origin': 'https://www.nolive.me',
        'referer': 'https://www.nolive.me/',
                'method': 'GET',
                'authority': 'aes128.seckeyserv.me'
      };
        case 's2.albula.xyz':
            return {
                ...defaultHeaders,
        'origin': 'https://www.sportshub.to',
        'referer': 'https://www.sportshub.to/'
      };
        case 'nflarcadia.xyz':
            return {
                ...defaultHeaders,
        'origin': 'https://gamerarcades.com',
        'referer': 'https://gamerarcades.com/'
      };
        case 'livenflstream.xyz':
            return {
                ...defaultHeaders,
        'origin': 'https://catchystream.com',
        'referer': 'https://catchystream.com/'
      };
        case 's3.twoflow.xyz':
        return {
                ...defaultHeaders,
        'origin': 'https://bestreamsports.org',
        'referer': 'https://bestreamsports.org/'
      };
        case 'n6.aliflailaaliflaila.com':
        return {
                ...defaultHeaders,
        'origin': 'https://fiveyardlab.com',
        'referer': 'https://fiveyardlab.com/'
      };
        case 'jggk.9novel.to':
        return {
                ...defaultHeaders,
        'origin': 'https://vwrc.truyenxalo.com',
        'referer': 'https://vwrc.truyenxalo.com/'
      };
        case 'ddh1.cdnbos.lol' :
        case 'ddh2.cdnbos.lol' :
        case 'ddh3.cdnbos.lol' :
        case 'ddh4.cdnbos.lol' :
        case 'ddh5.cdnbos.lol' :
        case 'ddy1.cdnbos.lol' :
        case 'ddy2.cdnbos.lol' :
        case 'ddy3.cdnbos.lol' :
        case 'ddy4.cdnbos.lol' :
        case 'ddy5.cdnbos.lol' :
        return {
                ...defaultHeaders,
        'origin': 'https://ddolahdplay.xyz',
        'referer': 'https://ddolahdplay.xyz/'
      };
    default:
      return defaultHeaders;
  }
}

function appendQueryParameter(url, paramKey, paramValue) {
    if (url.includes('?')) {
        return `${url}&${paramKey}=${paramValue}`;
    } else {
        return `${url}?${paramKey}=${paramValue}`;
    }
}
function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}
// A new route for handling .m3u8 requests
app.use('/proxy/', async (req, res, next) => {
  const fullURL = req.protocol + '://' + req.get('host') + req.originalUrl;
  const { pathname, search } = new URL(fullURL);
  console.log(`Received request for URL: ${fullURL}`);
  const targetURL = pathname.replace('/proxy/', 'https://') + search;
  const domain = new URL(targetURL).hostname;
  const parsedURL = new URL(targetURL);
  const fileExtension = path.extname(parsedURL.pathname).toLowerCase();
  if (fileExtension === '.m3u8') {
    try {
      const m3u8Response = await fetch(targetURL, { headers: getHeadersForDomain(domain)});
      let m3u8Content = await m3u8Response.text();
      m3u8Content = await Promise.all(m3u8Content.split('\n').map(async line => {
        const segmentParsedURL = new URL(line, targetURL);
        let segmentBaseURL;
        if (segmentParsedURL.pathname.startsWith('/')) {
          segmentBaseURL = parsedURL.origin;
        } else {
          segmentBaseURL = targetURL.substring(0, targetURL.lastIndexOf('/') + 1);
        }
        const segmentURL = line.startsWith('http') ? line : segmentBaseURL + segmentParsedURL.pathname + segmentParsedURL.search;
        const segmentFileExtension = path.extname(segmentParsedURL.pathname).toLowerCase();
        if (segmentFileExtension === '.ts' || segmentFileExtension === '.webp' || segmentFileExtension === '.js') {
          const resolvedURL = await resolveRedirect(segmentURL, getHeadersForDomain(domain));
          const segmentDomain = new URL(segmentURL).host;
          return appendQueryParameter(getSegmentURL(resolvedURL), "originalDomain", segmentDomain);
        } else if (line.match(/\.m3u8$/)) {
          // Add the host domain to the url
          const playlistDomain = new URL(segmentBaseURL).host;
          const playlistURL = line.startsWith('http') ? line : segmentBaseURL + segmentParsedURL.pathname;
          const resolvedURL = await resolveRedirect(playlistURL, getHeadersForDomain(domain));
          return appendQueryParameter(getPlaylistURL(resolvedURL), "originalDomain", playlistDomain);
        } else if (line.startsWith('#EXT-X-KEY')) {
          const keyURLMatch = line.match(/URI="([^"]+)"/);
          if (!keyURLMatch) {
            return line;
          }
          const keyURL = keyURLMatch[1];
          const segmentDomain = new URL(keyURL).host;
          const modifiedKeyURL = appendQueryParameter(getKeyURL(keyURL), "originalDomain", segmentDomain);
          return line.replace(/URI="([^"]+)"/, `URI="${modifiedKeyURL}"`);
        } else {
          return line;
        }
      }));
      m3u8Content = m3u8Content.join('\n');
      res.setHeader('Content-Type', 'application/vnd.apple.mpegurl');
            res.setHeader('Access-Control-Allow-Origin', '*');
      res.send(m3u8Content);
    } catch (err) {
      console.error('Failed to fetch m3u8:', err.message);
      res.status(500).send('Proxy Error');
    }
    return;
  }
});


async function resolveRedirect(url, headers) {
  try {
    const response = await fetch(url, { headers });
    if (response.redirected) {
      return response.url;
    }
    return url;
  } catch (error) {
    console.error('Failed to resolve redirect for', url, error.message);
    return changeExtensionToJs(url);
  }
}

function changeExtensionToJs(url) {
  const withoutExtension = url.substring(0, url.lastIndexOf('.'));
  return `${withoutExtension}.js`;
}

// A new route for handling .ts and .wbp requests
app.use('/segment/*',(req, res) => {
    const originalDomain = req.query.originalDomain;
        delete req.query.originalDomain;
    const headersForDomain = getHeadersForDomain(originalDomain);
    const fullURL = req.protocol + '://' + req.get('host') + req.originalUrl;
    console.log(`Received request for URL: ${fullURL}`);

    // Capture the segment path from the wildcard
    const segmentPath = req.params[0];

    // Construct the targetURL with the captured segment path
    const targetURL = 'https://' + segmentPath;

    // Create a proxyRequestOptions object with the headers copied from the original request
    const proxyRequestOptions = {
        url: targetURL,
        headers: headersForDomain
    };
    const proxyRequest = request(proxyRequestOptions);

    proxyRequest.on('response', function (sourceResponse) {
        res.setHeader('Access-Control-Allow-Origin', '*');
        sourceResponse.pipe(res);
    });
});