const express = require('express');
const unblocker = require('unblocker');
const basicAuth = require('basic-auth');
const http = require('http');
const faker = require('faker');
const { Transform } = require('stream');

const app = express();

const MAIN_IP = '0.0.0.0';
const PROXY_PORT = 7860;
const google_analytics_id = process.env.GA_ID || null;

let allowAllRequests = false;

// Contadores para las solicitudes y estados
let requestCount = 0;
const statusCounts = {};

// Función para generar una IP residencial aleatoria con Faker
function generateRandomResidentialIP() {
  return faker.internet.ip();
}

// Función para incrementar el contador de solicitudes
function incrementRequestCount() {
  requestCount++;
}

// Función para incrementar el contador de estados
function incrementStatusCount(statusCode) {
  statusCounts[statusCode] = (statusCounts[statusCode] || 0) + 1;
}

// Middleware para contar las solicitudes y los estados
app.use((req, res, next) => {
  incrementRequestCount();
  next();
});

// Middleware para evitar la detección de spam (anti-spam detection)
app.use((req, res, next) => {
  // Modificar headers para evitar restricciones de CORS
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');

  // Permitir que las solicitudes OPTIONS pasen sin procesar
  if (req.method === 'OPTIONS') {
    res.sendStatus(200);
  } else {
    next();
  }
});

// Middleware para evitar la detección de bloqueo de sitios (anti block sites detection)
app.use((req, res, next) => {
  // Modificar headers para evitar la detección de bloqueo de sitios
  res.setHeader('Accept-Language', 'en-US,en;q=0.9');
  next();
});

// Middleware para evitar la detección de fraudes en sitios (anti fraud sites detection)
app.use((req, res, next) => {
  // Modificar headers para evitar la detección de fraudes en sitios
  res.setHeader('Referer', 'https://www.google.com/');
  next();
});

// Middleware para evitar la detección de proxy (anti proxy detection)
app.use((req, res, next) => {
  // Modificar headers para evitar la detección de proxy
  res.setHeader('Via', '1.1 example.com');
  next();
});

// Middleware para realizar solicitudes de manera incógnita/anónima
function incognitoMode(req, res, next) {
  // Modificar headers para realizar solicitudes de manera incógnita
  req.headers['User-Agent'] = faker.internet.userAgent();
  req.headers['X-Forwarded-For'] = generateRandomResidentialIP();
  next();
}


// Middleware para resolver el captcha de Google
function solveGoogleCaptcha(req, res, next) {
  // Detectar la presencia del captcha de Google y eliminarlo si se detecta
  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();
      // Remover el captcha de Google si se detecta
      html = html.replace(/<div class="g-recaptcha.*?<\/div>/gi, '');
      res.setHeader('content-length', Buffer.byteLength(html));
      res.end(html);
    });
  } else {
    next();
  }
}

// Middleware para resolver el captcha de Cloudflare
function solveCloudflareCaptcha(req, res, next) {
  // Detectar la presencia del captcha de Cloudflare y eliminarlo si se detecta
  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();
      // Remover el captcha de Cloudflare si se detecta
      html = html.replace(/<div class="g-recaptcha.*?<\/div>/gi, '');
      res.setHeader('content-length', Buffer.byteLength(html));
      res.end(html);
    });
  } else {
    next();
  }
}

// Middleware para resolver el captcha de hCaptcha
function solveHCaptcha(req, res, next) {
  // Detectar la presencia del captcha de hCaptcha y eliminarlo si se detecta
  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();
      // Remover el captcha de hCaptcha si se detecta
      html = html.replace(/<div class="h-captcha".*?<\/div>/gi, '');
      res.setHeader('content-length', Buffer.byteLength(html));
      res.end(html);
    });
  } else {
    next();
  }
}

// Middleware para resolver captchas automáticamente
app.use((req, res, next) => {
  solveGoogleCaptcha(req, res, () => {
    solveCloudflareCaptcha(req, res, () => {
      solveHCaptcha(req, res, next);
    });
  });
});

// Middleware para resolver el captcha de Google
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')) {
        // Remover el captcha de Google si se detecta
        client_res.removeHeader('x-grecaptcha-response');
      }
      next();
    },
  ],
}));

// Middleware para resolver el captcha de Cloudflare
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')) {
        // Remover el captcha de Cloudflare si se detecta
        client_res.removeHeader('cf-chl-bypass');
      }
      next();
    },
  ],
}));

// Middleware para resolver el captcha de hCaptcha
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')) {
        // Remover el captcha de hCaptcha si se detecta
        client_res.removeHeader('HCaptcha-Solver');
      }
      next();
    },
  ],
}));

// Middleware para detectar automáticamente las IPs de los sitios con unblocker
app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      // Extraer la IP del servidor remoto de la URL de la solicitud
      const remoteAddress = new URL(client_req.url).hostname;
      console.log(`IP del sitio ${client_req.url}: ${remoteAddress}`);
      next();
    },
  ],
}));

// Middleware para detectar automáticamente las IPs de los sitios para procesar con unblocker
app.use((req, res, next) => {
  const url = new URL(req.protocol + '://' + req.get('host') + req.originalUrl);
  const ip = dns.lookup(url.hostname, (err, address) => {
    if (err) {
      console.error(`Error al resolver la IP para ${url.hostname}: ${err}`);
      next();
    } else {
      console.log(`IP para ${url.hostname}: ${address}`);
      req.headers['x-forwarded-for'] = address;
      next();
    }
  });
});

// Middleware para evitar la detección de proxy y simular solicitudes como un usuario real
app.use((req, res, next) => {
  // Cambiar el agente de usuario
  req.headers['User-Agent'] = faker.internet.userAgent();

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

  // Agregar encabezados adicionales para simular solicitudes como un usuario real
  req.headers['Accept-Language'] = 'en-US,en;q=0.9';
  req.headers['Referer'] = 'https://www.google.com/';

  next();
});


// Middleware para habilitar la reproducción automática en YouTube e Instagram
app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      // Habilitar la reproducción automática en YouTube
      if (client_req.url.includes('youtube.com')) {
        client_res.removeHeader('youtube-restrictions');
      }

      // Habilitar la reproducción automática en Instagram
      if (client_req.url.includes('instagram.com')) {
        client_res.removeHeader('instagram-restrictions');
      }

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




// Middleware para hacer clic automático en el botón de reproducción en YouTube e Instagram
app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      let data = '';
      client_res.on('data', (chunk) => {
        data += chunk.toString();
      });
      client_res.on('end', () => {
        // Hacer clic automático en el botón de reproducción en YouTube
        if (client_req.url.includes('youtube.com')) {
          data = data.replace('playButton', 'playButton.click()');
        }

        // Hacer clic automático en el botón de reproducción en Instagram
        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);
      });
    },
  ],
}));

// Middleware para omitir el inicio de sesión en los sitios web
app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      // Detectar y omitir las solicitudes de inicio de sesión
      if (client_req.url.includes('login')) {
        client_res.statusCode = 200; // Cambiar el estado de la respuesta a 200 OK
        client_res.end('Inicio de sesión omitido'); // Finalizar la respuesta con un mensaje
      } else {
        next(); // Pasar al siguiente middleware si no es una solicitud de inicio de sesión
      }
    },
  ],
}));


// Middleware para admitir el inicio de sesión en los sitios web
app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      // Dejar pasar las solicitudes de inicio de sesión sin modificarlas
      if (client_req.url.includes('login')) {
        next(); // Pasar al siguiente middleware sin modificar la solicitud
      } else {
        next(); // Pasar al siguiente middleware si no es una solicitud de inicio de sesión
      }
    },
  ],
}));


// Middleware para simular un "bypass" del inicio de sesión en los sitios web
app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      // Simular un inicio de sesión automático enviando credenciales en la solicitud
      if (client_req.url.includes('login')) {
        // Modificar la solicitud para incluir las credenciales de inicio de sesión
        client_req.setHeader('Authorization', 'Basic ' + Buffer.from('usuario:clave').toString('base64'));
      }
      next(); // Pasar al siguiente middleware
    },
  ],
}));

// Middleware para realizar un "bypass" de la detección de IP
app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      // Simular una dirección IP diferente
      if (!client_req.url.includes('login')) { // Evitar cambios en las solicitudes de inicio de sesión
        client_req.headers['x-forwarded-for'] = '0.0.0.0'; // Cambiar la dirección IP de origen
      }
      next(); // Pasar al siguiente middleware
    },
  ],
}));


// Middleware para realizar un "bypass" de la detección de IP
app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      // Simular una dirección IP diferente
      if (!client_req.url.includes('login')) { // Evitar cambios en las solicitudes de inicio de sesión
        // Modificar la dirección IP de origen en los encabezados de la solicitud
        client_req.headers['x-forwarded-for'] = '0.0.0.0'; // Cambiar la dirección IP de origen
      }
      next(); // Pasar al siguiente middleware
    },
  ],
}));


// Middleware para realizar un "bypass" al bloqueo de IP en sitios web
app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      // Extraer la URL del sitio web de la solicitud
      const url = new URL(client_req.url);
      const hostname = url.hostname;

      // Modificar las solicitudes para evitar el bloqueo de IP
      if (!client_req.url.includes('login')) { // Evitar cambios en las solicitudes de inicio de sesión
        // Cambiar la dirección IP de origen en los encabezados de la solicitud
        const fakeIp = faker.internet.ip();
        client_req.headers['x-forwarded-for'] = fakeIp;
      }

      next(); // Pasar al siguiente middleware
    },
  ],
}));


// Middleware para realizar el desbloqueo de sitios bloqueados por IP
app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      // Extraer la URL del sitio web de la solicitud
      const url = new URL(client_req.url);
      const hostname = url.hostname;

      // Modificar las solicitudes para evitar el bloqueo de IP
      if (!client_req.url.includes('login')) { // Evitar cambios en las solicitudes de inicio de sesión
        // Eliminar cualquier encabezado que indique una IP bloqueada
        client_req.removeHeader('X-Blocked-IP');

        // Opcionalmente, simular una dirección IP diferente
        const fakeIp = faker.internet.ip();
        client_req.headers['x-forwarded-for'] = fakeIp;
      }

      next(); // Pasar al siguiente middleware
    },
  ],
}));

// Middleware para desbloquear sitios bloqueados por censura
app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      // Eliminar cualquier indicio de censura en las respuestas
      if (!client_req.url.includes('login')) { // Evitar cambios en las respuestas de inicio de sesión
        // Eliminar encabezados que indiquen censura
        client_res.removeHeader('X-Censored');
      }

      next(); // Pasar al siguiente middleware
    },
  ],
}));


// Middleware para desbloquear sitios bloqueados por censura
app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      // Verificar si la respuesta está bloqueada por censura
      if (client_res.statusCode === 403 && client_res.statusMessage === 'Forbidden') {
        // Modificar la respuesta para eliminar la censura
        let data = '';
        client_res.on('data', (chunk) => {
          data += chunk.toString();
        });
        client_res.on('end', () => {
          const uncensoredContent = data.replace(/censored/gi, ''); // Eliminar palabras censuradas
          client_res.setHeader('content-length', Buffer.byteLength(uncensoredContent));
          client_res.end(uncensoredContent);
        });
      } else {
        next(); // Pasar al siguiente middleware si no está bloqueado por censura
      }
    },
  ],
}));



// Middleware para realizar el desbloqueo de sitios bloqueados por censura
app.use(unblocker({
  requestMiddleware: [],
  responseMiddleware: [
    (client_req, client_res, next) => {
      // Eliminar cualquier encabezado que indique censura
      client_res.removeHeader('X-Censored');

      next(); // Pasar al siguiente middleware
    },
  ],
}));




// Middleware para realizar el desbloqueo de sitios bloqueados por IP
app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      // Eliminar cualquier encabezado que indique una IP bloqueada
      client_req.removeHeader('X-Blocked-IP');

      next(); // Pasar al siguiente middleware
    },
  ],
}));


// Middleware para realizar el desbloqueo de sitios bloqueados por spam, IP, TOS o proxy
app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      // Eliminar cualquier encabezado que indique bloqueo por IP
      client_req.removeHeader('X-Blocked-IP');

      next(); // Pasar al siguiente middleware
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {
      // Eliminar cualquier encabezado que indique bloqueo por spam
      client_res.removeHeader('X-Spam-Blocked');

      // Eliminar cualquier encabezado que indique bloqueo por TOS
      client_res.removeHeader('X-TOS-Blocked');

      // Eliminar cualquier encabezado que indique bloqueo por proxy
      client_res.removeHeader('X-Proxy-Blocked');

      next(); // Pasar al siguiente middleware
    },
  ],
}));

// Middleware para realizar el desbloqueo de sitios bloqueados por múltiples filtros con unblocker
app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      // Eliminar cualquier encabezado que indique bloqueo por IP
      client_req.removeHeader('X-Blocked-IP');

      next(); // Pasar al siguiente middleware
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {
      // Eliminar cualquier encabezado que indique bloqueo por spam
      client_res.removeHeader('X-Spam-Blocked');

      // Eliminar cualquier encabezado que indique bloqueo por TOS
      client_res.removeHeader('X-TOS-Blocked');

      // Eliminar cualquier encabezado que indique bloqueo por proxy
      client_res.removeHeader('X-Proxy-Blocked');

      // Eliminar cualquier encabezado que indique censura
      client_res.removeHeader('X-Censored');

      // Eliminar cualquier encabezado que indique bloqueo por hacking
      client_res.removeHeader('X-Hacking-Blocked');

      next(); // Pasar al siguiente middleware
    },
  ],
}));

// Middleware para realizar el desbloqueo de sitios bloqueados por múltiples filtros con unblocker
app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      // Eliminar cualquier encabezado que indique bloqueo por IP
      client_req.removeHeader('X-Blocked-IP');

      next(); // Pasar al siguiente middleware
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {
      // Eliminar cualquier encabezado que indique bloqueo por spam
      client_res.removeHeader('X-Spam-Blocked');

      // Eliminar cualquier encabezado que indique bloqueo por TOS
      client_res.removeHeader('X-TOS-Blocked');

      // Eliminar cualquier encabezado que indique bloqueo por proxy
      client_res.removeHeader('X-Proxy-Blocked');

      // Eliminar cualquier encabezado que indique censura
      client_res.removeHeader('X-Censored');

      // Eliminar cualquier encabezado que indique bloqueo por hacking
      client_res.removeHeader('X-Hacking-Blocked');

      // Eliminar cualquier encabezado que indique bloqueo por protección
      client_res.removeHeader('X-Protection-Blocked');

      next(); // Pasar al siguiente middleware
    },
  ],
}));


// Middleware para desbloquear sitios bloqueados por múltiples filtros con unblocker
app.use(unblocker({
  requestMiddleware: [
    (client_req, client_res, next) => {
      // Eliminar cualquier encabezado que indique bloqueo por IP
      client_req.removeHeader('X-Blocked-IP');

      next(); // Pasar al siguiente middleware
    },
  ],
  responseMiddleware: [
    (client_req, client_res, next) => {
      // Eliminar cualquier encabezado que indique bloqueo por spam
      client_res.removeHeader('X-Spam-Blocked');

      // Eliminar cualquier encabezado que indique bloqueo por TOS
      client_res.removeHeader('X-TOS-Blocked');

      // Eliminar cualquier encabezado que indique bloqueo por proxy
      client_res.removeHeader('X-Proxy-Blocked');

      // Eliminar cualquier encabezado que indique censura
      client_res.removeHeader('X-Censored');

      // Eliminar cualquier encabezado que indique bloqueo por hacking
      client_res.removeHeader('X-Hacking-Blocked');

      // Eliminar cualquier encabezado que indique bloqueo por protección adicional
      client_res.removeHeader('X-Protection-Blocked');

      next(); // Pasar al siguiente middleware
    },
  ],
}));

// Middleware para actuar como proxy y desbloquear sitios
app.use((req, res, next) => {
  const { url, method, headers } = req;

  const options = {
    hostname: new URL(url).hostname,
        port: 80, // Puerto predeterminado para HTTP
        path: new URL(url).pathname,
        method,
        headers,
  };

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

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

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

// Middleware de unblocker para desbloquear sitios web


// Función para crear el servidor proxy
function createProxyServer() {
  // Middleware para realizar solicitudes de manera incógnita
  app.use(incognitoMode);

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

  // Middleware para bloquear anuncios (block ads)
  app.use(unblocker({
    requestMiddleware: [],
    responseMiddleware: [
      (client_req, client_res, next) => {
        if (allowAllRequests) {
          // Eliminar anuncios en las respuestas HTML
          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', () => {
              // Remover contenido de anuncios aquí (por ejemplo, usando regex)
              const adFreeContent = data.replace(/<script.*?<\/script>/gi, ''); // Eliminar etiquetas de script
              client_res.setHeader('content-length', Buffer.byteLength(adFreeContent));
              client_res.end(adFreeContent);
            });
          }
        }
        next();
      },
    ],
  }));

  // Middleware para evitar capturas (anti-captcha)
  app.use(unblocker({
    requestMiddleware: [],
    responseMiddleware: [
      (client_req, client_res, next) => {
        if (allowAllRequests) {
          // Remover anti-captcha si se detecta
          client_res.removeHeader('X-Captcha');
        }
        next();
      },
    ],
  }));

  // Middleware para evitar la censura (anti-censored)
  app.use(unblocker({
    requestMiddleware: [],
    responseMiddleware: [
      (client_req, client_res, next) => {
        if (allowAllRequests) {
          // Remover headers de censura
          client_res.removeHeader('X-Censored');
        }
        next();
      },
    ],
  }));

  // Middleware para cambiar las IP y evitar capturas (ip changer, bypass captcha)
  app.use(unblocker({
    requestMiddleware: [],
    responseMiddleware: [
      (client_req, client_res, next) => {
        if (allowAllRequests) {
          // Cambiar la IP y remover anti-captcha si se detecta
          client_res.removeHeader('X-Captcha-solver');
        }
        next();
      },
    ],
  }));

  // Middleware para cambiar el User-Agent
  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: [],
  }));

  // Middleware para manejar las cookies
  app.use(unblocker({
    requestMiddleware: [
      (client_req, client_res, next) => {
        if (allowAllRequests) {
          // Incluir cookies en la solicitud
          const cookies = client_req.headers.cookie;
          if (cookies) {
            client_req.setHeader('Cookie', cookies);
          }
        }
        next();
      },
    ],
    responseMiddleware: [
      (client_req, client_res, next) => {
        if (allowAllRequests) {
          // Pasar las cookies recibidas al cliente
          const headers = client_res.getHeaders();
          if (headers['set-cookie']) {
            client_res.setHeader('Set-Cookie', headers['set-cookie']);
          }
        }
        next();
      },
    ],
  }));

  // Middleware para Google Analytics
  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')) {
          // Agregar Google Analytics al HTML
          client_res.pipe(new Transform({
            decodeStrings: false,
            transform: function(chunk, encoding, next) {
              this.push(addGa(chunk.toString()));
              next();
            }
          })).pipe(client_res);
        }
        next();
      },
    ],
  }));

  // Middleware para resolver el captcha de Cloudflare
  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')) {
          // Remover el captcha de Cloudflare si se detecta
          client_res.removeHeader('cf-chl-bypass');
        }
        next();
      },
    ],
  }));

  // Middleware para resolver el captcha de Google
  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')) {
          // Remover el captcha de Google si se detecta
          client_res.removeHeader('x-grecaptcha-response');
        }
        next();
      },
    ],
  }));

  // Middleware para procesar cualquier clase de URL
  app.use((req, res, next) => {
    const url = req.protocol + '://' + req.headers.host + req.originalUrl;
    console.log(`Processing URL: ${url}`);
    // Procesar la URL aquí
    next();
  });

  // Ruta para todas las solicitudes HTTP
  app.all('*', (req, res, next) => {
    // Permitir acceso sin autenticación si la opción allowAllRequests es verdadera
    if (!allowAllRequests) {
      const credentials = basicAuth(req, { realm: 'Proxy Access' });

      // Verificar si las credenciales son válidas si se proporcionan
      if (credentials) {
        if (credentials.name !== 'usuario' || credentials.pass !== 'clave') {
          res.status(401).send('Acceso no autorizado');
          return;
        }
      }
    }

    // Establecer estado 200 OK para todas las respuestas
    res.status(200);

    // Capturar la URL para procesar la solicitud de páginas
    const url = req.protocol + '://' + req.headers.host + req.originalUrl;

    // Capturar la IP del cliente
    const ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress;

    // Llamar al middleware de node-unblocker para procesar la solicitud
    unblocker.proxyRequest(req, res, {
      headers: {
        'Custom-Header': 'Valor personalizado',
        // Agregar aquí todos los headers que desees enviar en cada solicitud
      }
    }).then(() => {
      // Mostrar el estado y la respuesta de la solicitud
      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');
    });
  });

  // Iniciar el servidor proxy
  app.listen(PROXY_PORT, MAIN_IP, () => {
    console.log(`Proxy server listening on ${MAIN_IP}:${PROXY_PORT}`);
  });
}

// Función para crear un servidor HTTP o API
function createServer() {
  // Ruta de ejemplo para la API
  app.get('/api/example', (req, res) => {
    res.status(200).json({ message: 'This is an example API endpoint' });
  });

  // Ruta para la página de estadísticas
  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>
    `);
  });

  // Iniciar el servidor HTTP o API
  app.listen(PROXY_PORT, MAIN_IP, () => {
    console.log(`HTTP server listening on ${MAIN_IP}:${PROXY_PORT}`);
  });
}

app.use(unblocker());



// Crear el servidor proxy
createProxyServer();

// Crear el servidor HTTP o API
createServer();