Ищем таргеты из выгрузки живых портов

import os
import re
import requests
import warnings
import concurrent.futures
import time
from urllib.parse import quote
from datetime import datetime
from pathlib import Path

# --- ИМПОРТ И ПРЕДУПРЕЖДЕНИЙ ---
from urllib3.exceptions import InsecureRequestWarning
warnings.filterwarnings("ignore", category=InsecureRequestWarning)

# --- Конфигурация ---
INPUT_DIR = "./input"  # Каталог с входными файлами
OUTPUT_DIR = "./output" # Каталог для результатов (только 200 OK)
OUTPUT_FULL_DIR = "./output_full" # Каталог для подробных логов (только ошибки)
OUTPUT_DONT_WORKED_DIR = "./output_dont_worked" # Каталог для всех обработанных URL
FORTINET_PATH = "/remote/login"  # Путь для проверки
TIMEOUT = 10  # Увеличим таймаут до 10 секунд, если сервера медленные
USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.6613.120 Safari/537.36"
THREADS = 25 # Уменьшено количество потоков
CHUNK_SIZE = 100 # Уменьшено количество URL в одном чанке

# Цвета для вывода в терминал (работает в терминалах, поддерживающих ANSI)
COLOR_RED = "\033[91m"
COLOR_GREEN = "\033[92m"
COLOR_BLUE = "\033[94m"
COLOR_YELLOW = "\033[93m"
COLOR_CYAN = "\033[96m"
COLOR_RESET = "\033[0m"

def log_failure_details(full_log_file_path, target_url, start_time, end_time, status_code_or_error, response_text_summary=""):
    """Записывает подробную информацию о НЕУДАЧНОМ запросе в общий лог-файл для страны."""
    with open(full_log_file_path, 'a', encoding='utf-8') as f:
        f.write(f"--- Failed Request Log ---\n")
        f.write(f"Target URL: {target_url}\n")
        f.write(f"Start Time: {datetime.fromtimestamp(start_time).strftime('%Y-%m-%d %H:%M:%S.%f')}\n")
        f.write(f"End Time: {datetime.fromtimestamp(end_time).strftime('%Y-%m-%d %H:%M:%S.%f')}\n")
        f.write(f"Duration: {end_time - start_time:.2f}s\n")
        f.write(f"Error/Status: {status_code_or_error}\n")
        if response_text_summary:
            f.write(f"Response Summary (first 200 chars): {response_text_summary[:200]}\n")
        f.write(f"Result: FAILED\n")
        f.write(f"-------------------------\n\n")

def process_single_url(args):
    """Обрабатывает один URL. Функция, выполняемая в потоке."""
    extracted_url, full_log_file_path = args
    target_url = extracted_url + FORTINET_PATH
    start_time = time.time()

    try:
        response = requests.get(
            target_url,
            headers={'User-Agent': USER_AGENT},
            verify=False,
            timeout=TIMEOUT
        )
        request_time = time.time() - start_time

        if response.status_code == 200:
            print(f"    {COLOR_GREEN}[+] 200 OK за {request_time:.2f}s для: {target_url}{COLOR_RESET}")
            return extracted_url, True, response.status_code
        else:
            print(f"    {COLOR_RED}[-] Код {response.status_code} за {request_time:.2f}s для: {target_url}{COLOR_RESET}")
            response_summary = response.text if response.text else "[No response body]"
            log_failure_details(full_log_file_path, target_url, start_time, time.time(), response.status_code, response_summary)
            return extracted_url, False, response.status_code

    except requests.exceptions.Timeout:
        error_msg = f"Timeout after {TIMEOUT}s"
        print(f"    {COLOR_RED}[ОШИБКА ТАЙМАУТ] {target_url} ({error_msg}){COLOR_RESET}")
        log_failure_details(full_log_file_path, target_url, start_time, time.time(), error_msg)
        return extracted_url, False, error_msg

    except requests.exceptions.RequestException as e:
        error_msg = str(e)
        print(f"    {COLOR_RED}[ОШИБКА ЗАПРОСА] {target_url}: {error_msg}{COLOR_RESET}")
        log_failure_details(full_log_file_path, target_url, start_time, time.time(), error_msg)
        return extracted_url, False, error_msg

    except Exception as e:
        error_msg = str(e)
        print(f"    {COLOR_RED}[НЕИЗВЕСТНАЯ ОШИБКА] {target_url}: {error_msg}{COLOR_RESET}")
        log_failure_details(full_log_file_path, target_url, start_time, time.time(), error_msg)
        return extracted_url, False, error_msg

def process_chunk(all_extracted_urls, output_file_path, dont_worked_file_path, full_log_file_path):
    """Обрабатывает один чанк URL, используя ThreadPoolExecutor."""
    if not all_extracted_urls:
        return

    successful_urls = set()

    with concurrent.futures.ThreadPoolExecutor(max_workers=THREADS) as executor:
        task_args = [(url, full_log_file_path) for url in all_extracted_urls]
        futures = {executor.submit(process_single_url, arg): arg[0] for arg in task_args}

        for future in concurrent.futures.as_completed(futures):
            extracted_url, success, error_details = future.result()
            if success:
                successful_urls.add(extracted_url)
                with open(output_file_path, 'a', encoding='utf-8') as f_out:
                    f_out.write(extracted_url + "\n")
            with open(dont_worked_file_path, 'a', encoding='utf-8') as f_dont_work:
                f_dont_work.write(extracted_url + "\n")

    print(f"  {COLOR_BLUE}[ЧАНК] Обработано: {len(all_extracted_urls)}, Найдено 200 OK: {len(successful_urls)}.{COLOR_RESET}")


def process_input_file(input_file_path, output_file_path, dont_worked_file_path, full_log_file_path):
    """Обрабатывает один входной файл ЧАНК за ЧАНКОМ, разбирая длинные строки на подстроки."""
    print(f"{COLOR_BLUE}[ИНФО] Начата обработка файла: {input_file_path}{COLOR_RESET}")

    with open(output_file_path, 'w', encoding='utf-8') as f_out:
        pass
    with open(dont_worked_file_path, 'w', encoding='utf-8') as f_dont_work:
        pass

    all_extracted_urls_chunk = []
    try:
        with open(input_file_path, 'r', encoding='utf-8') as f_in:
            for line_num, line in enumerate(f_in, start=1):
                line_content = line.strip()
                if not line_content:
                    continue

                print(f"  {COLOR_BLUE}[ЛОГ] Обработка строки {line_num} из {input_file_path} (длина {len(line_content)}).{COLOR_RESET}")

                # --- Ключевое изменение: разбор строки на подстроки ---
                # Регулярное выражение для поиска https://<IP>:<PORT>
                url_pattern = r'https://\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+'
                
                # Используем re.finditer для поиска всех совпадений в строке по одному
                # Это позволяет избежать создания большого списка сразу
                for match in re.finditer(url_pattern, line_content):
                    extracted_url = match.group() # Получаем найденный URL
                    
                    # Добавляем его в текущий чанк
                    all_extracted_urls_chunk.append(extracted_url)

                    # Если чанк заполнен, обрабатываем его
                    if len(all_extracted_urls_chunk) >= CHUNK_SIZE:
                        print(f"  {COLOR_CYAN}[ЧАНК] Заполнен (размер {CHUNK_SIZE}). Начинаю обработку...{COLOR_RESET}")
                        process_chunk(all_extracted_urls_chunk, output_file_path, dont_worked_file_path, full_log_file_path)
                        all_extracted_urls_chunk = [] # Очищаем чанк

    except FileNotFoundError:
        print(f"{COLOR_RED}[ОШИБКА] Файл {input_file_path} не найден.{COLOR_RESET}")
        return False
    except Exception as e:
        print(f"{COLOR_RED}[ОШИБКА] Ошибка чтения файла {input_file_path}: {e}{COLOR_RESET}")
        return False

    # Обрабатываем оставшиеся URL, если они есть
    if all_extracted_urls_chunk:
        print(f"  {COLOR_CYAN}[ЧАНК] Финальный (размер {len(all_extracted_urls_chunk)}). Начинаю обработку...{COLOR_RESET}")
        process_chunk(all_extracted_urls_chunk, output_file_path, dont_worked_file_path, full_log_file_path)

    print(f"{COLOR_BLUE}[ИНФО] Завершена обработка {input_file_path} (все чанки).{COLOR_RESET}")
    return True


def main():
    """Основная функция сканера Fortinet."""
    print(f"{COLOR_CYAN}--- Старт сканирования каталога {INPUT_DIR} (многопоточный, чанки, разбор строки, удаление после обработки) ---{COLOR_RESET}")

    if not os.path.isdir(INPUT_DIR):
        print(f"{COLOR_RED}[ОШИБКА] Каталог {INPUT_DIR} не найден.{COLOR_RESET}")
        return

    input_file_paths = []
    for country_dir_name in os.listdir(INPUT_DIR):
        country_input_path = os.path.join(INPUT_DIR, country_dir_name)

        if not os.path.isdir(country_input_path) or len(country_dir_name) != 2:
            continue

        print(f"{COLOR_BLUE}[ИНФО] Обрабатываем подкаталог: {country_input_path}{COLOR_RESET}")

        country_full_log_path = os.path.join(OUTPUT_FULL_DIR, country_dir_name)
        country_output_path = os.path.join(OUTPUT_DIR, country_dir_name)
        country_dont_worked_path = os.path.join(OUTPUT_DONT_WORKED_DIR, country_dir_name)

        os.makedirs(country_full_log_path, exist_ok=True)
        os.makedirs(country_output_path, exist_ok=True)
        os.makedirs(country_dont_worked_path, exist_ok=True)

        full_log_file_path = os.path.join(country_full_log_path, "full.log")

        for filename in os.listdir(country_input_path):
            if not filename.lower().endswith('.txt'):
                 continue

            input_file_path = os.path.join(country_input_path, filename)
            input_file_paths.append(input_file_path)

    print(f"{COLOR_BLUE}[ИНФО] Найдено {len(input_file_paths)} файлов для обработки.{COLOR_RESET}")

    for input_file_path in input_file_paths:
        path_parts = Path(input_file_path).parts
        if len(path_parts) < 3 or path_parts[-3] != 'input':
            print(f"{COLOR_YELLOW}[ПРЕДУПРЕЖДЕНИЕ] Неверный путь к файлу: {input_file_path}{COLOR_RESET}")
            continue

        country_code = path_parts[-2]
        filename = os.path.basename(input_file_path)
        output_file_path = os.path.join(OUTPUT_DIR, country_code, filename)
        dont_worked_file_path = os.path.join(OUTPUT_DONT_WORKED_DIR, country_code, filename)

        success = process_input_file(input_file_path, output_file_path, dont_worked_file_path, os.path.join(OUTPUT_FULL_DIR, country_code, "full.log"))

        if success:
            try:
                os.remove(input_file_path)
                print(f"{COLOR_GREEN}[+] Файл успешно обработан и удалён: {input_file_path}{COLOR_RESET}")
            except OSError as e:
                print(f"{COLOR_RED}[-] Ошибка при удалении файла {input_file_path}: {e}{COLOR_RESET}")
        else:
            print(f"{COLOR_YELLOW}[-] Файл НЕ был удалён из-за ошибки при обработке: {input_file_path}{COLOR_RESET}")

    print(f"\n{COLOR_CYAN}--- Сканирование завершено ---{COLOR_RESET}")


if __name__ == "__main__":
    main()

import os
import re
import requests
import warnings
import concurrent.futures
import time
import random
from urllib.parse import quote
from datetime import datetime
from pathlib import Path
import sys
import queue
from threading import Thread, Event

# --- ИМПОРТ И ПРЕДУПРЕЖДЕНИЙ ---
from urllib3.exceptions import InsecureRequestWarning
warnings.filterwarnings("ignore", category=InsecureRequestWarning)

# --- Конфигурация ---
INPUT_DIR = "./input"
OUTPUT_DIR = "./output"
OUTPUT_DONT_WORKED_DIR = "./output_dont_worked"
FORTINET_PATH = "/remote/login"
TIMEOUT = 10
USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.6613.120 Safari/537.36"
THREADS = 200
CHUNK_SIZE = 1000
CHUNK_DELAY = 1
REQUEST_DELAY_MEAN = 0.1
REQUEST_DELAY_VARIANCE = 0.05
WRITE_BUFFER_SIZE = 500
WRITE_BUFFER_TIMEOUT = 6

# --- Автоматическое определение портов ---
# Цвета для вывода в терминал (работает в терминалах, поддерживающих ANSI)
COLOR_RED = "\033[91m"
COLOR_GREEN = "\033[92m"
COLOR_BLUE = "\033[94m"
COLOR_YELLOW = "\033[93m"
COLOR_CYAN = "\033[96m"
COLOR_RESET = "\033[0m"

print(f"{COLOR_CYAN}--- Сканирование каталога {INPUT_DIR} для определения портов ---{COLOR_RESET}")
discovered_ports = set()
for item in os.listdir(INPUT_DIR):
    item_path = os.path.join(INPUT_DIR, item)
    if os.path.isdir(item_path) and len(item) == 2:
        try:
            files_in_subdir = os.listdir(item_path)
        except OSError as e:
            print(f"  {COLOR_RED}[ОШИБКА] Не удалось прочитать подкаталог '{item}': {e}{COLOR_RESET}")
            continue

        for filename in files_in_subdir:
            if filename.lower().endswith('.txt'):
                match = re.match(r'^(\d+)-', filename)
                if match:
                    port = int(match.group(1))
                    discovered_ports.add(port)

PORTS_TO_PROCESS = sorted(list(discovered_ports))
print(f"{COLOR_BLUE}[ИНФО] Обнаружено {len(PORTS_TO_PROCESS)} уникальных портов для обработки: {PORTS_TO_PROCESS}{COLOR_RESET}")

from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

def worker_thread(url_queue, result_queue, stop_event, stats):
    session = requests.Session()
    retry_strategy = Retry(
        total=3,
        backoff_factor=0.3,
        status_forcelist=[429, 500, 502, 503, 504],
    )
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)

    while not stop_event.is_set():
        try:
            extracted_url = url_queue.get(timeout=1)
        except queue.Empty:
            continue

        if extracted_url is None:
            url_queue.task_done()
            break

        target_url = extracted_url + FORTINET_PATH
        time.sleep(random.uniform(REQUEST_DELAY_MEAN - REQUEST_DELAY_VARIANCE, REQUEST_DELAY_MEAN + REQUEST_DELAY_VARIANCE))

        start_time = time.time()

        try:
            response = session.get(
                target_url,
                headers={'User-Agent': USER_AGENT},
                verify=False,
                timeout=TIMEOUT
            )
            request_time = time.time() - start_time

            if response.status_code == 200:
                print(f"    {COLOR_GREEN}[+] 200 OK за {request_time:.2f}s для: {target_url}{COLOR_RESET}")
                stats['success'] += 1
                result_queue.put(('success', extracted_url))
            else:
                print(f"    {COLOR_RED}[-] Код {response.status_code} за {request_time:.2f}s для: {target_url}{COLOR_RESET}")
                stats['failed'] += 1
                result_queue.put(('failed', extracted_url))

        except requests.exceptions.Timeout:
            error_msg = f"Timeout after {TIMEOUT}s"
            print(f"    {COLOR_RED}[ОШИБКА ТАЙМАУТ] {target_url} ({error_msg}){COLOR_RESET}")
            stats['failed'] += 1
            result_queue.put(('failed', extracted_url))

        except requests.exceptions.RequestException as e:
            error_msg = str(e)
            print(f"    {COLOR_RED}[ОШИБКА ЗАПРОСА] {target_url}: {error_msg}{COLOR_RESET}")
            stats['failed'] += 1
            result_queue.put(('failed', extracted_url))

        except Exception as e:
            error_msg = str(e)
            print(f"    {COLOR_RED}[НЕИЗВЕСТНАЯ ОШИБКА в worker] {target_url}: {error_msg}{COLOR_RESET}")
            stats['failed'] += 1
            result_queue.put(('failed', extracted_url))

        finally:
            url_queue.task_done()

    session.close()
    print(f"  {COLOR_BLUE}[WORKER] Поток завершает работу.{COLOR_RESET}")


def write_results_thread(result_queue, output_file_path, dont_worked_file_path, stop_event, stats):
    output_buffer = []
    dont_worked_buffer = []

    while not stop_event.is_set():
        try:
            res_type, url = result_queue.get(timeout=WRITE_BUFFER_TIMEOUT)
        except queue.Empty:
            if stop_event.is_set():
                break
            continue

        if res_type is None and url is None:
            break

        if res_type == 'success':
            output_buffer.append(url)
            # --- Информационное сообщение о добавлении в буфер для output ---
            print(f"      {COLOR_BLUE}[ЛОГ] URL '{url}' добавлен в буфер для записи в output.{COLOR_RESET}")
        elif res_type == 'failed':
            dont_worked_buffer.append(url)
            # --- Информационное сообщение о добавлении в буфер для output_dont_worked ---
            print(f"      {COLOR_BLUE}[ЛОГ] URL '{url}' добавлен в буфер для записи в output_dont_worked.{COLOR_RESET}")

        if len(output_buffer) >= WRITE_BUFFER_SIZE or len(dont_worked_buffer) >= WRITE_BUFFER_SIZE:
            flush_buffers(output_buffer, dont_worked_buffer, output_file_path, dont_worked_file_path, stats)

        result_queue.task_done()

    if output_buffer or dont_worked_buffer:
        flush_buffers(output_buffer, dont_worked_buffer, output_file_path, dont_worked_file_path, stats)

    print(f"  {COLOR_BLUE}[WRITER] Поток завершает работу.{COLOR_RESET}")


def flush_buffers(output_buf, dont_worked_buf, output_path, dont_worked_path, stats):
    if output_buf:
        try:
            with open(output_path, 'a', encoding='utf-8') as f_out:
                f_out.write('\n'.join(output_buf) + '\n')
            stats['written_success'] += len(output_buf)
            # --- Информационное сообщение о записи в output ---
            print(f"      {COLOR_GREEN}[ЗАПИСЬ] {len(output_buf)} URL записано в {output_path}.{COLOR_RESET}")
        except OSError as e:
            print(f"{COLOR_RED}[ОШИБКА ЗАПИСИ OUTPUT] {output_path}: {e}{COLOR_RESET}")
            stats['write_errors'] += len(output_buf)
        output_buf.clear()

    if dont_worked_buf:
        try:
            with open(dont_worked_path, 'a', encoding='utf-8') as f_dont_work:
                f_dont_work.write('\n'.join(dont_worked_buf) + '\n')
            stats['written_failed'] += len(dont_worked_buf)
            # --- Информационное сообщение о записи в output_dont_worked ---
            print(f"      {COLOR_GREEN}[ЗАПИСЬ] {len(dont_worked_buf)} URL записано в {dont_worked_path}.{COLOR_RESET}")
        except OSError as e:
            print(f"{COLOR_RED}[ОШИБКА ЗАПИСИ DONT_WORKED] {dont_worked_path}: {e}{COLOR_RESET}")
            stats['write_errors'] += len(dont_worked_buf)
        dont_worked_buf.clear()


def process_input_file(input_file_path, output_file_path, dont_worked_file_path):
    print(f"{COLOR_BLUE}[ИНФО] Начата обработка файла: {input_file_path}{COLOR_RESET}")

    MAX_QUEUE_SIZE = CHUNK_SIZE
    url_queue = queue.Queue(maxsize=MAX_QUEUE_SIZE)
    result_queue = queue.Queue(maxsize=MAX_QUEUE_SIZE)
    stop_event = Event()
    stats = {'success': 0, 'failed': 0, 'written_success': 0, 'written_failed': 0, 'write_errors': 0}

    writer_thread_instance = Thread(
        target=write_results_thread,
        args=(result_queue, output_file_path, dont_worked_file_path, stop_event, stats)
    )
    writer_thread_instance.start()

    workers = []
    for _ in range(THREADS):
        t = Thread(
            target=worker_thread,
            args=(url_queue, result_queue, stop_event, stats)
        )
        t.start()
        workers.append(t)

    processing_success = False
    try:
        with open(output_file_path, 'w', encoding='utf-8') as f_out:
            pass
        with open(dont_worked_file_path, 'w', encoding='utf-8') as f_dont_work:
            pass

        print(f"  {COLOR_BLUE}[ЛОГ] Файлы вывода созданы/очищены.{COLOR_RESET}")

        with open(input_file_path, 'r', encoding='utf-8') as f_in:
            for line_num, line in enumerate(f_in, start=1):
                line_content = line.strip()
                if not line_content:
                    continue

                print(f"  {COLOR_BLUE}[ЛОГ] Обработка строки {line_num} из {input_file_path}.{COLOR_RESET}")

                url_pattern = r'https://(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}):(\d+)'
                for match in re.finditer(url_pattern, line_content):
                    ip, port = match.groups()
                    extracted_url = f"https://{ip}:{port}"
                    url_queue.put(extracted_url)

                    if url_queue.qsize() >= CHUNK_SIZE:
                        print(f"  {COLOR_CYAN}[ЧАНК] Очередь заполнена (размер >= {CHUNK_SIZE}). Начинаю обработку...{COLOR_RESET}")
                        time.sleep(CHUNK_DELAY)

    except FileNotFoundError:
        print(f"{COLOR_RED}[ОШИБКА] Файл {input_file_path} не найден.{COLOR_RESET}")
        processing_success = False
    except Exception as e:
        print(f"{COLOR_RED}[ФАТАЛЬНАЯ ОШИБКА] Критическая ошибка при обработке {input_file_path}: {e}{COLOR_RESET}")
        processing_success = False
    finally:
        for _ in workers:
            url_queue.put(None)

        for t in workers:
            t.join(timeout=10)

        print(f"  {COLOR_BLUE}[ЛОГ] Все потоки обработки завершены. Ожидание завершения записи...{COLOR_RESET}")

        result_queue.put((None, None))

        writer_thread_instance.join(timeout=10)

        print(f"  {COLOR_BLUE}[ЛОГ] Поток записи завершен.{COLOR_RESET}")

        if stats['write_errors'] > 0:
             print(f"{COLOR_RED}[ОШИБКА] Обнаружены ошибки записи ({stats['write_errors']} шт.). Входной файл НЕ будет удален.{COLOR_RESET}")
             processing_success = False
        else:
            print(f"{COLOR_BLUE}[ЛОГ] Обработка завершена успешно для {input_file_path}. Статистика: Успехи: {stats['success']}, Неуспехи: {stats['failed']}, Записано: {stats['written_success']} OK, {stats['written_failed']} Не_ОК.{COLOR_RESET}")
            processing_success = True

        stop_event.set()

    return processing_success


def main():
    print(f"{COLOR_CYAN}--- Старт сканирования каталога {INPUT_DIR} (многопоточный, чанки, очереди, удаление после обработки, фильтрация по портам) ---{COLOR_RESET}")

    if not os.path.isdir(INPUT_DIR):
        print(f"{COLOR_RED}[ОШИБКА] Каталог {INPUT_DIR} не найден.{COLOR_RESET}")
        return

    country_dirs = []
    for item in os.listdir(INPUT_DIR):
        item_path = os.path.join(INPUT_DIR, item)
        if os.path.isdir(item_path) and len(item) == 2:
            try:
                files_in_subdir = os.listdir(item_path)
            except OSError as e:
                print(f"  {COLOR_RED}[ОШИБКА] Не удалось прочитать подкаталог '{item}': {e}{COLOR_RESET}")
                continue

            found_matching_file = False
            for filename in files_in_subdir:
                 if filename.lower().endswith('.txt'):
                     match = re.match(r'^(\d+)-', filename)
                     if match:
                         port = int(match.group(1))
                         if port in PORTS_TO_PROCESS:
                             found_matching_file = True
                             break

            if found_matching_file:
                country_dirs.append(item)
                print(f"  {COLOR_BLUE}[ЛОГ] Подкаталог '{item}' добавлен.{COLOR_RESET}")
            else:
                print(f"  {COLOR_YELLOW}[ЛОГ] Подкаталог '{item}' пропущен.{COLOR_RESET}")

    country_dirs.sort()

    if not country_dirs:
        print(f"{COLOR_YELLOW}[ИНФО] В каталоге {INPUT_DIR} не найдено подкаталогов стран по портам.{COLOR_RESET}")
        return

    print(f"{COLOR_BLUE}[ИНФО] Найдено {len(country_dirs)} подкаталогов стран.{COLOR_RESET}")

    # --- Создаем список файлов для обработки ---
    input_file_paths = []
    for country_code in country_dirs:
        country_input_path = os.path.join(INPUT_DIR, country_code)
        if not os.path.exists(country_input_path):
            continue

        try:
            files_in_dir = os.listdir(country_input_path)
        except OSError as e:
            print(f"  {COLOR_RED}[ОШИБКА] Не удалось прочитать подкаталог '{country_code}': {e}{COLOR_RESET}")
            continue

        for filename in files_in_dir:
            if not filename.lower().endswith('.txt'):
                continue

            file_matches_port = False
            for port in PORTS_TO_PROCESS:
                if filename.startswith(f"{port}-"):
                    file_matches_port = True
                    break

            if file_matches_port:
                input_file_path = os.path.join(country_input_path, filename)
                input_file_paths.append(input_file_path)
                # print(f"  {COLOR_BLUE}[ЛОГ] Файл добавлен: {input_file_path}{COLOR_RESET}") # Может быть много, закомментировано

    if not input_file_paths:
        print(f"{COLOR_YELLOW}[ИНФО] Не найдено ни одного файла для обработки.{COLOR_RESET}")
        return

    total_files = len(input_file_paths)
    print(f"{COLOR_BLUE}[ИНФО] Найдено {total_files} файлов для обработки.{COLOR_RESET}")

    # --- Обработка аргументов командной строки ---
    selected_indices = []
    if len(sys.argv) > 1:
        arg = sys.argv[1].strip().lower()

        if arg == 'all':
            selected_indices = list(range(total_files))
            print(f"{COLOR_BLUE}[ИНФО] Выбраны все {total_files} файлов.{COLOR_RESET}")

        elif '-' in arg:
            try:
                range_parts = arg.split('-')
                if len(range_parts) != 2:
                    raise ValueError("Неверный формат диапазона.")
                start_num = int(range_parts[0])
                end_num = int(range_parts[1])
                if start_num < 1 or end_num > total_files or start_num > end_num:
                    raise ValueError("Неверный диапазон.")
                selected_indices = list(range(start_num - 1, end_num))
                print(f"{COLOR_BLUE}[ИНФО] Выбран диапазон: файлы {start_num} - {end_num} ({len(selected_indices)} шт.).{COLOR_RESET}")
            except ValueError as e:
                print(f"{COLOR_RED}[ОШИБКА] {e} Используйте формат 'N-M', где 1 <= N <= M <= {total_files}.{COLOR_RESET}")
                return

        else: # Одиночное число
            try:
                single_num = int(arg)
                if single_num < 1 or single_num > total_files:
                    raise ValueError(f"Номер файла {single_num} вне диапазона. Должен быть от 1 до {total_files}.")
                selected_indices = [single_num - 1]
                print(f"{COLOR_BLUE}[ИНФО] Выбран файл № {single_num} ('{os.path.basename(input_file_paths[selected_indices[0]])}').{COLOR_RESET}")
            except ValueError as e:
                print(f"{COLOR_RED}[ОШИБКА] {e}{COLOR_RESET}")
                return
    else: # Интерактивный режим
        print(f"{COLOR_BLUE}Список файлов для обработки:{COLOR_RESET}")
        for i, file_path in enumerate(input_file_paths, start=1):
            print(f"  {i}. {file_path}")

        while True:
            try:
                user_input = input(f"{COLOR_BLUE}Введите номер файла или диапазон (например, '5' или '10-20'), или 'all': {COLOR_RESET}").strip()
                if not user_input:
                    continue

                if user_input.lower() == 'all':
                    selected_indices = list(range(total_files))
                    break

                if '-' in user_input:
                    range_parts = user_input.split('-')
                    if len(range_parts) != 2:
                        print(f"{COLOR_RED}[!] Неверный формат диапазона.{COLOR_RESET}")
                        continue
                    start_num = int(range_parts[0])
                    end_num = int(range_parts[1])
                    if start_num < 1 or end_num > total_files or start_num > end_num:
                        print(f"{COLOR_RED}[!] Неверный диапазон. Убедитесь, что 1 <= N <= M <= {total_files}.{COLOR_RESET}")
                        continue
                    selected_indices = list(range(start_num - 1, end_num))
                    break
                else:
                    single_num = int(user_input)
                    if single_num < 1 or single_num > total_files:
                        print(f"{COLOR_RED}[!] Неверный номер. Убедитесь, что 1 <= N <= {total_files}.{COLOR_RESET}")
                        continue
                    selected_indices = [single_num - 1]
                    break
            except ValueError:
                print(f"{COLOR_RED}[!] Пожалуйста, введите корректное число или диапазон.{COLOR_RESET}")
            except KeyboardInterrupt:
                print(f"\n{COLOR_YELLOW}--- Работа скрипта прервана ---{COLOR_RESET}")
                return

    # --- Обработка выбранных файлов ---
    print(f"{COLOR_BLUE}[ЛОГ] Начинается обработка {len(selected_indices)} выбранных файлов.{COLOR_RESET}")
    for idx in selected_indices:
        if idx < 0 or idx >= total_files:
             print(f"{COLOR_RED}[ОШИБКА] Индекс {idx} вне диапазона списка файлов (0 - {total_files-1}).{COLOR_RESET}")
             continue

        input_file_path = input_file_paths[idx]
        print(f"{COLOR_BLUE}[ЛОГ] Обработка индекса {idx}, файл: {input_file_path}{COLOR_RESET}")

        path_parts = Path(input_file_path).parts
        if len(path_parts) < 3 or path_parts[-3] != 'input':
            print(f"{COLOR_YELLOW}[ПРЕДУПРЕЖДЕНИЕ] Неверный путь: {input_file_path}{COLOR_RESET}")
            continue

        country_code = path_parts[-2]
        filename = os.path.basename(input_file_path)
        output_file_path = os.path.join(OUTPUT_DIR, country_code, filename)
        dont_worked_file_path = os.path.join(OUTPUT_DONT_WORKED_DIR, country_code, filename)

        os.makedirs(os.path.dirname(output_file_path), exist_ok=True)
        os.makedirs(os.path.dirname(dont_worked_file_path), exist_ok=True)

        try:
            success = process_input_file(input_file_path, output_file_path, dont_worked_file_path)
        except Exception as e:
             print(f"{COLOR_RED}[ФАТАЛЬНАЯ ОШИБКА ВНУТРИ process_input_file] {input_file_path}: {e}{COLOR_RESET}")
             success = False

        if success:
            try:
                os.remove(input_file_path)
                # --- Информационное сообщение об удалении файла из input ---
                print(f"{COLOR_GREEN}[+] Файл успешно обработан и УДАЛЁН из input: {input_file_path}{COLOR_RESET}")
            except OSError as e:
                print(f"{COLOR_RED}[-] Ошибка при удалении файла {input_file_path}: {e}{COLOR_RESET}")
        else:
            print(f"{COLOR_YELLOW}[-] Файл НЕ был удалён: {input_file_path}{COLOR_RESET}")

    print(f"\n{COLOR_CYAN}--- Сканирование завершено ---{COLOR_RESET}")


if __name__ == "__main__":
    main()