import os, time, json, base64, requests
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor, as_completed

import config
from template import build_from_links, write_post2

LINKS_JSON = "links.json"


def load_links():
    if not os.path.exists(LINKS_JSON):
        return {"images": {}, "videos": {}}
    try:
        with open(LINKS_JSON, "r", encoding="utf-8") as f:
            return json.load(f)
    except Exception:
        return {"images": {}, "videos": {}}


def save_links(data):
    with open(LINKS_JSON, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)


def upload_image(file_path):
    try:
        original_name = os.path.basename(file_path)
        name_key = os.path.splitext(original_name)[0]
        with open(file_path, "rb") as image_file:
            encoded = base64.b64encode(image_file.read()).decode("utf-8")
        payload = {"key": config.API_KEY, "image": encoded, "name": name_key}
        r = requests.post(config.UPLOAD_IMG_URL, data=payload, timeout=60)
        r.raise_for_status()
        data = r.json()
        if data.get("status") == 200:
            url = data["data"]["image"]["url"]
            print(f"  ✓ {original_name} → {url}")
            return url, name_key
        return None, None
    except Exception as e:
        print(f"  ✗ Ошибка: {os.path.basename(file_path)} - {e}")
        return None, None


def upload_images(folder_path):
    print("\n?️  Загрузка изображений...")
    links = load_links()
    image_ext = {".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"}
    image_files = [
        os.path.join(folder_path, f)
        for f in os.listdir(folder_path)
        if os.path.isfile(os.path.join(folder_path, f))
        and os.path.splitext(f)[1].lower() in image_ext
    ]

    img_start = time.time()
    for idx, fp in enumerate(sorted(image_files), 1):
        key = os.path.splitext(os.path.basename(fp))[0]
        if key in links["images"]:
            continue
        print(f"[{idx}/{len(image_files)}] {os.path.basename(fp)}")
        url, key_out = upload_image(fp)
        if url:
            links["images"][key_out] = url
            save_links(links)
        time.sleep(2)

    img_time = int(time.time() - img_start)
    print(f"⏱ Изображения обработаны за {img_time} секунд")


def get_dood_upload_server() -> str | None:
    """Получаем актуальный URL сервера для загрузки"""
    try:
        r = requests.get(
            config.DOOD_UPLOAD_SERVER,
            params={"key": config.DOOD_API_KEY},
            timeout=30,
        )
        r.raise_for_status()
        data = r.json()
        if data.get("status") == 200 and data.get("result"):
            return data["result"]
        print(f"❌ Не удалось получить upload server: {data}")
        return None
    except Exception as e:
        print(f"❌ Ошибка получения upload server: {e}")
        return None


def _normalize_dood_link(link: str) -> str:
    """Приводим ссылку к виду /d/ (страница с плеером + кнопка загрузки)"""
    if not link:
        return link
    # относительный путь
    if link.startswith("/"):
        link = "https://dood.to" + link
    # заменяем /e/ → /d/ (embed → download page с кнопкой)
    if "/e/" in link:
        link = link.replace("/e/", "/d/")
    return link


def upload_video(video_path: Path, max_attempts: int = 2) -> str | None:
    """Загрузка одного видео через Doodstream API"""
    for attempt in range(1, max_attempts + 1):
        print(f"  Попытка {attempt}/{max_attempts}: {video_path.name}")
        try:
            server_url = get_dood_upload_server()
            if not server_url:
                time.sleep(5)
                continue

            # ключ иногда нужен и в query
            upload_url = (
                f"{server_url}?{config.DOOD_API_KEY}"
                if "?" not in server_url
                else server_url
            )

            start = time.time()
            with open(video_path, "rb") as f:
                files = {"file": (video_path.name, f, "video/mp4")}
                data = {"api_key": config.DOOD_API_KEY}
                r = requests.post(
                    upload_url,
                    data=data,
                    files=files,
                    timeout=config.UPLOAD_TIMEOUT,
                )

            duration = time.time() - start
            r.raise_for_status()
            resp = r.json()

            if resp.get("status") == 200 and resp.get("result"):
                item = (
                    resp["result"][0]
                    if isinstance(resp["result"], list)
                    else resp["result"]
                )
                # предпочитаем download-страницу (с кнопкой загрузки)
                link = (
                    item.get("download_url")
                    or item.get("protected_dl")
                    or item.get("protected_embed")
                )
                if link:
                    link = _normalize_dood_link(link)
                    print(f"  ✅ {video_path.name} → {link} ({duration:.1f} сек)")
                    return link

            print(f"  ❌ Неожиданный ответ API: {resp}")
        except Exception as e:
            print(f"  ❌ Ошибка: {e}")
        time.sleep(5)

    print(f"  ❌ Не удалось загрузить {video_path.name}")
    return None


def upload_videos_batch(to_upload: list):
    """
    Загружает видео пачками по MAX_CONCURRENT_UPLOADS.
    После каждой пачки — пауза BATCH_TIMEOUT секунд.
    """
    links = load_links()
    total = len(to_upload)
    if total == 0:
        return links

    batch_size = config.MAX_CONCURRENT_UPLOADS
    print(
        f"\n? Параллельная загрузка: {batch_size} видео одновременно, "
        f"пауза {config.BATCH_TIMEOUT} сек между пачками"
    )

    for batch_start in range(0, total, batch_size):
        batch = to_upload[batch_start : batch_start + batch_size]
        batch_num = batch_start // batch_size + 1
        total_batches = (total + batch_size - 1) // batch_size
        print(f"\n? Пачка {batch_num}/{total_batches} ({len(batch)} видео)...")

        results = {}
        with ThreadPoolExecutor(max_workers=len(batch)) as executor:
            future_to_key = {
                executor.submit(upload_video, video): key
                for key, video in batch
            }
            for future in as_completed(future_to_key):
                key = future_to_key[future]
                try:
                    link = future.result()
                    results[key] = link if link else f"{key} не загрузилось"
                except Exception as e:
                    print(f"  ❌ Исключение для {key}: {e}")
                    results[key] = f"{key} ошибка"

        # сохраняем после каждой пачки
        links["videos"].update(results)
        save_links(links)

        # пауза между пачками (кроме последней)
        if batch_start + batch_size < total:
            print(f"⏳ Пауза {config.BATCH_TIMEOUT} сек перед следующей пачкой...")
            time.sleep(config.BATCH_TIMEOUT)

    return links


def main():
    folder = Path(config.FOLDER_PATH)
    newpost_path = folder / "newpost.txt"

    print("\n=== Выбор режима ===")
    print("1. Полная очистка и новый сбор (для нового поста)")
    print("2. Дополнить существующие данные (догрузить новые файлы)")
    mode = input("Выберите режим (1 или 2): ").strip()

    if mode == "1":
        if os.path.exists(LINKS_JSON):
            os.remove(LINKS_JSON)
            print("? Старый links.json удалён — начинаем с чистого листа")
    else:
        print("? Режим дополнения — старые данные сохраняются")

    # 1. Изображения (imgbb)
    upload_images(str(folder))

    # 2. Видео (Doodstream API, параллельно)
    video_files = sorted(list(folder.glob("*.mp4")))
    links = load_links()

    to_upload = []
    for v in video_files:
        key = os.path.splitext(v.name)[0]
        if key not in links["videos"]:
            to_upload.append((key, v))

    if to_upload:
        print(f"\nНужно загрузить {len(to_upload)} видео")
        total_start = time.time()
        links = upload_videos_batch(to_upload)
        total_time = time.time() - total_start
        print(
            f"\n⏱ Все видео обработаны за {total_time:.1f} секунд "
            f"({total_time / 60:.1f} минут)"
        )
    else:
        print("✅ Все видео уже загружены.")

    print("\n? Создаём newpost.txt...")
    # перечитываем актуальные ссылки
    links = load_links()
    data = build_from_links(str(folder), video_links=links)
    write_post2(data, str(newpost_path))
    print("? Готово!")


if __name__ == "__main__":
    main()

import os, re
from collections import OrderedDict

def extract_base_before_date(name_with_ext: str) -> str:
    name = os.path.splitext(os.path.basename(name_with_ext))[0]
    date_pattern = r'(?<=[-_. ])(20\d{2}[-_.](?:0?[1-9]|1[0-2])[-_.](?:0?[1-9]|[12]\d|3[01]))'
    m = re.search(date_pattern, name)
    if m:
        base = name[:m.start()].strip("-_. ")
    else:
        base = name.strip("-_. ")
    base = re.sub(
        r'[-_](CB|SC|BC|MB|LB|TEASER|CUT[S]?|PREVIEW|202[0-9]-[0-9]{2}.*?)$',
        '',
        base,
        flags=re.I,
    )
    base = re.sub(r'[-_. ](cuts?|preview|teaser|jpg|png|webp)$', '', base, flags=re.I)
    base = base.strip("-_. ")
    base = re.sub(r'[-_. ]+$', '', base)
    return base or name


def normalize_key(text: str) -> str:
    return re.sub(r'[\W_]+', '', text).lower()


def find_video_link(img_key: str, videos: dict) -> str | None:
    """Ищем ссылку на видео для данной картинки максимально гибко."""
    if not videos:
        return None

    # 1. Точное совпадение ключа
    if img_key in videos:
        return videos[img_key]

    # 2. Нормализованный ключ картинки
    img_norm = normalize_key(img_key)
    for vkey, vlink in videos.items():
        if normalize_key(vkey) == img_norm:
            return vlink

    # 3. Базовое имя (без даты и суффиксов)
    img_base = normalize_key(extract_base_before_date(img_key + ".jpg"))
    for vkey, vlink in videos.items():
        v_base = normalize_key(extract_base_before_date(vkey + ".mp4"))
        if v_base and img_base and v_base == img_base:
            return vlink

    # 4. startswith / contains (запасной)
    for vkey, vlink in videos.items():
        if (
            vkey.startswith(img_key)
            or img_key.startswith(vkey)
            or img_norm in normalize_key(vkey)
            or normalize_key(vkey) in img_norm
        ):
            return vlink

    return None


def build_from_links(folder_path: str, video_links: dict = None, sendvid_links: dict = None):
    """
    video_links — основной параметр (новый).
    sendvid_links — для обратной совместимости со старыми вызовами.
    """
    if video_links is None:
        video_links = sendvid_links or {"images": {}, "videos": {}}

    images = video_links.get("images", {})
    videos = video_links.get("videos", {})

    # display-имена из реальных mp4-файлов
    mp4_display = {}
    for fn in sorted(os.listdir(folder_path)):
        if fn.lower().endswith(".mp4"):
            display = extract_base_before_date(fn)
            key = normalize_key(display)
            if key not in mp4_display:
                mp4_display[key] = display

    data = OrderedDict()

    # Основной проход — по картинкам
    for img_key, url in images.items():
        display = extract_base_before_date(img_key + ".jpg")
        norm_key = normalize_key(display)

        if norm_key not in data:
            data[norm_key] = {
                "display": mp4_display.get(norm_key, display),
                "links": [],
                "sendvid": [],  # оставляем имя поля для совместимости с write_post2
            }
        data[norm_key]["links"].append(f"[img]{url}[/img]")

        # Ищем видео
        vlink = find_video_link(img_key, videos)
        if vlink and vlink not in data[norm_key]["sendvid"]:
            data[norm_key]["sendvid"].append(vlink)

    # Добавляем видео, у которых нет ни одной картинки (чтобы ничего не потерялось)
    used_videos = set()
    for item in data.values():
        used_videos.update(item["sendvid"])

    for vkey, vlink in videos.items():
        if vlink in used_videos or not vlink or "не загрузилось" in str(vlink):
            continue
        display = extract_base_before_date(vkey + ".mp4")
        norm_key = normalize_key(display)
        if norm_key not in data:
            data[norm_key] = {
                "display": mp4_display.get(norm_key, display),
                "links": [],
                "sendvid": [vlink],
            }
        elif vlink not in data[norm_key]["sendvid"]:
            data[norm_key]["sendvid"].append(vlink)

    return data


def write_post2(data_odict: OrderedDict, output_path: str):
    items = list(data_odict.values())
    if not items:
        print("Нет данных.")
        return

    singles = [x for x in items if len(x["links"]) == 1]
    multis = [x for x in items if len(x["links"]) > 1]

    lines = []

    if singles:
        first = singles[0]
        singles = singles[1:]
        lines.append(f"[b]{first['display']}[/b]")
        lines.append(first["links"][0])
        if first["sendvid"]:
            lines.append(" ".join(first["sendvid"]))
        lines.append("")

    total = len(singles) + len(multis)
    lines.append(f"[spoiler={total} nicknames] ")
    lines.append("")

    for i in range(0, len(singles), 3):
        group = singles[i : i + 3]
        lines.append(" _________ ".join(f"[b]{x['display']}[/b]" for x in group))
        lines.append(" ".join(x["links"][0] for x in group))
        lines.append("")
        sendvid = [s for x in group for s in x["sendvid"]]
        if sendvid:
            lines.append(" ".join(sendvid))
        lines.append("")

    for x in multis:
        lines.append(f"[b]{x['display']}[/b]")
        lines.append(" ".join(x["links"]))
        if x["sendvid"]:
            lines.append(" ".join(x["sendvid"]))
        lines.append("")

    lines.append("-------")
    lines.append("")
    lines.append("[/spoiler]")

    with open(output_path, "w", encoding="utf-8") as f:
        f.write("\n".join(lines))
    print(f"✅ Записан {output_path}")


if __name__ == "__main__":
    print("template.py готов.")

DOOD_API_KEY = "YOUR_DOOD_API_KEY"   # Замени на свой ключ, взять тут https://doodstream.com/settings
DOOD_UPLOAD_SERVER = "https://doodapi.co/api/upload/server"

API_KEY = "YOUR_API_KEY"                         # Замени на свой ключ от imgbb - взять тут https://api.imgbb.com/ после входа в аккаунт
FOLDER_PATH = r"FOLDER_PATH"                     # Путь к папке с видео и картинками
UPLOAD_IMG_URL = "https://api.imgbb.com/1/upload"

MAX_CONCURRENT_UPLOADS = 7
BATCH_TIMEOUT = 60
UPLOAD_TIMEOUT = 300

import os
import time
import random
import json
import base64
import requests
from pathlib import Path

import config
from template import build_from_links, write_post2

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC


LINKS_JSON = "links.json"


def load_links():
    if not os.path.exists(LINKS_JSON):
        return {"images": {}, "videos": {}}
    try:
        with open(LINKS_JSON, "r", encoding="utf-8") as f:
            return json.load(f)
    except:
        return {"images": {}, "videos": {}}


def save_links(data):
    with open(LINKS_JSON, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)


def get_driver():
    chrome_options = Options()
    if getattr(config, 'USE_EXISTING_BROWSER', True):
        chrome_options.add_experimental_option("debuggerAddress", f"127.0.0.1:{getattr(config, 'DEBUGGING_PORT', 9222)}")
    else:
        # Для будущих улучшений
        chrome_options.add_argument("--no-sandbox")
        chrome_options.add_argument("--disable-dev-shm-usage")
    print("? Подключаемся к браузеру...")
    return webdriver.Chrome(options=chrome_options)


def is_logged_in(driver) -> bool:
    try:
        driver.get(config.UPLOAD_VID_URL)
        time.sleep(4)
        return bool(driver.find_elements(By.XPATH, "//a[contains(., 'My Videos') or contains(., 'Upload')]"))
    except:
        return False


def login(driver):
    print("? Выполняется вход...")
    driver.get(config.LOGIN_URL)
    time.sleep(6)
    try:
        wait = WebDriverWait(driver, 30)
        email = wait.until(EC.presence_of_element_located((By.XPATH, "//input[@type='email' or contains(@name,'email')]")))
        email.clear()
        email.send_keys(config.USERNAME)
        pwd = driver.find_element(By.XPATH, "//input[@type='password']")
        pwd.clear()
        pwd.send_keys(config.PASSWORD)
        submit = wait.until(EC.element_to_be_clickable((By.XPATH, "//button | //input[@type='submit']")))
        driver.execute_script("arguments[0].scrollIntoView({block: 'center'});", submit)
        time.sleep(2)
        submit.click()
        time.sleep(25)
        print("✅ Логин успешен")
        return True
    except Exception as e:
        print(f"❌ Ошибка логина: {e}")
        raise


def upload_image(file_path):
    try:
        original_name = os.path.basename(file_path)
        name_key = os.path.splitext(original_name)[0]
        with open(file_path, "rb") as image_file:
            encoded = base64.b64encode(image_file.read()).decode('utf-8')
        payload = {'key': config.API_KEY, 'image': encoded, 'name': name_key}
        r = requests.post(config.UPLOAD_IMG_URL, data=payload, timeout=60)
        r.raise_for_status()
        data = r.json()
        if data.get('status') == 200:
            url = data['data']['image']['url']
            print(f"  ✓ {original_name} → {url}")
            return url, name_key
        return None, None
    except Exception as e:
        print(f"  ✗ Ошибка: {os.path.basename(file_path)} - {e}")
        return None, None


def upload_images(folder_path):
    print("\n?️  Загрузка изображений...")
    links = load_links()
    image_ext = {'.jpg','.jpeg','.png','.gif','.webp','.bmp'}
    image_files = [os.path.join(folder_path, f) for f in os.listdir(folder_path) 
                   if os.path.isfile(os.path.join(folder_path, f)) and os.path.splitext(f)[1].lower() in image_ext]
    
    img_start = time.time()
    for idx, fp in enumerate(sorted(image_files), 1):
        key = os.path.splitext(os.path.basename(fp))[0]
        if key in links["images"]:
            continue
        print(f"[{idx}/{len(image_files)}] {os.path.basename(fp)}")
        url, key_out = upload_image(fp)
        if url:
            links["images"][key_out] = url
            save_links(links)
        time.sleep(2)
    
    img_time = int(time.time() - img_start)
    print(f"⏱ Изображения обработаны за {img_time} секунд")


def upload_video(driver, video_path: Path, max_attempts=2):
    for attempt in range(1, max_attempts+1):
        print(f"Попытка {attempt}/{max_attempts}: {video_path.name}")
        driver.get(config.UPLOAD_VID_URL)
        time.sleep(5)
        try:
            file_input = WebDriverWait(driver, 25).until(EC.presence_of_element_located((By.XPATH, "//input[@type='file']")))
            file_input.send_keys(str(video_path.absolute()))
            start = time.time()
            while time.time() - start < config.UPLOAD_TIMEOUT:
                if is_video_ready(driver):
                    try:
                        el = driver.find_element(By.XPATH, "//a[contains(@href,'sendvid.com')] | //input[contains(@value,'sendvid.com')]")
                        link = (el.get_attribute("href") or el.get_attribute("value")).strip()
                        if link and "sendvid.com" in link:
                            duration = time.time() - start
                            print(f"✅ Успешно: {link} (за {duration:.1f} сек)")
                            return link
                    except:
                        pass
                time.sleep(config.POLL_INTERVAL)
        except Exception as e:
            print(f"Ошибка: {e}")
        time.sleep(10)
    print(f"❌ Не удалось загрузить {video_path.name}")
    return None


def is_video_ready(driver):
    try:
        return "is being converted" in driver.page_source.lower() or bool(driver.find_elements(By.XPATH, "//a[contains(@href,'sendvid.com')] | //input[contains(@value,'sendvid.com')]"))
    except:
        return False


def main():
    folder = Path(config.FOLDER_PATH)
    newpost_path = folder / "newpost.txt"

    print("\n=== Выбор режима ===")
    print("1. Полная очистка и новый сбор (для нового поста)")
    print("2. Дополнить существующие данные (догрузить новые файлы)")
    mode = input("Выберите режим (1 или 2): ").strip()

    if mode == "1":
        if os.path.exists(LINKS_JSON):
            os.remove(LINKS_JSON)
            print("? Старый links.json удалён — начинаем с чистого листа")
    else:
        print("? Режим дополнения — старые данные сохраняются")

    # 1. Изображения
    upload_images(str(folder))

    # 2. Видео
    video_files = sorted(list(folder.glob("*.mp4")))
    links = load_links()
    
    to_upload = []
    for v in video_files:
        key = os.path.splitext(v.name)[0]
        if key not in links["videos"]:
            to_upload.append((key, v))

    if to_upload:
        print(f"\nНужно загрузить {len(to_upload)} видео")
        driver = get_driver()
        try:
            if not is_logged_in(driver):
                login(driver)
            
            total_start = time.time()
            for i, (key, video) in enumerate(to_upload, 1):
                print(f"\n[{i}/{len(to_upload)}] {video.name}")
                link = upload_video(driver, video)
                links["videos"][key] = link if link else f"{video.name} не загрузилось"
                save_links(links)
                time.sleep(random.uniform(*config.DELAY_BETWEEN_UPLOADS))
            
            total_time = time.time() - total_start
            print(f"\n⏱ Все видео обработаны за {total_time:.1f} секунд ({total_time/60:.1f} минут)")
        finally:
            print("Браузер оставлен открытым.")
    else:
        print("✅ Все видео уже загружены.")

    # 3. Создание newpost.txt
    print("\n? Создаём newpost.txt...")
    data = build_from_links(str(folder), sendvid_links=links)
    write_post2(data, str(newpost_path))
    print("? Готово!")


if __name__ == "__main__":
    main()

import os
import re
from collections import OrderedDict


def extract_base_before_date(name_with_ext: str) -> str:
    name = os.path.splitext(os.path.basename(name_with_ext))[0]
    date_pattern = r'(?<=[-_. ])(20\d{2}[-_.](?:0?[1-9]|1[0-2])[-_.](?:0?[1-9]|[12]\d|3[01]))'
    m = re.search(date_pattern, name)
    if m:
        base = name[:m.start()].strip("-_. ")
    else:
        base = name.strip("-_. ")
    base = re.sub(r'[-_](CB|SC|BC|MB|LB|TEASER|CUT[S]?|PREVIEW|202[0-9]-[0-9]{2}.*?)$', '', base, flags=re.I)
    base = re.sub(r'[-_. ](cuts?|preview|teaser|jpg|png|webp)$', '', base, flags=re.I)
    base = base.strip("-_. ")
    base = re.sub(r'[-_. ]+$', '', base)
    return base or name


def normalize_key(text: str) -> str:
    return re.sub(r'[\W_]+', '', text).lower()


def build_from_links(folder_path: str, sendvid_links: dict = None):
    if sendvid_links is None:
        sendvid_links = {"images": {}, "videos": {}}

    mp4_display = {}
    for fn in sorted(os.listdir(folder_path)):
        if fn.lower().endswith(".mp4"):
            display = extract_base_before_date(fn)
            key = normalize_key(display)
            if key not in mp4_display:
                mp4_display[key] = display

    data = OrderedDict()

    # Добавляем картинки + соответствующие видео
    for img_key, url in sendvid_links.get("images", {}).items():
        display = extract_base_before_date(img_key + ".jpg")
        norm_key = normalize_key(display)
        if norm_key not in data:
            data[norm_key] = {
                "display": mp4_display.get(norm_key, display),
                "links": [],
                "sendvid": []
            }
        data[norm_key]["links"].append(f"[img]{url}[/img]")

        # Ищем точную видео-ссылку по полному ключу картинки
        video_key = img_key  # самое важное совпадение
        if video_key in sendvid_links.get("videos", {}):
            data[norm_key]["sendvid"].append(sendvid_links["videos"][video_key])
        else:
            # Запасной поиск
            for vkey, vlink in sendvid_links.get("videos", {}).items():
                if vkey.startswith(img_key) or img_key.startswith(vkey):
                    data[norm_key]["sendvid"].append(vlink)
                    break

    return data


def write_post2(data_odict: OrderedDict, output_path: str):
    items = list(data_odict.values())
    if not items:
        print("Нет данных.")
        return

    singles = [x for x in items if len(x["links"]) == 1]
    multis = [x for x in items if len(x["links"]) > 1]

    lines = []

    if singles:
        first = singles[0]
        singles = singles[1:]
        lines.append(f"[b]{first['display']}[/b]")
        lines.append(first["links"][0])
        if first["sendvid"]:
            lines.append(" ".join(first["sendvid"]))
        lines.append("")

    total = len(singles) + len(multis)
    spoiler_start = f"[spoiler={total} nicknames]"

    # Формируем содержимое спойлера без лишних пустых строк
    spoiler_content = []

    for i in range(0, len(singles), 3):
        group = singles[i:i + 3]
        names_line = " _________ ".join(f"[b]{x['display']}[/b]" for x in group)
        imgs_line = " ".join(x["links"][0] for x in group)
        
        sendvid = [s for x in group for s in x["sendvid"]]
        sendvid_line = " ".join(sendvid) if sendvid else None

        spoiler_content.append(names_line)
        spoiler_content.append(imgs_line)
        if sendvid_line:
            spoiler_content.append(sendvid_line)
        # Добавляем пустую строку только между группами (кроме последней)
        if i + 3 < len(singles):
            spoiler_content.append("")

    # Мультис
    for x in multis:
        if spoiler_content:  # разделяем от предыдущих
            spoiler_content.append("")
        spoiler_content.append(f"[b]{x['display']}[/b]")
        spoiler_content.append(" ".join(x["links"]))
        if x["sendvid"]:
            spoiler_content.append(" ".join(x["sendvid"]))

    # Собираем финальный спойлер
    if spoiler_content:
        lines.append(spoiler_start + " " + spoiler_content[0])
        for line in spoiler_content[1:]:
            lines.append(line)
    else:
        lines.append(spoiler_start)

    lines.append("")
    lines.append("-------")
    lines.append("")
    lines.append("[/spoiler]")

    with open(output_path, "w", encoding="utf-8") as f:
        f.write("\n".join(lines))
    print(f"✅ Записан {output_path}")


if __name__ == "__main__":
    print("template.py готов.")

# Основные настройки
UPLOAD_VID_URL = "https://sendvid.com/"          # Главная страница Sendvid
LOGIN_URL = "https://sendvid.com/users/sign_in"  # Если требуется логин

API_KEY = "YOUR_API_KEY"                         # Замени на свой ключ от imgbb - взять тут https://api.imgbb.com/ после входа в аккаунт
FOLDER_PATH = r"FOLDER_PATH"                     # Путь к папке с видео и картинками
UPLOAD_IMG_URL = "https://api.imgbb.com/1/upload"

# Логин и пароль sendvid
USERNAME = "USERNAME"             # тут заменить на ваш логин
PASSWORD = "PASSWORD"             # тут заменить на ваш пароль

USE_EXISTING_BROWSER = True       # для просмотра загрузки в браузере
DEBUGGING_PORT = 9222

# Задержки в секундах
DELAY_BETWEEN_UPLOADS = (4, 10)   # случайная задержка между загрузками
UPLOAD_TIMEOUT = 360              # максимум 6 минут на одно видео
POLL_INTERVAL = 10                # проверять статус каждые 10 сек