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