# retoor <retoor@molodetz.nl>

import asyncio
import io
import json
import time
import zipfile
from pathlib import Path
import requests
from playwright.sync_api import expect
from tests.conftest import BASE_URL
from devplacepy.database import get_table, refresh_snapshot
from devplacepy.services.jobs import queue
from devplacepy.services.jobs.zip_service import ZipService
from tests.conftest import run_async
_counter_zip_download = [0]
def _signup_zip_download():
    _counter_zip_download[0] += 1
    name = f"zd{int(time.time() * 1000)}{_counter_zip_download[0]}"
    session = requests.Session()
    session.post(
        f"{BASE_URL}/auth/signup",
        data={
            "username": name,
            "email": f"{name}@t.dev",
            "password": "secret123",
            "confirm_password": "secret123",
            "birth_date": "1990-01-01",
            "accept_terms": "1",
        },
        allow_redirects=True,
    )
    refresh_snapshot()
    key = get_table("users").find_one(username=name)["api_key"]
    return name, key
def _h_zip_download(key):
    return {"X-API-KEY": key, "Accept": "application/json"}
def _create_project_zip_download(key, title):
    r = requests.post(
        f"{BASE_URL}/projects/create",
        headers=_h_zip_download(key),
        data={
            "title": title,
            "description": "zip download test",
            "project_type": "software",
            "status": "In Development",
        },
    )
    assert r.status_code == 200, r.text
    return r.json()["data"]
def _write_zip_download(key, slug, path, content):
    r = requests.post(
        f"{BASE_URL}/projects/{slug}/files/write",
        headers=_h_zip_download(key),
        data={"path": path, "content": content},
        allow_redirects=False,
    )
    assert r.status_code in (200, 302), r.text
def _process_uid(uid):
    async def drive():
        svc = ZipService()
        for _ in range(400):
            await svc.run_once()
            refresh_snapshot()
            job = queue.get_job(uid)
            if job and job["status"] in ("done", "failed"):
                return
            await asyncio.sleep(0.05)

    run_async(drive())
def _drain_pending():
    async def drive():
        svc = ZipService()
        appeared = False
        for _ in range(600):
            refresh_snapshot()
            pending = [
                r
                for r in get_table("jobs").find(kind="zip")
                if r["status"] in ("pending", "running")
            ]
            if pending:
                appeared = True
            await svc.run_once()
            refresh_snapshot()
            pending = [
                r
                for r in get_table("jobs").find(kind="zip")
                if r["status"] in ("pending", "running")
            ]
            if appeared and not pending and not svc._inflight:
                return
            await asyncio.sleep(0.05)

    run_async(drive())
def _cleanup_archives():
    refresh_snapshot()
    jobs = get_table("jobs")
    for row in list(jobs.find(kind="zip")):
        result = json.loads(row.get("result") or "{}")
        local_path = result.get("local_path")
        if local_path:
            Path(local_path).unlink(missing_ok=True)
        jobs.delete(uid=row["uid"])
def _login_zip_download(page, name):
    page.goto(f"{BASE_URL}/auth/login", wait_until="domcontentloaded")
    page.fill("#email", f"{name}@t.dev")
    page.fill("#password", "secret123")
    page.click("button:has-text('Sign in')")
    page.wait_for_url("**/feed", timeout=10000, wait_until="domcontentloaded")


def test_enqueue_project_zip_returns_uid(app_server):
    try:
        _, key = _signup_zip_download()
        proj = _create_project_zip_download(key, "Enqueue Returns Uid")
        slug = proj["slug"] or proj["uid"]
        r = requests.post(f"{BASE_URL}/projects/{slug}/zip", headers=_h_zip_download(key))
        assert r.status_code == 200, r.text
        body = r.json()
        assert body["uid"]
        assert body["status_url"] == f"/zips/{body['uid']}"
    finally:
        _cleanup_archives()


def test_status_pending_then_done_then_download(app_server):
    try:
        _, key = _signup_zip_download()
        proj = _create_project_zip_download(key, "Full Flow")
        slug = proj["slug"] or proj["uid"]
        _write_zip_download(key, slug, "README.md", "# hello")
        _write_zip_download(key, slug, "src/app.py", "print(1)\n")
        uid = requests.post(f"{BASE_URL}/projects/{slug}/zip", headers=_h_zip_download(key)).json()[
            "uid"
        ]

        pending = requests.get(
            f"{BASE_URL}/zips/{uid}", headers={"Accept": "application/json"}
        ).json()
        assert pending["status"] in ("pending", "running")
        assert pending["download_url"] is None

        _process_uid(uid)

        done = requests.get(
            f"{BASE_URL}/zips/{uid}", headers={"Accept": "application/json"}
        ).json()
        assert done["status"] == "done", done
        assert done["download_url"] == f"/zips/{uid}/download"
        assert done["file_count"] == 2 and done["dir_count"] == 1

        dl = requests.get(f"{BASE_URL}{done['download_url']}")
        assert dl.status_code == 200
        assert dl.headers["content-type"] == "application/zip"
        assert "attachment" in dl.headers.get("content-disposition", "")
        assert ".zip" in dl.headers.get("content-disposition", "")
        names = sorted(zipfile.ZipFile(io.BytesIO(dl.content)).namelist())
        assert names == ["README.md", "src/", "src/app.py"]
    finally:
        _cleanup_archives()
