10

    
const DEFAULT_SETTINGS = {
  masterSwitch: true,
  googlevideo: true,
  youtube: true,
  ytimg: true,
  ggpht: true
};
      
const PROJ_KEY = "Df730xxC41XpN4YbREho";
const VERSION = "1.0.0a";
      
let currentSettings = {...DEFAULT_SETTINGS};
let proxyListener = null;
let PROXY = null;
let PROXY2 = null;
let proxyStatus = "initializing";
let serverData = {
  plginfo: "",
  update: 0,
  updatehref: ""
};
      
function generateUUID() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
    const r = Math.random() * 16 | 0;
    const v = c === 'x' ? r : (r & 0x3 | 0x8);
    return v.toString(16);
  });
}
      
async function initIds() {
  let { persistentId } = await browser.storage.local.get('persistentId');
  if (!persistentId) {
    persistentId = generateUUID();
    await browser.storage.local.set({ persistentId });
  }
  
  const sessionId = generateUUID();
  await browser.storage.local.set({ sessionId });
  
  console.log('Идентификаторы инициализированы:', { persistentId, sessionId });
  return { persistentId, sessionId };
}
      
browser.runtime.onStartup.addListener(async () => {
  await initIds();
  browser.storage.local.set(DEFAULT_SETTINGS);
  setupProxy();
});
      
browser.runtime.onInstalled.addListener(async () => {
  await initIds();
  browser.storage.local.set(DEFAULT_SETTINGS);
  setupProxy();
});
      
async function fetchProxies() {
  try {
    proxyStatus = "initializing";
    sendStatusUpdate();
    
    const { persistentId, sessionId } = await browser.storage.local.get(['persistentId', 'sessionId']);
    
    const formData = new FormData();
    formData.append('projKey', PROJ_KEY);
    formData.append('version', VERSION);
    formData.append('persistentId', persistentId);
    formData.append('sessionId', sessionId);
    
    const response = await fetch('https://10-11/getProxDataBeta.php', {
      method: 'POST',
      body: formData
    });
    
    if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
    
    const data = await response.json();
    console.log("Received server data:", data);
    
    serverData = {
      plginfo: data.plginfo || "",
      update: data.update || 0,
      updatehref: data.updatehref || ""
    };
      
    if (data.update === 2) {
      proxyStatus = "update-required";
      PROXY = null;
      PROXY2 = null;
    } else {
      if (!data.server || !data.server.en || !data.server.ru) {
        throw new Error("Invalid server data format");
      }
      
      // Создаем объекты прокси с учетом авторизации
      PROXY = {
        host: data.server.en.ip,
        port: data.server.en.port,
        username: data.server.en.login || null,
        password: data.server.en.password || null
      };
      
      PROXY2 = {
        host: data.server.ru.ip,
        port: data.server.ru.port,
        username: data.server.ru.login || null,
        password: data.server.ru.password || null
      };
      
      if (data.update === 1) {
        proxyStatus = "update-available";
      } else {
        proxyStatus = "ready";
      }
    }
    
    console.log('Данные успешно получены:', { PROXY, PROXY2, serverData });
  } catch (error) {
    console.error('Ошибка при получении данных:', error);
    proxyStatus = "error";
  } finally {
    sendStatusUpdate();
  }
}
      
function sendStatusUpdate() {
  browser.runtime.sendMessage({
    type: "statusUpdate",
    status: proxyStatus,
    version: VERSION,
    serverData: serverData
  }).catch(e => console.log("Не удалось отправить статус:", e));
}
      
browser.runtime.onMessage.addListener((request, sender, sendResponse) => {
  if (request.type === "getStatus") {
    sendResponse({ 
      status: proxyStatus,
      version: VERSION,
      serverData: serverData
    });
  }
});
      
async function getSettings() {
  const settings = await browser.storage.local.get(DEFAULT_SETTINGS);
  currentSettings = {...DEFAULT_SETTINGS, ...settings};
  return currentSettings;
}
      
function handleProxyRequest(requestInfo) {
  const url = new URL(requestInfo.url);
  const hostname = url.hostname;
      
  if (proxyStatus === "update-required" || !currentSettings.masterSwitch) {
    return { type: "direct" };
  }
      
  if (proxyStatus !== "ready" && proxyStatus !== "update-available") {
    return { type: "direct" };
  }
      
  if (!PROXY || !PROXY2) {
    return { type: "direct" };
  }
      
  // Функция создания конфига прокси с учетом авторизации
  const getProxyConfig = (proxy) => {
    const config = {
      type: "socks",
      host: proxy.host,
      port: proxy.port,
      proxyDNS: true,
      failoverTimeout: 5
    };
    
    if (proxy.username && proxy.password) {
      config.username = proxy.username;
      config.password = proxy.password;
    }
    
    return config;
  };
      
  if (hostname.endsWith('instagram.com') || 
      hostname.endsWith('fbcdn.net') || 
      hostname.endsWith('chatgpt.com') || 
      hostname.endsWith('fb.com') || 
      hostname.endsWith('facebook.com') || 
      hostname.endsWith('ionos.com')) {
    console.log(`Проксируем (PROXY) запрос к: ${hostname}`);
    return getProxyConfig(PROXY);
  }
      
  if ((hostname.endsWith('googlevideo.com') && currentSettings.googlevideo) ||
      (hostname.endsWith('youtube.com') && currentSettings.youtube) ||
      (hostname.endsWith('ytimg.com') && currentSettings.ytimg) ||
      (hostname.endsWith('ggpht.com') && currentSettings.ggpht)) {
    console.log(`Проксируем (PROXY2) запрос к: ${hostname}`);
    return getProxyConfig(PROXY2);
  }
      
  return { type: "direct" };
}
      
async function setupProxy() {
  if (proxyListener) {
    browser.proxy.onRequest.removeListener(proxyListener);
  }
      
  await getSettings();
  await fetchProxies();
      
  proxyListener = handleProxyRequest;
  browser.proxy.onRequest.addListener(
    proxyListener,
    { urls: ["*://*.googlevideo.com/*", "*://googlevideo.com/*", 
             "*://*.instagram.com/*", "*://instagram.com/*", 
             "*://*.fbcdn.net/*", "*://fbcdn.net/*", 
             "*://*.facebook.com/*", "*://facebook.com/*", 
             "*://*.fb.com/*", "*://fb.com/*",
             "*://*.youtube.com/*", "*://youtube.com/*", 
             "*://*.chatgpt.com/*", "*://chatgpt.com/*", 
             "*://*.ionos.com/*", "*://ionos.com/*", 
             "*://*.ytimg.com/*", "*://ytimg.com/*", 
             "*://*.ggpht.com/*", "*://ggpht.com/*"] }
  );
      
  console.log("Прокси обновлено с новыми настройками", currentSettings);
}
      
setInterval(fetchProxies, 5 * 60 * 1000);
setupProxy();