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 сек

    resp = await client.post(
        f"{BASE_URL}/api/stream/play",
        params={
            "streamerId": name,
            "playerId": "hls",
            "serverId": servers[0]["id"],
            "verId": "",
            "t": str(int(time.time() * 1000)),
            "c": "1",
        },
        json={},
    )
    if resp.status_code != 200:
        logger.warning(f"[{name}] HTTP {resp.status_code}")
        return None
    data = resp.json()
    url = data.get("result", {}).get("url")
    if not url:
        logger.warning(f"[{name}] No URL in response: {data}")
        return None
    return url