const net = require('net');

// Приложение А ТЗ — запрещённые диапазоны
const BLOCKED_RANGES = [
  '10.0.0.0/8',
  '172.16.0.0/12',
  '192.168.0.0/16',
  '100.64.0.0/10',
  '127.0.0.0/8',
  '169.254.0.0/16',
  '192.0.0.0/24',
  '192.0.2.0/24',
  '198.51.100.0/24',
  '203.0.113.0/24',
  '198.18.0.0/15',
  '224.0.0.0/4',
  '240.0.0.0/4',
  '255.255.255.255/32',
];

/**
 * Проверить и нормализовать IPv4/CIDR.
 * Возвращает { cidr: 'x.x.x.x/yy', wasNormalized: bool }
 * или выбрасывает ошибку с понятным текстом.
 */
function validate(input) {
  const raw = (input || '').trim();
  if (!raw) throw new Error('Пустое значение');

  // Отсекаем IPv6 и доменные имена
  if (raw.includes(':')) throw new Error('IPv6 не поддерживается');
  if (/[a-zA-Z]/.test(raw.replace(/\./g, '').replace(/\//g, '').replace(/\d/g, '')))
    throw new Error('Некорректный формат');

  // Отсекаем множественные слэши
  if ((raw.match(/\//g) || []).length > 1) {
    throw new Error('Некорректный формат');
  }

  // Если нет маски — добавляем /32
  let cidr = raw.includes('/') ? raw : raw + '/32';

  const [addr, maskStr] = cidr.split('/');

  // Строгая проверка маски (parseInt глотает мусор: '24abc' → 24)
  if (!/^\d{1,2}$/.test(maskStr)) {
    throw new Error('Некорректная маска');
  }
  const mask = parseInt(maskStr, 10);

  if (mask < 22 || mask > 32) {
    throw new Error('Маска должна быть от /22 до /32');
  }

  if (!net.isIPv4(addr)) throw new Error('Некорректный IPv4 адрес');

  // Нормализация: обнуляем host-биты
  const ipNum = addr.split('.').reduce((acc, octet) => (acc << 8) + parseInt(octet, 10), 0) >>> 0;
  const netMask = ~((1 << (32 - mask)) - 1) >>> 0;
  const network = (ipNum & netMask) >>> 0;
  const networkAddr = [
    (network >>> 24) & 0xff,
    (network >>> 16) & 0xff,
    (network >>> 8) & 0xff,
    network & 0xff,
  ].join('.');

  const wasNormalized = addr !== networkAddr;
  const normalized = networkAddr + '/' + mask;

  // Проверка запрещённых диапазонов (overlaps ловит оба направления:
  // и запись внутри запрещённого блока, и суперсеть над ним)
  for (const blocked of BLOCKED_RANGES) {
    if (overlaps(normalized, blocked)) {
      throw new Error(`Диапазон ${normalized} пересекается с запрещённым (${blocked})`);
    }
  }

  return { cidr: normalized, wasNormalized };
}

/**
 * Проверить пересечение двух CIDR
 */
function overlaps(cidr1, cidr2) {
  const a = cidrToRange(cidr1);
  const b = cidrToRange(cidr2);
  // Каноническая формула пересечения двух отрезков: [a.start, a.end] ∩ [b.start, b.end] ≠ ∅
  return a.start <= b.end && b.start <= a.end;
}

/**
 * Проверить что cidr является подсетью parent
 */
function isSubnetOf(cidr, parent) {
  const child = cidrToRange(cidr);
  const par = cidrToRange(parent);
  return child.start >= par.start && child.end <= par.end;
}

function cidrToRange(cidr) {
  const [addr, maskStr] = cidr.split('/');
  const mask = parseInt(maskStr, 10);
  const ip = addr.split('.').reduce((acc, o) => (acc << 8) + parseInt(o, 10), 0) >>> 0;
  const start = ip >>> 0;
  const end = (ip | ((1 << (32 - mask)) - 1)) >>> 0;
  return { start, end };
}

/**
 * Конвертировать беззнаковое 32-битное число в строку IPv4.
 * Используется при обратном преобразовании диапазон → CIDR.
 */
function numToIP(n) {
  return [
    (n >>> 24) & 0xff,
    (n >>> 16) & 0xff,
    (n >>> 8)  & 0xff,
    n & 0xff,
  ].join('.');
}

/**
 * Преобразовать числовой диапазон [start, end] (unsigned 32-bit) в
 * минимальный набор CIDR-блоков.
 *
 * Алгоритм: для каждой текущей позиции ищем наибольший выровненный блок,
 * начинающийся в cur и не выходящий за end. «Выровненный» — значит cur
 * является адресом сети (host-биты = 0) для данного префикса.
 * Кол-во trailing zeros в cur определяет максимально допустимый блок.
 *
 * @param {number} start — uint32 начало диапазона
 * @param {number} end   — uint32 конец диапазона (включительно)
 * @returns {string[]}   массив строк вида '1.2.3.4/24'
 */
function rangeToCIDRs(start, end) {
  const cidrs = [];
  let cur = start >>> 0;
  const endU = end >>> 0;

  while (cur <= endU) {
    // Считаем кол-во trailing zeros в cur — они дают максимальный
    // выровненный блок, который может начинаться с этого адреса.
    let trailingZeros = 0;
    if (cur === 0) {
      trailingZeros = 32; // 0.0.0.0 выровнен на любой блок
    } else {
      let tmp = cur;
      while ((tmp & 1) === 0 && trailingZeros < 32) {
        tmp = tmp >>> 1;
        trailingZeros++;
      }
    }

    // Начинаем с максимально выровненного блока и сужаем,
    // пока блок не поместится в [cur, endU].
    let prefix = 32 - trailingZeros;
    while (prefix <= 32) {
      const hostBits = 32 - prefix;
      // blockEnd = cur + 2^hostBits - 1; для /32 blockEnd = cur
      const blockEnd = hostBits > 0 ? (cur + Math.pow(2, hostBits) - 1) >>> 0 : cur;
      if (blockEnd <= endU) break;
      prefix++;
    }

    cidrs.push(numToIP(cur) + '/' + prefix);

    // Шагаем к следующему блоку
    const hostBits = 32 - prefix;
    if (hostBits === 0) {
      // /32 — шаг ровно один адрес
      if (cur === 0xFFFFFFFF) break; // последний адрес IPv4
      cur = (cur + 1) >>> 0;
    } else {
      const blockSize = Math.pow(2, hostBits);
      cur = (cur + blockSize) >>> 0;
      if (cur === 0) break; // переполнение uint32 — весь диапазон пройден
    }
  }

  return cidrs;
}

/**
 * Агрегировать (суммаризировать) массив CIDR-строк в минимальный
 * эквивалентный набор без пересечений.
 *
 * Шаги:
 *   1. Конвертируем каждый CIDR в числовой диапазон [start, end].
 *   2. Сортируем диапазоны по start.
 *   3. Объединяем пересекающиеся и смежные диапазоны — scan-line merge.
 *   4. Каждый слитый диапазон → минимальный набор CIDR (rangeToCIDRs).
 *
 * Используется в /export: все компании суммаризируются совместно по ТЗ.
 *
 * @param {string[]} cidrs — массив строк вида '1.2.3.4/24'
 * @returns {string[]}     минимальный набор CIDR в порядке возрастания
 */
function aggregateCIDRs(cidrs) {
  if (!cidrs || cidrs.length === 0) return [];

  // Шаг 1: CIDR → числовые диапазоны
  const ranges = cidrs.map(cidrToRange);

  // Шаг 2: сортировка по start (числа ≤ 2^32, безопасно сравнивать как float)
  ranges.sort((a, b) => {
    if (a.start < b.start) return -1;
    if (a.start > b.start) return 1;
    return 0;
  });

  // Шаг 3: scan-line merge — объединяем перекрывающиеся и смежные диапазоны
  const merged = [{ start: ranges[0].start, end: ranges[0].end }];
  for (let i = 1; i < ranges.length; i++) {
    const last = merged[merged.length - 1];
    const cur = ranges[i];
    // «Смежные» означает cur.start === last.end + 1 (без зазора)
    // Защита от переполнения: last.end === 0xFFFFFFFF — следующего нет
    const adjacent = last.end < 0xFFFFFFFF && cur.start === last.end + 1;
    if (cur.start <= last.end || adjacent) {
      // Поглощаем cur в last (расширяем если cur заходит дальше)
      if (cur.end > last.end) last.end = cur.end;
    } else {
      // Новый несмежный диапазон
      merged.push({ start: cur.start, end: cur.end });
    }
  }

  // Шаг 4: каждый слитый диапазон → минимальный набор CIDR
  const result = [];
  for (const range of merged) {
    result.push(...rangeToCIDRs(range.start, range.end));
  }
  return result;
}

module.exports = { validate, overlaps, BLOCKED_RANGES, aggregateCIDRs };