const express = require('express');
const unblocker = require('unblocker');
const basicAuth = require('basic-auth');
const faker = require('faker');
const { Transform } = require('stream');
const dns = require('dns');
const http = require('http');
const https = require('https');
const { URL } = require('url');
const httpProxy = require('http-proxy');
const request = require('request')
const pick = require('lodash').pick
const app = express();
const server = createServer();
const auth = require('basic-auth')
const ytdl = require('ytdl-core');
const axios = require('axios');
const url = require('url');
const { createProxyMiddleware } = require('http-proxy-middleware');
const LOGIN = 'usuario';
const PASSWORD = 'clave';
const MAIN_IP = '0.0.0.0';
const PROXY_PORT = 7860;
const google_analytics_id = process.env.GA_ID || null;
let port = parseInt(process.env.PORT || "");
const httpProxyServer = httpProxy.createProxyServer({});

if (isNaN(port)) port = 8080;

let allowAllRequests = false;

let requestCount = 0;
const statusCounts = {};

function generateRandomResidentialIP() {
  return faker.internet.ip();
}

function incrementRequestCount() {
  requestCount++;
}

function incrementStatusCount(statusCode) {
  statusCounts[statusCode] = (statusCounts[statusCode] || 0) + 1;
}

app.use(express.json());

app.use((req, res, next) => {
    if (req.method === 'GET' || req.method === 'POST' || req.method === 'PUT' || req.method === 'CONNECT' || req.method === '' || req.method === '*') {
        next();
    } else {
        res.status(405).send('Method Not Allowed');
    }
});

app.use((req, res, next) => {

  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, CONNECT, OPTIONS');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');

  if (req.method === 'OPTIONS') {
    res.sendStatus(200);
  } else {
    next();
  }
});

app.use((req, res, next) => {

  res.setHeader('Accept-Language', 'en-US,en;q=0.9');
  next();
});

app.use((req, res, next) => {

  res.setHeader('Referer', 'https://www.google.com/');
  next();
});

function incognitoMode(req, res, next) {

  req.headers['User-Agent'] = faker.internet.userAgent();
  req.headers['X-Forwarded-For'] = generateRandomResidentialIP();
  req.headers['X-Forwarded-Proto'] = 'https';
  next();
}

function solveGoogleCaptcha(req, res, next) {

  if (res.getHeader('content-type') && res.getHeader('content-type').includes('text/html')) {
    const data = [];
    res.on('data', chunk => {
      data.push(chunk);
    });
    res.on('end', () => {
      let html = Buffer.concat(data).toString();

      html = html.replace(/<div class="g-recaptcha.*?<\/div>/gi, '');
      res.setHeader('content-length', Buffer.byteLength(html));
      res.end(html);
    });
  } else {
    next();
  }
}

function solveCloudflareCaptcha(req, res, next) {

  if (res.getHeader('content-type') && res.getHeader('content-type').includes('text/html')) {
    const data = [];
    res.on('data', chunk => {
      data.push(chunk);
    });
    res.on('end', () => {
      let html = Buffer.concat(data).toString();

      html = html.replace(/<div class="g-recaptcha.*?<\/div>/gi, '');
      res.setHeader('content-length', Buffer.byteLength(html));
      res.end(html);
    });
  } else {
    next();
  }
}

function solveHCaptcha(req, res, next) {

  if (res.getHeader('content-type') && res.getHeader('content-type').includes('text/html')) {
    const data = [];
    res.on('data', chunk => {
      data.push(chunk);
    });
    res.on('end', () => {
      let html = Buffer.concat(data).toString();

      html = html.replace(/<div class="h-captcha".*?<\/div>/gi, '');
      res.setHeader('content-length', Buffer.byteLength(html));
      res.end(html);
    });
  } else {
    next();
  }
}

app.use((req, res, next) => {
  solveGoogleCaptcha(req, res, () => {
    solveCloudflareCaptcha(req, res, () => {
      solveHCaptcha(req, res, next);
    });
  });
});

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('cf-chl-bypass');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('HCaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {

      const remoteAddress = new URL(client_req.url).hostname;
      console.log(`IP del sitio ${client_req.url}: ${remoteAddress}`);
      next();
    },
  ],
}));

app.use((req, res, next) => {

  req.headers['User-Agent'] = faker.internet.userAgent();

  const randomIp = faker.internet.ip();
  console.log(`IP simulada: ${randomIp}`);
  req.headers['x-forwarded-for'] = randomIp;

  req.headers['Accept-Language'] = 'en-US,en;q=0.9';
  req.headers['Referer'] = 'https://www.google.com/';

  next();
});

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      if (client_req.url.includes('login')) {
        client_res.statusCode = 200; 
        client_res.end('Inicio de sesión omitido'); 
      } else {
        next(); 
      }
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      if (client_req.url.includes('login')) {
        next(); 
      } else {
        next(); 
      }
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      if (client_req.url.includes('login')) {

        client_req.setHeader('Authorization', 'Basic ' + Buffer.from('usuario:clave').toString('base64'));
      }
      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      client_req.removeHeader('X-Blocked-IP');

      next(); 
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {

      client_res.removeHeader('X-Spam-Blocked');

      client_res.removeHeader('X-TOS-Blocked');

      client_res.removeHeader('X-Proxy-Blocked');

      client_res.removeHeader('X-Censored');

      client_res.removeHeader('X-Hacking-Blocked');

      next(); 
    },
  ],
}));

function proxy(req, res) {
  request.get(
    req.params.url,
    {
      headers: {
        ...pick(req.headers, ['cookie', 'dnt', 'referer']),
        'user-agent': 'Bandwidth-Hero Compressor',
        'x-forwarded-for': req.headers['x-forwarded-for'] || req.ip,
        via: '1.1 bandwidth-hero'
      },
      timeout: 10000,
      maxRedirects: 5,
      encoding: null,
      strictSSL: false,
      gzip: true,
      jar: true
    },
    (err, origin, buffer) => {
      if (err || origin.statusCode >= 400) return redirect(req, res)

      copyHeaders(origin, res)
      res.setHeader('content-encoding', 'identity')
      req.params.originType = origin.headers['content-type'] || ''
      req.params.originSize = buffer.length

      if (shouldCompress(req)) {
        compress(req, res, buffer)
      } else {
        bypass(req, res, buffer)
      }
    }
  )
}

app.use(incognitoMode);

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests) {
        client_res.removeHeader('Content-Security-Policy');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests) {

        if (client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {
          let data = '';
          client_res.on('data', (chunk) => {
            data += chunk.toString();
          });
          client_res.on('end', () => {

            const adFreeContent = data.replace(/<script.*?<\/script>/gi, ''); 
            client_res.setHeader('content-length', Buffer.byteLength(adFreeContent));
            client_res.end(adFreeContent);
          });
        }
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests) {

        client_res.removeHeader('X-Captcha-solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      client_req.headers['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.82 Safari/537.36';
      next();
    },
  ],
  responseMiddleware: [],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests) {

        const cookies = client_req.headers.cookie;
        if (cookies) {
          client_req.setHeader('Cookie', cookies);
        }
      }
      next();
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests) {

        const headers = client_res.getHeaders();
        if (headers['set-cookie']) {
          client_res.setHeader('Set-Cookie', headers['set-cookie']);
        }
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('x-grecaptcha-response');
      }
      next();
    },
  ],
}));

app.all('*', (req, res, next) => {

  if (!allowAllRequests) {
    const credentials = basicAuth(req, { realm: 'Proxy Access' });

    if (credentials) {
      if (credentials.name !== 'usuario' || credentials.pass !== 'clave') {
        res.status(401).send('Acceso no autorizado');
        return;
      }
    }
  }

  res.status(200);

  const ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress;

  unblocker.proxyRequest(req, res, {
    headers: {
      'Custom-Header': 'Valor personalizado',

    }
  }).then(() => {

    console.log(`[${new Date().toISOString()}] ${req.method} ${url} - IP: ${ip} - Status: ${res.statusCode}`);
    incrementStatusCount(res.statusCode);
  }).catch((err) => {
    console.error('Error en la solicitud al servidor:', err);
    res.status(500).send('Error interno del servidor');
  });
});

function createServer() {

  app.get('/api/example', (req, res) => {
    res.status(200).json({ message: 'This is an example API endpoint' });
  });

  app.get('/stats', (req, res) => {
    res.send(`
      <h1>Proxy Stats</h1>
      <p>Total Requests: ${requestCount}</p>
      <p>Status Counts:</p>
      <ul>
        ${Object.keys(statusCounts).map(status => `<li>${status}: ${statusCounts[status]}</li>`).join('')}
      </ul>
    `);
  });

}

app.use((req, res, next) => {
    httpProxyServer.web(req, res, { target: req.url });
});

app.use((req, res, next) => {
    if (allowAllRequests) {

        app.web(req, res, { target: req.url, changeOrigin: true });
    } else {
        const credentials = auth(req);
        if (!credentials || credentials.name !== LOGIN || credentials.pass !== PASSWORD) {
            res.statusCode = 401;
            res.setHeader('WWW-Authenticate', 'Basic realm="example"');
            res.end('Access denied');
        } else {

            app.web(req, res, { target: req.url, changeOrigin: true });
        }
    }
});

function authenticate(req, res, next) {
  if (LOGIN && PASSWORD) {
    const credentials = auth(req)
    if (!credentials || credentials.name !== LOGIN || credentials.pass !== PASSWORD) {
      res.setHeader('WWW-Authenticate', `Basic realm="Bandwidth-Hero Compression Service"`)

      return res.status(401).end('Access denied')
    }
  }

  next()
}

app.use(unblocker({
    requestMiddleware: [],
    responseMiddleware: [
      (client_req, client_res, next) => {
        if (allowAllRequests) {
          client_res.removeHeader('Content-Security-Policy');
        }
        next();
      },
    ],
  }));

app.use(unblocker({
    requestMiddleware: [],
    responseMiddleware: [
      (client_req, client_res, next) => {
        if (allowAllRequests) {

          client_res.removeHeader('X-Captcha');
        }
        next();
      },
    ],
  }));

app.use(unblocker({
    requestMiddleware: [],
    responseMiddleware: [
      (client_req, client_res, next) => {
        if (allowAllRequests) {

          client_res.removeHeader('X-Censored');
        }
        next();
      },
    ],
  }));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {

      if (client_req.url.includes('youtube.com')) {
        client_res.removeHeader('youtube-restrictions');
      }

      if (client_req.url.includes('instagram.com')) {
        client_res.removeHeader('instagram-restrictions');
      }

      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      const url = new URL(client_req.url);
      const hostname = url.hostname;

      if (!client_req.url.includes('login')) { 

        const fakeIp = faker.internet.ip();
        client_req.headers['x-forwarded-for'] = fakeIp;
      }

      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      const url = new URL(client_req.url);
      const hostname = url.hostname;

      if (!client_req.url.includes('login')) { 

        client_req.removeHeader('X-Blocked-IP');

        const fakeIp = faker.internet.ip();
        client_req.headers['x-forwarded-for'] = fakeIp;
      }

      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {

      if (!client_req.url.includes('login')) { 

        client_res.removeHeader('X-Censored');
      }

      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {

      if (client_res.statusCode === 403 && client_res.statusMessage === 'Forbidden') {

        let data = '';
        client_res.on('data', (chunk) => {
          data += chunk.toString();
        });
        client_res.on('end', () => {
          const uncensoredContent = data.replace(/censored/gi, ''); 
          client_res.setHeader('content-length', Buffer.byteLength(uncensoredContent));
          client_res.end(uncensoredContent);
        });
      } else {
        next(); 
      }
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {

      client_res.removeHeader('X-Censored');

      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      client_req.removeHeader('X-Blocked-IP');

      next(); 
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {

      client_res.removeHeader('X-Spam-Blocked');

      client_res.removeHeader('X-TOS-Blocked');

      client_res.removeHeader('X-Proxy-Blocked');

      client_res.removeHeader('X-Censored');

      client_res.removeHeader('X-Hacking-Blocked');

      next(); 
    },
  ],
}));

app.use((req, res, next) => {
    const { url, method, headers } = req;

    try {

        const targetUrl = new URL(url);

        const protocol = targetUrl.protocol === 'https:' ? https : http;

        let port = targetUrl.port || (protocol === https ? 443 : 80);

        const options = {
            hostname: targetUrl.hostname,
            port,
            path: targetUrl.pathname + targetUrl.search + targetUrl.hash,
            method,
            headers,
        };

        const proxyReq = protocol.request(options, proxyRes => {

            let responseBody = '';
            proxyRes.setEncoding('utf8');
            proxyRes.on('data', chunk => {
                responseBody += chunk;
            });
            proxyRes.on('end', () => {

                res.status(proxyRes.statusCode);
                res.set(proxyRes.headers);
                res.send(responseBody);
            });
        });

        proxyReq.on('error', err => {
            console.error('Error en la solicitud proxy:', err);
            res.status(500).send('Error en el proxy');
        });

        req.pipe(proxyReq);
    } catch (error) {
        console.error('Error al procesar la URL:', error);
        res.status(400).send('URL inválida');
    }
});

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      client_req.removeHeader('X-Blocked-IP');

      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      client_req.removeHeader('X-Blocked-IP');

      next(); 
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {

      client_res.removeHeader('X-Spam-Blocked');

      client_res.removeHeader('X-TOS-Blocked');

      client_res.removeHeader('X-Proxy-Blocked');

      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      client_req.removeHeader('X-Blocked-IP');

      next(); 
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {

      client_res.removeHeader('X-Spam-Blocked');

      client_res.removeHeader('X-TOS-Blocked');

      client_res.removeHeader('X-Proxy-Blocked');

      client_res.removeHeader('X-Censored');

      client_res.removeHeader('X-Hacking-Blocked');

      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      client_req.removeHeader('X-Blocked-IP');

      next(); 
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {

      client_res.removeHeader('X-Spam-Blocked');

      client_res.removeHeader('X-TOS-Blocked');

      client_res.removeHeader('X-Proxy-Blocked');

      client_res.removeHeader('X-Censored');

      client_res.removeHeader('X-Hacking-Blocked');

      client_res.removeHeader('X-Protection-Blocked');

      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      client_req.removeHeader('X-Blocked-IP');

      next(); 
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {

      client_res.removeHeader('X-Spam-Blocked');

      client_res.removeHeader('X-TOS-Blocked');

      client_res.removeHeader('X-Proxy-Blocked');

      client_res.removeHeader('X-Censored');

      client_res.removeHeader('X-Hacking-Blocked');

      client_res.removeHeader('X-Protection-Blocked');

      next(); 
    },
  ],
}));

app.use((req, res, next) => {
  solveGoogleCaptcha(req, res, () => {
    solveCloudflareCaptcha(req, res, () => {
      solveHCaptcha(req, res, next);
    });
  });
});

app.use(unblocker({
    requestMiddleware: [],
    responseMiddleware: [
        (client_req, client_res, next) => {
            if (allowAllRequests) {
                client_res.removeHeader('Content-Security-Policy');
            }
            next();
        },
    ],
}));

app.use(unblocker({
    requestMiddleware: [],
    responseMiddleware: [
        (client_req, client_res, next) => {
            if (allowAllRequests) {

                if (client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {
                    let data = '';
                    client_res.on('data', (chunk) => {
                        data += chunk.toString();
                    });
                    client_res.on('end', () => {

                        const adFreeContent = data.replace(/<script.*?<\/script>/gi, ''); 
                        client_res.setHeader('content-length', Buffer.byteLength(adFreeContent));
                        client_res.end(adFreeContent);
                    });
                }
            }
            next();
        },
    ],
}));

app.use((req, res, next) => {
    solveGoogleCaptcha(req, res, () => {
        solveCloudflareCaptcha(req, res, () => {
            next();
        });
    });
});

app.use((req, res, next) => {

    res.setHeader('X-Adblock-Test', 'success');
    next();
});

app.use((req, res, next) => {

    req.ip = getRandomIP();
    next();
});

app.use((req, res, next) => {

    req.headers['User-Agent'] = getRandomUserAgent();
    next();
});

app.use((req, res, next) => {

    res.setHeader('Connection', 'keep-alive');
    next();
});

app.use((req, res, next) => {

    res.setHeader('X-Robots-Tag', 'noindex, nofollow');
    next();
});

app.use((req, res, next) => {

    res.setHeader('DNT', '1');
    next();
});

app.use((req, res, next) => {

    res.setHeader('X-Forwarded-For', getRandomIP());
    next();
});

app.use((err, req, res, next) => {

});

app.use((req, res, next) => {

    next();
});

app.use((req, res, next) => {

    res.setHeader('Accept', 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Accept-Encoding', 'gzip, deflate, br');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Connection', 'keep-alive');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Cache-Control', 'no-cache');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Pragma', 'no-cache');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Accept-Language', 'en-US,en;q=0.9');
    next();
});

app.use((req, res, next) => {

    res.setHeader('X-Requested-With', 'XMLHttpRequest');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Access-Control-Allow-Credentials', 'true');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Access-Control-Allow-Origin', '*');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Access-Control-Expose-Headers', 'Content-Length');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Access-Control-Max-Age', '3600');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Access-Control-Request-Headers', 'Content-Type, Authorization');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Access-Control-Request-Method', 'GET, POST, PUT, DELETE, OPTIONS');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Origin', 'http://example.com');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Sec-Fetch-Dest', 'document');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Sec-Fetch-Mode', 'navigate');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Sec-Fetch-Site', 'cross-site');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Sec-Fetch-User', '?1');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Upgrade-Insecure-Requests', '1');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Accept', 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Accept-Encoding', 'gzip, deflate, br');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Accept-Language', 'en-US,en;q=0.9');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Cookie', 'sessionId=12345');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Cache-Control', 'max-age=0');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Host', 'www.example.com');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Referer', 'http://www.example.com/');
    next();
});

app.use((req, res, next) => {

    res.setHeader('Upgrade-Insecure-Requests', '1');
    next();
});

app.use((req, res, next) => {

    res.setHeader('User-Agent', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3');
    next();
});

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests) {
        client_res.removeHeader('Content-Security-Policy');
      }
      next();
    },
  ],
}));

app.use((req, res, next) => {
  solveGoogleCaptcha(req, res, () => {
    solveCloudflareCaptcha(req, res, () => {
      solveHCaptcha(req, res, next);
    });
  });
});

app.use((req, res, next) => {
  req.headers['User-Agent'] = faker.internet.userAgent();
  const randomIp = faker.internet.ip();
  req.headers['x-forwarded-for'] = randomIp;
  req.headers['Accept-Language'] = 'en-US,en;q=0.9';
  req.headers['Referer'] = 'https://www.google.com/';
  next();
});

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      let data = '';
      client_res.on('data', (chunk) => {
        data += chunk.toString();
      });
      client_res.on('end', () => {
        if (client_req.url.includes('youtube.com')) {
          data = data.replace('playButton', 'playButton.click()');
        }
        if (client_req.url.includes('instagram.com')) {
          data = data.replace('playButton', 'playButton.click()');
        }
        client_res.setHeader('content-length', Buffer.byteLength(data));
        client_res.end(data);
      });
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-Country-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-Cookie-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-JS-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-WebGL-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-WebRTC-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-Server-Security-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-Firewall-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-ISP-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-Browser-Firewall-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-Server-Firewall-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-ISP-Firewall-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests) {
        client_res.removeHeader('Content-Security-Policy');
      }
      next();
    },
  ],
}));

app.use((req, res, next) => {
  solveGoogleCaptcha(req, res, () => {
    solveCloudflareCaptcha(req, res, () => {
      solveHCaptcha(req, res, next);
    });
  });
});

app.use((req, res, next) => {
  req.headers['User-Agent'] = faker.internet.userAgent();
  const randomIp = faker.internet.ip();
  req.headers['x-forwarded-for'] = randomIp;
  req.headers['Accept-Language'] = 'en-US,en;q=0.9';
  req.headers['Referer'] = 'https://www.google.com/';
  next();
});

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      let data = '';
      client_res.on('data', (chunk) => {
        data += chunk.toString();
      });
      client_res.on('end', () => {
        if (client_req.url.includes('youtube.com')) {
          data = data.replace('playButton', 'playButton.click()');
        }
        if (client_req.url.includes('instagram.com')) {
          data = data.replace('playButton', 'playButton.click()');
        }
        client_res.setHeader('content-length', Buffer.byteLength(data));
        client_res.end(data);
      });
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_req.headers['x-forwarded-for'] = faker.internet.ip());;
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      client_req.headers['User-Agent'] = faker.internet.userAgent();
      next();
    },
  ],
  responseMiddleware: [],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-Browser-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-JS-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-WebGL-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-WebRTC-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-3rd-Party-Cookie-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-Mixed-Content-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-Browser-Security-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-Proxy-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-DNS-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-Network-Block');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (!client_req.url.includes('login')) {
        client_res.removeHeader('X-Network-Firewall-Block');
      }
      next();
    },
  ],
}));

app.use((req, res, next) => {
  solveGoogleCaptcha(req, res, () => {
    solveCloudflareCaptcha(req, res, () => {
      solveHCaptcha(req, res, next);
    });
  });
});

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {

      client_res.removeHeader('X-Censored');
      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      client_req.removeHeader('X-Blocked-IP');
      next(); 
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {

      client_res.removeHeader('X-Spam-Blocked');

      client_res.removeHeader('X-TOS-Blocked');

      client_res.removeHeader('X-Proxy-Blocked');

      client_res.removeHeader('X-Censored');

      client_res.removeHeader('X-Hacking-Blocked');

      client_res.removeHeader('X-Protection-Blocked');
      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      client_req.removeHeader('X-Blocked-IP');
      next(); 
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {

      client_res.removeHeader('X-Spam-Blocked');

      client_res.removeHeader('X-TOS-Blocked');

      client_res.removeHeader('X-Proxy-Blocked');
      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      client_req.removeHeader('X-Blocked-IP');
      next(); 
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {

      client_res.removeHeader('X-Spam-Blocked');

      client_res.removeHeader('X-TOS-Blocked');

      client_res.removeHeader('X-Proxy-Blocked');

      client_res.removeHeader('X-Censored');

      client_res.removeHeader('X-Hacking-Blocked');

      client_res.removeHeader('X-Protection-Blocked');
      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('FunCaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('Coinhive-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('Coinhive-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('SolveMedia-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('Anti-Bot-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('Funcaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('ArkoseLabs-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('DistilNetworks-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('ImageCaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('KeyCaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('SoundCaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('TikTokCaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('QQCaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('Recaptcha3-Solver');
      }
      next();
    },
  ],
}));

app.use((req, res, next) => {
  solveGoogleCaptcha(req, res, () => {
    solveCloudflareCaptcha(req, res, () => {
      solveHCaptcha(req, res, next);
    });
  });
});

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {

      client_res.removeHeader('X-Censored');
      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      client_req.removeHeader('X-Blocked-IP');
      next(); 
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {

      client_res.removeHeader('X-Spam-Blocked');

      client_res.removeHeader('X-TOS-Blocked');

      client_res.removeHeader('X-Proxy-Blocked');

      client_res.removeHeader('X-Censored');

      client_res.removeHeader('X-Hacking-Blocked');

      client_res.removeHeader('X-Protection-Blocked');
      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      client_req.removeHeader('X-Blocked-IP');
      next(); 
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {

      client_res.removeHeader('X-Spam-Blocked');

      client_res.removeHeader('X-TOS-Blocked');

      client_res.removeHeader('X-Proxy-Blocked');
      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {

      client_req.removeHeader('X-Blocked-IP');
      next(); 
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {

      client_res.removeHeader('X-Spam-Blocked');

      client_res.removeHeader('X-TOS-Blocked');

      client_res.removeHeader('X-Proxy-Blocked');

      client_res.removeHeader('X-Censored');

      client_res.removeHeader('X-Hacking-Blocked');

      client_res.removeHeader('X-Protection-Blocked');
      next(); 
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('X-Recaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('FunCaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('Coinhive-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('Coinhive-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('SolveMedia-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('Anti-Bot-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('Funcaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('ArkoseLabs-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('DistilNetworks-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('ImageCaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('KeyCaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('SoundCaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('TikTokCaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('QQCaptcha-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      if (allowAllRequests && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {

        client_res.removeHeader('Recaptcha3-Solver');
      }
      next();
    },
  ],
}));

app.use(unblocker({
    requestMiddleware: [],
    responseMiddleware: [
        (client_req, client_res, next) => {
            if (allowAllRequests) {
                client_res.removeHeader('Content-Security-Policy');
            }
            next();
        },
    ],
}));

app.use(unblocker({
    requestMiddleware: [],
    responseMiddleware: [
        (client_req, client_res, next) => {
            if (allowAllRequests && google_analytics_id && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {
                client_res.pipe(new Transform({
                    decodeStrings: false,
                    transform: function (chunk, encoding, next) {
                        this.push(addGa(chunk.toString()));
                        next();
                    }
                })).pipe(client_res);
            }
            next();
        },
    ],
}));

app.use((req, res, next) => {
    const credentials = auth(req);
    if (!credentials || credentials.name !== LOGIN || credentials.pass !== PASSWORD) {
        res.statusCode = 401;
        res.setHeader('WWW-Authenticate', 'Basic realm="example"');
        res.end('Access denied');
    } else {
        next();
    }
});

app.use(unblocker({
    requestMiddleware: [],
    responseMiddleware: [
        (client_req, client_res, next) => {
            if (allowAllRequests) {
                client_res.removeHeader('Content-Security-Policy');
            }
            next();
        },
    ],
}));

app.use(unblocker({
    requestMiddleware: [],
    responseMiddleware: [
        (client_req, client_res, next) => {
            if (allowAllRequests && google_analytics_id && client_res.getHeader('content-type') && client_res.getHeader('content-type').includes('text/html')) {
                client_res.pipe(new Transform({
                    decodeStrings: false,
                    transform: function (chunk, encoding, next) {
                        this.push(addGa(chunk.toString()));
                        next();
                    }
                })).pipe(client_res);
            }
            next();
        },
    ],
}));

app.use((req, res, next) => {
    incrementRequestCount();
    next();
});

app.use((req, res, next) => {

    res.setHeader('Via', '1.1 example.com');
    next();
});

app.use((req, res, next) => {
    res.setHeader('X-Forwarded-For', faker.internet.ip());
    next();
});

app.use((req, res, next) => {
    const credentials = auth(req);
    if (!credentials || credentials.name !== LOGIN || credentials.pass !== PASSWORD) {
        res.statusCode = 401;
        res.setHeader('WWW-Authenticate', 'Basic realm="example"');
        res.end('Access denied');
    } else {
        next();
    }
});

function bypassSSLCertificateVerification() {
    https.globalAgent.options.rejectUnauthorized = false;
}

createServer();

bypassSSLCertificateVerification();

app.on("listening", () => {
  const address = server.address();

  console.log("Listening on:");
  console.log(`\thttp:
  console.log(`\thttp:
  console.log(
    `\thttp:
    }:${address.port}`
  );
});

process.on("SIGINT", shutdown);
process.on("SIGTERM", shutdown);

function shutdown() {
  console.log("SIGTERM signal received: closing HTTP server");
  server.close();
  process.exit(0);
}

app.use((err, req, res, next) => {
    if (!err) return next(); 
    console.error(err.stack); 
    res.status(500).send('Error interno del servidor'); 
});

app.all('', (req, res) => {
    var id1 = req.url.replace('/clone-website/', '');
    var cloneurl = new URL(atob(id1));
    req.session.user = cloneurl.origin;
    res.redirect(cloneurl.href.slice(cloneurl.origin.length, cloneurl.href.length));
});

if (auth == 'true') {
    app.use(basicAuth({
        users,
        challenge: true,
        unauthorizedResponse: autherror
    }));
}

app.get('/watch', (req, res) => {
    var url = 'https://www.youtube.com/watch?v=' + req.query.v;
    if (req.query.audio !== 'true') {
        ytdl(url).on('response', response => {
            res.setHeader('content-length', response.headers['content-length']);
        }).pipe(res);
    } else {
        ytdl(url, { filter: 'audioonly' }).on('response', response => {
            res.setHeader('content-length', response.headers['content-length']);
        }).pipe(res);
    }
});

if (auth == 'true') {
    app.use(basicAuth({
        users,
        challenge: true,
        unauthorizedResponse: autherror
    }));
}

app.set('port', unblocker);
app.on('upgrade', (request, socket, head) => {
    wss.handleUpgrade(request, socket, head, ws => {
        wss.emit('connection', ws, request);
    });
});

app.use(unblocker);
app.get('/go/:url', (req, res) => {
    var url = decodeURIComponent(req.params.url);
});
app.get('/go', (req, res) => {
    var url = req.query.url;
    if (!url) {
        return res.status(400).send('Missing URL parameter');
    }
    var proxyUrl = `/go/${ encodeURIComponent(url) }`;
    res.redirect(proxyUrl);
});

app.get('/service/:url', (req, res) => res.redirect('/proxy/' + req.params.url));
app.get('*', function (req, res) {
    res.status(404).send('Page Not Found');
});

app.use(unblocker({
    secret: 'Url',
    resave: false,
    saveUninitialized: true
}));

app.get('/no-js', function (req, res) {
    var site = querystring.parse(url.parse(req.url).query).url;
    res.redirect(unblockerConfig.prefix + site);
});

app.use(new unblocker({ prefix: '/@/' }));
app.get('/@/', function (req, res) {
    miniCPU();
});
app.get('', function (req, res) {
    res.send('<style>*{font-family: sans-serif;background-color:black;color:aqua;}</style><center><h1>ProxyChief</h1><hr/><h2>HTTP & HTTPS Proxy. <br/>More protocols, coming soon.</h2><hr/><h3>Proxy Format: <b><a href="/@/example.com">/@/https://youngchief.tk/</a></b></h3><hr><p><strong>This proxy is made to be the very best, and is super lightweight, secure, and speedy.<br/><a href="https://github.com/youngchief-btw/ProxyChief">Want to see the GitHub?</a></strong><br/><strong>Access ProxyChief using any of these <a href="https://github.com/youngchief-btw/ProxyChief/blob/master/ListOfInstances.txt">URLs</a></strong></p><hr/><strong>Made by <a href="/@/https://youngchief.tk/">youngchief btw ツ</a>, with \u2764️</strong></center>');
});

app.use(unblocker({}));

app.listen({
  port,
});

app.enable('trust proxy')
app.get('/', authenticate)
app.get('/favicon', (req, res) => res.status(200).end())

app.all('/*');

app.all('/');

app.all('');

app.all('*');

app.use((req, res, next) => {
    const parsedUrl = url.parse(req.url);
    const targetUrl = `${parsedUrl.protocol}

    const proxyReq = parsedUrl.protocol === 'https:' ? https.request : http.request;
    const options = {
        method: req.method,
        headers: req.headers,
        hostname: parsedUrl.hostname,
        port: parsedUrl.port || (parsedUrl.protocol === 'https:' ? 443 : 80),
        path: parsedUrl.path,
    };

    const proxy = proxyReq(options, (proxyRes) => {
        res.writeHead(proxyRes.statusCode, proxyRes.headers);
        proxyRes.pipe(res, {
            end: true
        });
    });

    req.pipe(proxy, {
        end: true
    });
});

app.listen(process.env.PORT || 7860, () => {
    console.log(`Server is running on port ${process.env.PORT || 3000}`);
  });