const yts = require('yt-search');
const morgan = require('morgan');
const express = require('express');
const ytdl = require('ytdl-core');
const ffmpeg = require("fluent-ffmpeg")
const { Writable, pipeline, Readable, PassThrough } = 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 mimes = require("mime-types")
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 convertMp4ToAudio(inputBuffer) {
    return new Promise((resolve, reject) => {
        const inputStream = new Readable();
        inputStream.push(inputBuffer);
        inputStream.push(null);

        const outputBuffer = [];
        const outputStream = new Writable({
            write(chunk, encoding, callback) {
                outputBuffer.push(chunk);
                callback();
            }
        });

        ffmpeg(inputStream)
            .toFormat('mp3')
            .on('end', () => {
                console.log('Conversion finished!');
                resolve(Buffer.concat(outputBuffer));
            })
            .on('error', (err) => {
                console.error('Error during conversion:', err);
                reject(err);
            })
            .pipe(outputStream);
    });
}
function formatSize(bytes, si = false, dp = 2) {
   const thresh = si ? 1000 : 1024;

   if (Math.abs(bytes) < thresh) {
      return `${bytes} B`;
   }

   const units = si
      ? ["kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]
      : ["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"];
   let u = -1;
   const r = 10 ** dp;

   do {
      bytes /= thresh;
      ++u;
   } while (
      Math.round(Math.abs(bytes) * r) / r >= thresh &&
      u < units.length - 1
   );

   return `${bytes.toFixed(dp)} ${units[u]}`;
}
async function streamToBuffer(stream) {
    const chunks = [];
    const captureChunks = new Writable({
        write(chunk, encoding, callback) {
            chunks.push(chunk);
            callback();
        }
    });
      
    await util.promisify(pipeline)(stream, captureChunks);

    return Buffer.concat(chunks);
} 
async function fileDitch(media){
  return new Promise(async (resolve, reject) => {
    let {fileTypeFromBuffer} = await (await import('file-type'))
     let mime = await fileTypeFromBuffer(media)
     let form = new FormData()

     form.append("files[]", media, `file-${new Date().getTime()}.${mime.ext}`)

     axios.post("https://up1.fileditch.com/temp/upload.php", form, {
        headers: {
           "User-Agent": generateRandomUserAgent(),
          "X-Forwarded-For": generateRandomIP(),
           ...form.getHeaders()
        }
     }).then(({ data }) => resolve(data?.files[0]?.url)).catch(reject(null))
  })
//https://up1.fileditch.com/upload.php
}
async function ytAPI(url) {
  try {
    const ID = ytdl.getVideoID(url)
          //let videoStream = await ytdl(ID, { filter: 'audioandvideo', quality: 'highestvideo' });
    let data = await ytdl.getInfo('https://www.youtube.com/watch?v=' + ID)
      let format = ytdl.chooseFormat(data.formats, { filter: 'videoandaudio', quality: 'highestvideo' });
          let audioStream = await ytdl(ID, {filter: "audioandvideo", quality:"lowestvideo"})
          //let buffermp4 = await streamToBuffer(videoStream)
          let buffermp3 = await streamToBuffer(audioStream)
          buffermp3 = await convertMp4ToAudio(buffermp3)
          //buffermp4 = await fileDitch(buffermp4)
          buffermp3 = await fileDitch(buffermp3)
      return {
        mp4_url: format.url,
        mp3_url: buffermp3,
          }
  } catch (err) {
    console.error('Error occurred:', err);
    return null;
  }
}



// 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;
}
}


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: "Google Search",
        method: "GET",
        example: `${host}/googleSearch?q=`
      },
      {
          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) => {
try {
        let { url } = req.query;
        //if (!ytIdRegex.test(url)) return res.json({ message: 'Invalid URL' });
        if (!ytdl.validateURL(url)) return res.json({ message: 'Invalid URL' });
        let videoID = ytdl.getVideoID(url);
        //let dataInfo = await ytdl.getBasicInfo(videoID) || {};
        let otherAPI =  await (await axios.get("https://line.1010diy.com/web/free-mp3-finder/detail?url="+url))?.data?.data ? await (await axios.get("https://line.1010diy.com/web/free-mp3-finder/detail?url="+url))?.data?.data : null

        let response = {
            metadata: otherAPI,
            //other: otherAPI || null
        };

        return res.json(response);
    } catch (e) {
        console.log(e);
        return res.status(500).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' });

    // Fetch data from tikwm.com API
    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' });

    // Array of versions to try
    const versions = ['v1', 'v2', 'v3'];
    const results = [];
  const Tiktok = require("@tobyg74/tiktok-api-dl")
    for (const version of versions) {
      try {
        const tiktokResult = await Tiktok.Downloader(url, { version });
        results.push({ version, result: tiktokResult });
      } catch (error) {
        results.push({ version, error: error.message });
      }
    }

    return res.json({
      data: data ? data : results,
    });

  } 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', {
            "data": [{
                "text": prompt,
                "files": []
            }],
            "event_data": null,
            "fn_index": 1,
            "trigger_id": 14,
            "session_hash": session_hash
        }, {
            headers: {
              'User-Agent': generateRandomUserAgent(),
              'X-Forwarded-For': generateRandomIP()
            }
        });
        
        let res = await axios.post('https://kingnish-opengpt-4o.hf.space/queue/join?__theme=light', {
            "data": [
                null,
                null,
                false
            ],
            "event_data": null,
            "fn_index": 3,
            "trigger_id": 14,
            "session_hash": session_hash
        }, {
            headers: {
              'User-Agent': generateRandomUserAgent(),
              'X-Forwarded-For': generateRandomIP()
            }
        });

        let event_ID = res.data.event_id;
        
        let anu = await axios.get('https://kingnish-opengpt-4o.hf.space/queue/data?session_hash=' + session_hash, {
            headers: {
              'User-Agent': generateRandomUserAgent(),
              'X-Forwarded-For': generateRandomIP()
            }
        });
        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({data: data
})
} 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' });
        if (!ytdl.validateURL(url)) return res.json({ message: 'Invalid URL' });
        let data = await ytAPI(url) || {};
        let videoID = ytdl.getVideoID(url);
        let dataInfo = await yts({ videoId: videoID }) || {};
        //let otherAPI =  await (await axios.get("https://line.1010diy.com/web/free-mp3-finder/detail?url="+url))?.data?.data ? await (await axios.get("https://line.1010diy.com/web/free-mp3-finder/detail?url="+url))?.data?.data : null

        let response = {
            ...dataInfo,
            mp4: data.mp4_url,
            mp3: data.mp3_url,
            //other: otherAPI || 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('/googleSearch', async (req, res) => {
    try {
        let q = req.query.q || req.query.query;
        if (!q) return res.json({ message: 'Input parameter q' });
        let get = await (require("google-it"))({"query": q})
        return res.json(get)
    } 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();
     mime.types['py'] = 'text/x-python';                // Python
mime.types['java'] = 'text/x-java-source';         // Java
mime.types['c'] = 'text/x-c';                      // C
mime.types['cpp'] = 'text/x-c++src';               // C++
mime.types['cc'] = 'text/x-c++src';                // C++
mime.types['cxx'] = 'text/x-c++src';               // C++
mime.types['cs'] = 'text/x-csharp';                // C#
mime.types['php'] = 'application/x-httpd-php';     // PHP
mime.types['rb'] = 'text/x-ruby';                  // Ruby
mime.types['pl'] = 'text/x-perl';                  // Perl
mime.types['sh'] = 'application/x-sh';             // Shell Script
mime.types['go'] = 'text/x-go';                    // Go
mime.types['swift'] = 'text/x-swift';              // Swift
mime.types['kt'] = 'text/x-kotlin';                // Kotlin
mime.types['rs'] = 'text/x-rustsrc';               // Rust
mime.types['scala'] = 'text/x-scala';              // Scala
mime.types['r'] = 'text/x-r-source';               // R
mime.types['R'] = 'text/x-r-source';               // R (alternatif untuk huruf besar)
mime.types['lua'] = 'text/x-lua';                  // Lua
mime.types['md'] = 'text/markdown';                // Markdown
mime.types['json'] = 'application/json';           // JSON
mime.types['js'] = 'application/javascript';       // JavaScript
mime.types['ts'] = 'application/x-typescript';     // TypeScript
mime.types['xml'] = 'application/xml';             // XML
mime.types['yaml'] = 'application/x-yaml';         // YAML
mime.types['yml'] = 'application/x-yaml';          // YAML (alternatif)
mime.types['html'] = 'text/html';                  // HTML
mime.types['htm'] = 'text/html';                   // HTML (alternatif)
mime.types['css'] = 'text/css';                    // CSS
mime.types['scss'] = 'text/x-scss';                // SCSS (Sass)
mime.types['sass'] = 'text/x-sass';                // Sass
mime.types['less'] = 'text/x-less';                // Less
mime.types['coffee'] = 'text/coffeescript';        // CoffeeScript
mime.types['dart'] = 'application/dart';           // Dart
mime.types['sql'] = 'application/sql';             // SQL
mime.types['vb'] = 'text/x-vbscript';              // VBScript
mime.types['vbs'] = 'text/x-vbscript';             // VBScript (alternatif)
mime.types['bat'] = 'application/x-msdos-program'; // Batch script
mime.types['cmd'] = 'application/cmd';             // Command script
mime.types['ps1'] = 'application/x-powershell';    // PowerShell script
mime.types['ini'] = 'text/plain';                  // INI file
mime.types['toml'] = 'application/toml';           // TOML
mime.types['cfg'] = 'text/plain';                  // Configuration file
mime.types['conf'] = 'text/plain';                 // Configuration file
mime.types['properties'] = 'text/plain';           // Properties file
mime.types['log'] = 'text/plain';                  // Log file
mime.types['yml'] = 'application/x-yaml';          // YAML file
mime.types['rst'] = 'text/x-rst';                  // reStructuredText
mime.types['latex'] = 'application/x-latex';       // LaTeX
mime.types['tex'] = 'application/x-tex';           // TeX
mime.types['bib'] = 'text/x-bibtex';               // BibTeX
mime.types['mat'] = 'application/x-matlab-data';   // MATLAB
mime.types['m'] = 'text/x-matlab';                 // MATLAB or Objective-C
mime.types['octave'] = 'text/x-octave';            // GNU Octave
mime.types['rmd'] = 'text/x-r-markdown';           // R Markdown
mime.types['jl'] = 'text/x-julia';                 // Julia
mime.types['clj'] = 'text/x-clojure';              // Clojure
mime.types['cljs'] = 'text/x-clojurescript';       // ClojureScript
mime.types['cljc'] = 'text/x-clojure';             // Clojure (Common)
mime.types['erl'] = 'text/x-erlang';               // Erlang
mime.types['hs'] = 'text/x-haskell';               // Haskell
mime.types['lhs'] = 'text/x-literate-haskell';     // Literate Haskell
mime.types['ml'] = 'text/x-ocaml';                 // OCaml
mime.types['mli'] = 'text/x-ocaml';                // OCaml Interface
mime.types['fs'] = 'text/x-fsharp';                // F#
mime.types['fsi'] = 'text/x-fsharp';               // F# Interactive
mime.types['fsx'] = 'text/x-fsharp';               // F# Script
mime.types['fsscript'] = 'text/x-fsharp';          // F# Script (alternative)
mime.types['elm'] = 'text/x-elm';                  // Elm
mime.types['elm'] = 'application/elm';             // Elm (alternative)
mime.types['ex'] = 'text/x-elixir';                // Elixir
mime.types['exs'] = 'text/x-elixir';               // Elixir Script
mime.types['eex'] = 'text/x-eex';                  // Elixir Embedded Templates
mime.types['html.eex'] = 'text/x-html-elixir';     // Elixir HTML Embedded Templates
mime.types['hx'] = 'text/x-haxe';                  // Haxe
mime.types['hxml'] = 'application/hxml';           // Haxe XML
mime.types['sml'] = 'text/x-sml';                  // Standard ML
mime.types['thy'] = 'text/x-isabelle-theory';      // Isabelle Theory
mime.types['lean'] = 'text/x-lean';                // Lean
mime.types['v'] = 'text/x-verilog';                // Verilog
mime.types['sv'] = 'text/x-systemverilog';         // SystemVerilog
mime.types['vhd'] = 'text/x-vhdl';                 // VHDL
mime.types['vhdl'] = 'text/x-vhdl';                // VHDL (alternative)
mime.types['scm'] = 'text/x-scheme';               // Scheme
mime.types['ss'] = 'text/x-scheme';                // Scheme (alternative)
mime.types['rkt'] = 'text/x-racket';               // Racket
mime.types['lisp'] = 'text/x-common-lisp';         // Common Lisp
mime.types['asd'] = 'text/x-common-lisp';          // Common Lisp ASDF
mime.types['cl'] = 'text/x-common-lisp';           // Common Lisp (alternative)
mime.types['el'] = 'text/x-emacs-lisp';            // Emacs Lisp
mime.types['sc'] = 'text/x-supercollider';         // SuperCollider
mime.types['f'] = 'text/x-fortran';                // Fortran
mime.types['f90'] = 'text/x-fortran';              // Fortran (alternative)
mime.types['f95'] = 'text/x-fortran';              // Fortran (alternative)
mime.types['v'] = 'text/x-vim';                    // Vim Script
mime.types['pro'] = 'text/x-prolog';               // Prolog
mime.types['pl'] = 'text/x-prolog';                // Prolog (alternative to Perl)
mime.types['p'] = 'text/x-pascal';                 // Pascal
mime.types['pas'] = 'text/x-pascal';               // Pascal (alternative)
mime.types['d'] = 'text/x-d';                      // D
mime.types['ada'] = 'text/x-ada';                  // Ada
mime.types['adb'] = 'text/x-ada';                  // Ada Body
mime.types['ads'] = 'text/x-ada';                  // Ada Specification
mime.types['nim'] = 'text/x-nim';                  // Nim
mime.types['nimble'] = 'text/x-nim';               // Nimble
mime.types['cr'] = 'text/x-crystal';               // Crystal
mime.types['cl'] = 'text/x-clarion';               // Clarion
mime.types['prg'] = 'text/x-clarion';              // Clarion Program
mime.types['l'] = 'text/x-lex';                    // Lex/Flex
mime.types['yy'] = 'text/x-bison';                 // Bison/Yacc
mime.types['bison'] = 'text/x-bison';              // Bison/Yacc (alternative)
mime.types['mly'] = 'text/x-menhir';               // Menhir
     let {fileTypeFromBuffer} = await (await import('file-type'))
  return res.json({
message:"Success",
code: 200,
result : {name: file.name,
    fileSize: file.size,
    size: formatSize(file.size),
    mimetype: mimes.lookup(file?.name) || (await fileTypeFromBuffer(data))?.mime || "application/octet-stream",
    ext: mimes.extension(mimes.lookup(file?.name)) || (await fileTypeFromBuffer(data))?.ext || file?.name?.split(".")[1] || "bin",
    buffer: Buffer.from(data)},
  })
} catch (e) {
    console.log(e);
    return res.json({ message: "Internal Server Error",
        code: 500
     });
}
})
  .use((req, res, next) => {
    res.redirect('/');
  })
.listen(7860, () => console.log('App running on port 7860'));