const yts = require('yt-search');
const morgan = require('morgan');
const express = require('express');
const ytdl = require('ytdl-core');
const { Writable, pipeline } = require('stream');
const util = require('util');
const axios = require('axios');
const FormData = require('form-data')
const cp = require('child_process')
const os = require('os')
const cheerio = require('cheerio')
const cloudscraper = require('cloudscraper')
const acrcloud = require("acrcloud");
const { File } = require('megajs')
const { BingChat } = require("bing-chat-cjs-rnz");
const path = require("path")
const fs = require("fs")
const ytdlp = require('yt-dlp-exec');
let fetch;

(async () => {
fetch = (await import('node-fetch')).default;
})();

// Regex untuk mengidentifikasi URL YouTube dan Mega
const ytIdRegex = /(?:https?:\/\/)?(?:www\.|music\.)?(?:youtube\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|\S*?[?&]v=|shorts\/|user\/\S+\/\S+\/)|youtu\.be\/)([\w-]{11})/;

// Fungsi untuk melakukan HTTP POST request
const post = async (url, form, headers = {}) => {
const response = await fetch(url, {
method: 'post',
body: new URLSearchParams(form),
headers
});
return response;
};

// isURL
function isUrl(url) {
let regex = new RegExp(/(https?:\/\/)?(www\.)?[-a-zA-Z0-9@:%.+~#=]{1,256}\.[a-zA-Z0-9()]{1,9}\b([-a-zA-Z0-9()@:%+.~#?&//=]*)/, 'gi');
if (!regex.test(url)) return false;
return url?.match(regex);
}

//RANDOM
function generateRandomUserAgent() {
const androidVersions = ['4.0.3', '4.1.1', '4.2.2', '4.3', '4.4', '5.0.2', '5.1', '6.0', '7.0', '8.0', '9.0', '10.0', '11.0', '12.0', '13.0'];
const deviceModels = ['M2004J19C', 'S2020X3', 'Xiaomi4S', 'RedmiNote9', 'SamsungS21', 'GooglePixel5', 'iPhone13,4', 'SM-A526B', 'SM-G991B', 'SM-G998B', 'iPhone13,2', 'iPhone13,3', 'iPhone13,1', 'SM-G996B', 'SM-G970F'];
const buildVersions = ['RP1A.200720.011', 'RP1A.210505.003', 'RP1A.210812.016', 'QKQ1.200114.002', 'RQ2A.210505.003', 'RQ3A.211001.001', 'SD1A.210817.036', 'T825YDXU3CTK1', 'QKQ1.191014.012', 'QKQ1.190918.001', 'QKQ1.190626.002', 'QKQ1.190716.003', 'QKQ1.190626.002', 'QKQ1.190626.002', 'QKQ1.190626.002'];
const browsers = ['Chrome', 'Firefox', 'Safari', 'Edge', 'Opera'];

const getRandomElement = (arr) => arr[Math.floor(Math.random() * arr.length)];
const getRandomNumber = (max) => Math.floor(Math.random() * max) + 1;

const selectedModel = getRandomElement(deviceModels);
const selectedBuild = getRandomElement(buildVersions);
const selectedBrowser = getRandomElement(browsers);
const browserVersion = `${selectedBrowser}/${getRandomNumber(96)}.${getRandomNumber(999)}.${getRandomNumber(9999)}.${getRandomNumber(99)}`;
const userAgent = `Mozilla/5.0 (Linux; Android ${getRandomElement(androidVersions)}; ${selectedModel} Build/${selectedBuild}) AppleWebKit/537.36 (KHTML, like Gecko) ${browserVersion} Mobile Safari/537.36`;

return userAgent;
}
function generateRandomIP() {
return Array(4)
.fill(0)
.map(() => Math.floor(Math.random() * 256))
.join('.');
}
//BIMG
async function bimg(query) {
const { BingApi } = await import("bing-nodejs");
const bing = new BingApi({
cookie: process.env.BING_IMAGE_COOKIE
});
let data = await bing.createImage(query).then((res) => {
return res.urls; // string[]
});

// Filter out links that end with '.svg'
let filteredData = data.filter(i => !i.includes('.svg'));
return filteredData
}
async function bingChat(text) {
const api = new BingChat({
cookie: process.env.BING_IMAGE_COOKIE
})
const res = await api.sendMessage(text, { variant: 'Precise' })
return res?.text
}

async function acrCloud(buffer) {
let { mime } = await (await import('file-type')).fileTypeFromBuffer(buffer);
if (/audio|video/.test(mime)) {
const wow = new acrcloud({
host: "identify-ap-southeast-1.acrcloud.com",
access_key: "b1cc283b4fb72483ebb6ea9c53512331",
access_secret: "xyqJGTZRTrUotaraHEjji00WBClx7RpWozywdANq"
});
let { status, metadata } = await wow.identify(buffer);
if (status.code !== 0) throw new Error(status.msg);
//console.log(metadata.music[0])
return metadata.music[0];
} else {
throw new Error('Error: only audio/video files are supported');
}
}

// MEDIAFIRE DL
async function mediafire(url) {
  return new Promise(async (resolve, reject) => {
      var a, b;
      if (!/https?:\/\/(www\.)?mediafire.com/.test(url)) return resolve();
      try {
          const data = await axios.get(url, {
              headers: {
                  'User-Agent': generateRandomUserAgent(),
                  'X-Forwarded-For': generateRandomIP(),
              }
          });
          if (!data) {
              resolve();
          } else {
              const $ = cheerio.load(data.data);
              const Url = ($('#downloadButton').attr('href') || '').trim();
              const url2 = ($('#download_link > a.retry').attr('href') || '').trim();
              const $intro = $('div.dl-info > div.intro');
              const filename = $intro.find('div.filename').text().trim();
              const filetype = $intro.find('div.filetype > span').eq(0).text().trim();
              const ext = ((b = (a = /(.+?)\s*(?:\(|$)/.exec($intro.find('div.filetype > span').eq(1).text())) === null || a === void 0 ? void 0 : a[1]) === null || b === void 0 ? void 0 : b.trim()) || 'bin';
              const $li = $('div.dl-info > ul.details > li');
              const upload_date = $li.eq(1).find('span').text().trim();
              const filesize = $li.eq(0).find('span').text().trim();
              const filesizeB = formatSize(filesize);
              const result = {
                  url: Url || url2,
                  url2,
                  filename,
                  filetype,
                  ext,
                  upload_date,
                  filesize,
                  filesizeB
              };
              resolve(result);
          }
      } catch (error) {
          reject(error);
      }
  });
}


//SAVEIG
async function igdl(query) {
url_dl = [];
let headers = {
'Accept': '/',
'Accept-Language': 'en-US,en;q=0.9',
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
'Referer': 'https://saveig.app/',
'Referrer-Policy': 'strict-origin-when-cross-origin',
'X-Requested-With': 'XMLHttpRequest'
}
let options = {
method: 'POST',
uri: 'https://saveig.app/api/ajaxSearch',
headers: headers,
formData: {
q: query
}
}
ch = cheerio.load(JSON.parse(await cloudscraper(options)).data);
ch('.download-items__btn').each(function(a,b) { url_dl.push(ch(b).find('a').attr('href'))})
return url_dl;
}

//FBDL
async function fby2mate(url) {
  try {
      let form = new FormData();
      form.append('q', url);
      form.append('vt', 'facebook');
      let data = await fetch('https://y2mate.mx/api/ajaxSearch/facebook', {
          method: 'POST',
          body: form,
          headers: {
              'User-Agent': generateRandomUserAgent(),
              'X-Forwarded-For': generateRandomIP(),
              ...form.getHeaders()
          }
      });
      data = await data.json();
      return data;
  } catch (e) {
      return e;
  }
}

async function ytAPI(url) {
  try {
    // Fetch the video info
    const info = await ytdlp.getInfo(url);

    // Extract necessary information
    const videoDetails = {
      title: info.title,
      url: url,
      formats: info.formats.map(format => ({
        format_id: format.format_id,
        ext: format.ext,
        resolution: format.resolution,
        url: format.url
      }))
    };

    // Filter MP4 and MP3 formats
    const mp4Format = videoDetails.formats.find(format => format.ext === 'mp4');
    const mp3Format = videoDetails.formats.find(format => format.ext === 'mp3');

    const result = {
      title: videoDetails.title,
      url: videoDetails.url,
      mp4Url: mp4Format ? mp4Format.url : null,
      mp3Url: mp3Format ? mp3Format.url : null
    };

    return result;
  } catch (error) {
    console.error('Error fetching video info:', error);
    throw error;
  }
}


// Fungsi untuk mengkonversi video dari YouTube
const convert = async (url, v_id, ftype, fquality, fname, token, timeExpire) => {
let params = {
v_id,
ftype,
fquality,
fname,
token,
timeExpire,
client: 'yt5s.com'
};

// Mengirim permintaan konversi
let resServer = await (await post(url, params, { 'x-requested-key': 'de0cfuirtgf67a' })).json();
let server = resServer.c_server;

// Jika tidak ada server dan tipe file adalah mp3, kembalikan null
if (!server && ftype === 'mp3') return server || resServer.d_url || '';

// Mengambil data hasil konversi
let data = await (await post(`${server}/api/json/convert`, params)).json();
let result;

// Memeriksa status kode hasil konversi
if (data.statusCode === 200) result = data.result;
while (!result) {
    let json = await (await post(`${server}/api/json/convert`, params)).json();
    if (json.statusCode === 200) {
        result = json.result;
        break;
    }
    await new Promise(resolve => setTimeout(resolve, 2000));
}
return result;
};

// Fungsi untuk mendownload video dari YouTube
const youtubedl = async (url) => {
let html = await (await fetch('https://yt5s.com/en32', {headers: {
'User-Agent': generateRandomUserAgent(),
'X-Forwarded-For': generateRandomIP(),
}})).text();
let urlAjax = (html.match(/k_url_search="(.?)"/) || [])[1];
let urlConvert = (html.match(/k_url_convert="(.?)"/) || [])[1];
let json = await (await post(urlAjax, { q: url, vt: 'home' })).json();
let video = {}, audio = {};
if (!json?.links) throw json.mess;
Object.values(json.links.mp4).map(({ k, size }) => video[k] = {
quality: k,
fileSizeH: size,
fileSize: parseFloat(size) * (/MB$/.test(size) ? 1000 : 1),
download: convert.bind(null, urlConvert, json.vid, 'mp4', k, json.fn, json.token, parseInt(json.timeExpires))
});

Object.values(json.links.mp3).map(({ key, size }) => audio[key] = {
    quality: key,
    fileSizeH: size,
    fileSize: parseFloat(size) * (/MB$/.test(size) ? 1000 : 1),
    download: convert.bind(null, urlConvert, json.vid, 'mp3', key.replace(/kbps/i, ''), json.fn, json.token, parseInt(json.timeExpires))
});

return {
    id: json.vid,
    title: json.title,
    thumbnail: `https://i.ytimg.com/vi/${json.vid}/0.jpg`,
    video,
    audio
};
};

//TWITTER API
async function twitterDL(url) {
try {
let form = new FormData();
form.append('q', url);
form.append('lang', 'en');
    let response = await fetch('https://x2twitter.com/api/ajaxSearch', {
        method: 'POST',
        body: form,
        headers: {
            'User-Agent': generateRandomUserAgent(),
            'X-Forwarded-For': generateRandomIP(),
            ...form.getHeaders()
        }
    });

    let data = await response.json();
    const $ = cheerio.load(data?.data);
    let downloads = [];

    $('.dl-action a').each((index, element) => {
        const format = $(element).text().trim();
        const url = $(element).attr('href');
        if (url !== '#') {
            downloads.push({ format, url });
        }
    });

    // Jika tidak ada unduhan dari load pertama, coba load kedua
    if (downloads.length === 0) {
        $('a').each((index, element) => {
            const href = $(element).attr('href');
            if (href && href !== '/' && href !== '#') {
                downloads.push(href);
            }
        });
    }

    return { downloads };
} catch (error) {
    return error;
}
}

async function ytDEEL(url) {
    const { v4: uuidv4 } = require('uuid');
    const theme = encodeURIComponent('system');
    const apiUrl = `https://gradio-blocks-youtube-downloader.hf.space/queue/join?__theme=${theme}`;
    const mp3UploadId = uuidv4(); // Gunakan UUID yang berbeda untuk MP3
    const mp4UploadId = Math.random().toString(36).substring(2); // Gunakan UUID yang berbeda untuk MP4
  
    const mp3PostData = {
      data: [url, false],
      event_data: null,
      fn_index: 0,
      session_hash: mp3UploadId, // Gunakan mp3UploadId untuk MP3
      trigger_id: 10
    };
  
    const mp4PostData = {
      data: [url, true],
      event_data: null,
      fn_index: 0,
      session_hash: mp4UploadId, // Gunakan mp4UploadId untuk MP4
      trigger_id: 10
    };
  
    try {
      // Kirim permintaan MP3
      const mp3Response = await axios.post(apiUrl, mp3PostData, { headers: { 'Content-Type': 'application/json', 'Accept': '*/*' } });
      const mp3EventId = mp3Response.data.event_id;
  
      // Tunggu respons MP3
      let mp3Url;
      let mp3Completed = false;
      const mp3StatusUrl = `https://gradio-blocks-youtube-downloader.hf.space/queue/data?session_hash=${mp3UploadId}`;
      while (!mp3Completed) {
        const statusResponse = await axios.get(mp3StatusUrl, { headers: { 'Accept': 'text/event-stream' }, responseType: 'text' });
        const rawData = statusResponse.data.trim().split('\n').map(line => line.replace(/^data: /, ''));
        for (const line of rawData) {
          try {
            const event = JSON.parse(line);
            if (event.msg === 'process_completed') {
              if (event.event_id === mp3EventId && !mp3Completed) {
                mp3Url = event?.output?.data[1]?.value?.url;
                mp3Completed = true;
              }
            }
          } catch (e) {}
        }
        await new Promise(resolve => setTimeout(resolve, 5000));
      }
  
      // Kirim permintaan MP4
      const mp4Response = await axios.post(apiUrl, mp4PostData, { headers: { 'Content-Type': 'application/json', 'Accept': '*/*' } });
      const mp4EventId = mp4Response.data.event_id;
  
      // Tunggu respons MP4
      let mp4Url;
      let mp4Completed = false;
      const mp4StatusUrl = `https://gradio-blocks-youtube-downloader.hf.space/queue/data?session_hash=${mp4UploadId}`;
      while (!mp4Completed) {
        const statusResponse = await axios.get(mp4StatusUrl, { headers: { 'Accept': 'text/event-stream' }, responseType: 'text' });
        const rawData = statusResponse.data.trim().split('\n').map(line => line.replace(/^data: /, ''));
        for (const line of rawData) {
          try {
            const event = JSON.parse(line);
            if (event.msg === 'process_completed') {
              if (event.event_id === mp4EventId && !mp4Completed) {
                mp4Url = event?.output?.data[0]?.value?.url;
                mp4Completed = true;
              }
            }
          } catch (e) {}
        }
        await new Promise(resolve => setTimeout(resolve, 5000));
      }
  
        const result = { mp3: mp3Url.replace(/\s/g, '%20'), mp4: mp4Url.replace(/\s/g, '%20') };
        return result
  
  
    } catch (error) {
      throw error;
    }
  }

const app = express()
.set('json spaces', 4)
.use(morgan('dev'))
.use(express.json())
.all('/', async (req, res) => {
    const v8 = require('v8'); // Menempatkan ini di dalam handler agar tidak dijalankan saat server dimulai

    const status = {};
    status['diskUsage'] = cp.execSync('du -sh').toString().split('M')[0] + ' MB';

    const used = process.memoryUsage();
    for (let x in used) status[x] = formatSize(used[x]);

    const totalmem = os.totalmem();
    const freemem = os.freemem();
    status['memoryUsage'] = `${formatSize(totalmem - freemem)} / ${formatSize(totalmem)}`;

    // Menambahkan statistik heap V8
    const heapStats = v8.getHeapStatistics();
    for (let x in heapStats) status[x] = formatSize(heapStats[x]);

    // Menambahkan semua properti dan metode dari v8
    for (let x in v8) {
        if (typeof v8[x] !== 'function') {
            status[x] = v8[x];
        }
    }

    const host = 'https://' + req.get('host');

    res.json({
        creator: `@${process.env['SPACE_AUTHOR_NAME'] || 'ALOK FF'}`,
        message: 'Hello World!',
        uptime: new Date(process.uptime() * 1000).toUTCString().split(' ')[4],
        status, // Menambahkan latency ke JSON
        list: [
      {
          title: "BING AI",
          method: "GET",
          example: `${host}/bing?q=`
      },
      {
          title: "Facebook Downloader",
          method: "GET",
          example: `${host}/fb?url=`
      },
      {
          title: "Instagram Downloader",
          method: "GET",
          example: `${host}/ig?url=`
      },
      {
          title: "Mediafire Downloader",
          method: "GET",
          example: `${host}/mediafire?url=`
      },
      {
          title: "Mega Downloader",
          method: "GET",
          example: `${host}/mega?url=${encodeURIComponent('url')}`
      },
      {
          title: "Pinterest Downloader",
          method: "GET",
          example: `${host}/pindl?url=`
      },
      {
          title: "Tiktok Downloader",
          method: "GET",
          example: `${host}/tt?url=`
      },
      {
          title: "Twitter/X Downloader",
          method: "GET",
          example: `${host}/twitter?url=`
      },
      {
          title: "Whatmusic Search",
          method: "GET",
          example: `${host}/whatmusic?url=`
      },
      {
          title: "Youtube Downloader",
          method: "GET",
          example: `${host}/ytdl?url=`
      },
      {
          title: "Youtube Search",
          method: "GET",
          example: `${host}/ytsearch?q=`
      }
  ]
})})


.get('/yt', async (req, res) => {
const host = 'https://' + req.get('host');
try {
    let { url, type, quality, json } = req.query;
    if (!ytIdRegex.test(url)) return res.json({ message: 'Invalid URL' });
    if (!!json) {
        let ytId = ytIdRegex.exec(url)?.[1];
        if (!ytId) return res.json({ message: 'No video id found' });
        let data = await yts({ videoId: ytId });
        const downloadUrls = {
            audio: `${host}/yt?url=${url}&type=audio&quality=128kbps`,
            video: `${host}/yt?url=${url}&type=video&quality=`,
        };
        return res.json({
            ...data,
            download: downloadUrls
        });
    }
    if (!type || !/audio|video/i.test(type)) type = 'video';
    let data = await youtubedl(url).catch(e => console.log(e));
    if (!data) return res.json({ message: 'Error: link download not found' });
    type = type.toLowerCase();
    let result = quality ? Object.values(data[type]).find(x => x.quality == quality) : Object.values(data[type])[0];
    if (quality && !result) return res.json({ message: `Invalid quality: ${quality}, available quality (${Object.keys(data[type]).join('/')})` });
    if (!result) return res.json({ message: 'Error: can\'t download' });
    res.redirect(await result.download());
} catch (e) {
        console.log(e);
        return res.json({ message: e.message });
    }
})
.get('/ig', async (req,res) => {
try {
let {url} = req.query
let regex = /https?:\/\/(www\.)?instagram\.com\/(p|reel|tv)\/[a-zA-Z0-9_-]+\/?/;
if (!regex.test(url)) return res.json({ message: 'Invalid URL' });
let data = await igdl(url)
return res.json(data)
} catch (e) {
console.log(e);
return res.json({ message: e.message });
}
})
.get('/tt', async (req, res) => {
  try {
      let { url } = req.query
      let regex = /https?:\/\/(www\.)?(tiktok\.com|vt\.tiktok\.com|v\.tiktok\.com|t\.tiktok\.com)/;
      if (!regex.test(url)) return res.json({ message: 'Invalid URL' });
      let data = await fetch(`https://tikwm.com/api/?url=${url}`, {
          headers: {
              'User-Agent': generateRandomUserAgent(),
              'X-Forwarded-For': generateRandomIP(),
          }
      });
      data = await data.json();
      if (!data) return res.json({ message: 'API TO API KOID' });
      return res.json(data);
  } catch (e) {
      console.log(e);
      return res.json({ message: e.message });
  }
})

.get('/pindl', async (req, res) => {
  try {
      let { url } = req.query
      let regex = /https:\/\/pin\.it\/\w+|https:\/\/[a-z]{2}\.pinterest\.com\/pin\/\d+/;
      if (!regex.test(url)) return res.json({ message: 'Invalid URL' });
      let data = await fetch(`https://pinterestdownloader.io/id/frontendService/DownloaderService?url=${url}`, {
          headers: {
              'User-Agent': generateRandomUserAgent(),
              'X-Forwarded-For': generateRandomIP(),
          }
      });
      data = await data.json();
      if (!data) return res.json({ message: 'API TO API KOID' });
      return res.json(data);
  } catch (e) {
      console.log(e);
      return res.json({ message: e.message });
  }
})

.get('/fb', async (req, res) => {
try {
let {url} = req.query
let regex = /https?:\/\/(fb\.watch|(www\.|web\.|m\.)?facebook\.com)/;
if (!regex.test(url)) return res.json({ message: 'Invalid URL' });
let data = await fby2mate(url)
return res.json(data)
} catch (e) {
console.log(e);
return res.json({ message: e.message });
}
})
.get('/bimg', async (req, res) => {
try {
let q = req.query.q || req.query.query;
if (!q) return res.json({ message: 'Input parameter q' });
let data = await bimg(q)
return res.json({query: q, data: data})
} catch (e) {
console.log(e);
return res.json({ message: e.message });
}
})
.get('/bing', async (req, res) => {
try {
let q = req.query.q || req.query.query;
if (!q) return res.json({ message: 'Input parameter q' });
let data = await bingChat(q)
if (data.length === 0) {
  async function gpt4o(prompt) {
    let session_hash = Math.random().toString(36).substring(2);
    
    try {
        let resPrompt = await axios.post('https://kingnish-opengpt-4o.hf.space/run/predict?__theme=light', {
            "data": [{
                "text": prompt,
                "files": []
            }],
            "event_data": null,
            "fn_index": 3,
            "trigger_id": 34,
            "session_hash": session_hash
        });
        
        let res = await axios.post('https://kingnish-opengpt-4o.hf.space/queue/join?__theme=light', {
            "data": [
                null,
                null,
                "idefics2-8b-chatty",
                "Top P Sampling",
                0.5,
                4096,
                1,
                0.9,
                true
            ],
            "event_data": null,
            "fn_index": 5,
            "trigger_id": 34,
            "session_hash": session_hash
        });

        let event_ID = res.data.event_id;
        
        let anu = await axios.get('https://kingnish-opengpt-4o.hf.space/queue/data?session_hash=' + session_hash);
        const lines = anu.data.split('\n');
        const processStartsLine = lines.find(line => line.includes('process_completed'));
        
        if (processStartsLine) {
            const processStartsData = JSON.parse(processStartsLine.replace('data: ', ''));
            let ress = processStartsData.output.data;
            let result = ress[0][0][1];
            return result;
        } else {
            return 'error kang!';
        }
    } catch (error) {
        console.error(error);
        return 'error kang!';
    }
}

data = await gpt4o(q)
//return res.json({message: 'Terkena Chaptcha BOT!!!'})
}
return res.json({result
})
} catch (e) {
console.log(e);
return res.json({ message: e.message });
}
})
.get('/whatmusic', async (req, res) => {
try {
let { url } = req.query
async function downloadBuffer(url) {
try {
const response = await axios({
method: 'get',
url: url,
responseType: 'arraybuffer'
});
return Buffer.from(response.data, 'binary');
} catch (error) {
throw new Error(`Failed to download the file: ${error.message}`);
}
}
if (!url) return res.json({ message: 'Input parameter url' });
if (!isUrl(url)) return res.json({ message: 'Invalit Input Link' })
let data = await acrCloud(await downloadBuffer(isUrl(url)[0]))
if (!data) return res.json({ error: 'Error'});
return res.json(data);
} catch (e) {
console.log(e);
return res.json({ message: e.message });
}
})
.get('/ytsearch', async (req, res) => {
    try {
        let q = req.query.q || req.query.query;
        if (!q) return res.json({ message: 'Input parameter q' });

            let aloka = await yts(q);

        if (!aloka?.all[0]) return res.json({ message: 'Not found' });
        return res.json(aloka?.all);
    } catch (e) {
        console.log(e);
        return res.json({ message: e.message });
    }
})
.get('/mediafire', async (req, res) => {
try {
let { url } = req.query
//console.log(url)
if (!/https?:\/\/(www\.)?mediafire\.com\/(file|download)/i.test(url)) {
return res.json({ message: 'Invalid URL' });
}
let data = await mediafire(url)
return res.json(data)
} catch (e) {
console.log(e);
return res.json({ message: e.message });
}
})
.get('/ytdl', async (req, res) => {
    try {
        let { url } = req.query;
        if (!ytIdRegex.test(url)) return res.json({ message: 'Invalid URL' });

        let data = await ytAPI(url)
      let dataInfo = await ytdl.getVideoID(url)
      dataInfo = await yts({videoId: dataInfo})

        let response = {
            info: dataInfo ? dataInfo : {},
            dl: data ? data : null,
        };

        return res.json(response);
    } catch (e) {
        console.log(e);
        return res.status(500).json({ message: e.message });
    }
})
.get('/twitter', async (req, res) => {
try {
let { url } = req.query;
url = url.replace('x.com', 'twitter.com'); // Mengganti x.com dengan twitter.com dalam URL
if (!/(https?:\/\/(www\.)?(twitter|x)\.com\/.*\/status\/.*)/.test(url)) {
return res.json({ message: 'Invalid URL' });
}
let data = await twitterDL(url);
return res.json(data);
} catch (e) {
console.log(e);
return res.json({ message: e.message });
}
})


.get('/mega', async (req, res) => {
try {
    let { url } = req.query;
    if (!/https:\/\/mega\.nz\/file\/[a-zA-Z0-9]{8}#[a-zA-Z0-9-_]{43}/.test(url)) {
        return res.json({ message: 'Invalid URL' });
    }
    const file = File.fromURL(url);
     await file.loadAttributes();
     let data = await file.downloadBuffer();
  return res.json({
    title: file.name,
    size: formatSize(file.size),
    base64: data.toString('base64')
  })
} catch (e) {
    console.log(e);
    return res.json({ message: e.message });
}
})
.listen(7860, () => console.log('App running on port 7860'));