from fastapi import FastAPI, Body
from pydantic import BaseModel
from concurrent.futures import ThreadPoolExecutor
from post_text import post_to_site
from menu_link import add_menu_link
from home_link import add_home_link
from check_site import check_site
from models.site import Site
from fastapi.responses import JSONResponse
import requests
from normalize_url import normalize_site_url
import urllib3
import time
import os
import tempfile
import uuid
import config
from config import LARAVEL_CALLBACK_SECRET, LARAVEL_BASE_URL

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

app = FastAPI()

# Кол-во потоков можно регулировать тут
executor = ThreadPoolExecutor(max_workers=10)

# Для /health: задачи в работе и время жизни сервиса. uvicorn запущен с
# несколькими воркерами-процессами, поэтому счётчик общий — файл-маркер на
# задачу в TASKS_DIR (в /tmp контейнера, обнуляется при перезапуске).
START_TIME = time.time()
TASKS_DIR = os.getenv("TASKS_DIR", os.path.join(tempfile.gettempdir(), "postbird-tasks"))
os.makedirs(TASKS_DIR, exist_ok=True)


def active_tasks_count() -> int:
    try:
        return len(os.listdir(TASKS_DIR))
    except OSError:
        return 0


def submit_tracked(fn, *args):
    """Отправить задачу в пул и учесть её в active_tasks."""
    marker = os.path.join(TASKS_DIR, uuid.uuid4().hex)
    open(marker, "w").close()

    def run():
        try:
            fn(*args)
        finally:
            try:
                os.remove(marker)
            except OSError:
                pass

    try:
        return executor.submit(run)
    except Exception:
        os.remove(marker)
        raise


# ------- MODELS -------
class Payload(BaseModel):
    site: Site
    title: str
    body_html: str


class FooterLinkPayload(Site):
    link_url: str
    anchor: str = ""
    # Готовый HTML абзаца для главной (сгенерирован Laravel). Пусто — сервис соберёт сам.
    content_html: str = ""

# ------- CALLBACKS TO LARAVEL -------

def send_callback_with_retry(endpoint: str, payload: dict, max_retries: int = 4):
    """Send callback to Laravel with exponential backoff retry"""
    url = f"{LARAVEL_BASE_URL}{endpoint}"

    for attempt in range(max_retries):
        try:
            response = requests.post(url, json=payload, timeout=10, verify=config.callback_verify_ssl())
            print(f"📤 Callback {endpoint} status: {response.status_code}")
            if response.status_code < 500:
                return response
            print(f"⚠️ Server error, attempt {attempt + 1}/{max_retries}")
        except requests.exceptions.RequestException as e:
            print(f"❌ Request failed, attempt {attempt + 1}/{max_retries}: {e}")

        if attempt < max_retries - 1:
            sleep_time = 2 ** (attempt + 1)  # 2, 4, 8 seconds
            print(f"⏳ Retrying in {sleep_time}s...")
            time.sleep(sleep_time)

    print(f"❌ All {max_retries} attempts failed for {endpoint}")
    return None

def notify_laravel_post(text_id: int, site_id: int, status: str, url: str = None, error: str = None):
    payload = {
        "text_id": text_id,
        "site_id": site_id,
        "status": status,
        "url": url,
        "error": error,
        "secret": LARAVEL_CALLBACK_SECRET
    }
    send_callback_with_retry("/api/publish-callback", payload)

def notify_laravel_checked(site_id: int, status: str, error: str = None, check_token: str = None,
                           url: str = None, login_url: str = None):
    payload = {
        "site_id": site_id,
        "status": status,
        "error": error,
        "check_token": check_token,
        # Адреса, найденные при проверке: Laravel сохранит их у сайта.
        "url": url,
        "login_url": login_url,
        "secret": LARAVEL_CALLBACK_SECRET
    }
    send_callback_with_retry("/api/checked-callback", payload)

# ------- BACKGROUND TASKS -------

def background_publish(site_data: dict, title: str, body_html: str):
    site = Site(**site_data)
    try:
        success, result = post_to_site(site, title, body_html)
        if success:
            notify_laravel_post(site.text_id, site.id, "posted", url=result)
        else:
            notify_laravel_post(site.text_id, site.id, "error", error=str(result))
    except Exception as e:
        notify_laravel_post(site.text_id, site.id, "error", error=str(e))

def background_check(site_data: dict):
    site = Site(**site_data)
    try:
        success, result = check_site(site)
        if success:
            notify_laravel_checked(site.id, "OK", check_token=site.check_token,
                                   url=site.url, login_url=site.login_url)
        else:
            notify_laravel_checked(site.id, "error", error=str(result), check_token=site.check_token,
                                   url=site.url, login_url=site.login_url)
    except Exception as e:
        notify_laravel_checked(site.id, "error", error=str(e), check_token=site.check_token)

# ------- ENDPOINTS -------

@app.get("/health")
async def health():
    return {
        "status": "ok",
        "active_tasks": active_tasks_count(),
        "uptime_seconds": int(time.time() - START_TIME),
    }

@app.post("/publish")
async def publish(payload: Payload):
    try:
        # Submit directly to thread pool, no need for extra threading.Thread
        submit_tracked(background_publish, payload.site.dict(), payload.title, payload.body_html)
        return {"success": True, "message": "Задача публикации запущена в фоне"}
    except Exception as e:
        return JSONResponse(status_code=500, content={"success": False, "error": str(e)})

@app.post("/check")
async def check(site: Site = Body(...)):
    try:
        # Normalize URL before submitting
        normalize_site_url(site)
        # Submit directly to thread pool
        submit_tracked(background_check, site.dict())
        return {"success": True, "message": "Задача проверки запущена в фоне"}
    except Exception as e:
        return JSONResponse(status_code=500, content={"success": False, "error": str(e)})


@app.post("/test-post")
def test_post(site: Site = Body(...)):
    """Опубликовать тестовый пост. Синхронно: Laravel ждёт результат."""
    try:
        normalize_site_url(site)
        title = "Проверка публикации"
        body = "<p>Это тестовый пост, созданный автоматически для проверки доступа к сайту.</p>"
        success, result = post_to_site(site, title, body)
        if success:
            return {"success": True, "url": result}
        return {"success": False, "error": str(result)}
    except Exception as e:
        return JSONResponse(status_code=500, content={"success": False, "error": str(e)})


@app.post("/menu-link")
def menu_link(payload: FooterLinkPayload = Body(...)):
    """Добавить ссылку в меню сайта. Синхронно: Laravel ждёт результат."""
    try:
        site = Site(**{k: getattr(payload, k) for k in Site.model_fields})
        normalize_site_url(site)
        success, result = add_menu_link(site, payload.link_url, payload.anchor)
        if success:
            return {"success": True, "menu": result}
        return {"success": False, "error": str(result)}
    except Exception as e:
        return JSONResponse(status_code=500, content={"success": False, "error": str(e)})


@app.post("/home-link")
def home_link(payload: FooterLinkPayload = Body(...)):
    """Поставить ссылку с окружающим текстом на главную. Синхронно."""
    try:
        site = Site(**{k: getattr(payload, k) for k in Site.model_fields})
        normalize_site_url(site)
        success, result = add_home_link(site, payload.link_url, payload.anchor, payload.content_html or None)
        if success:
            return {"success": True, "url": result}
        return {"success": False, "error": str(result)}
    except Exception as e:
        return JSONResponse(status_code=500, content={"success": False, "error": str(e)})
