main.py

import io, json, os, re, secrets, threading, uuid, uvicorn, zipfile
from html import escape
from datetime import datetime, timezone
from pathlib import Path
from fastapi import BackgroundTasks, FastAPI, File, Form, HTTPException, Request, UploadFile
from fastapi.middleware.cors import CORSMiddleware
from starlette.status import HTTP_401_UNAUTHORIZED, HTTP_500_INTERNAL_SERVER_ERROR
from pydantic import BaseModel
from typing import Dict, List, Optional
from fastapi.responses import StreamingResponse
from urllib.parse import parse_qs, urlparse
from dotenv import load_dotenv

from googleapiclient.discovery import build
from googleapiclient.http import MediaIoBaseDownload, MediaIoBaseUpload
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
import fitz 

load_dotenv()

app = FastAPI()

PUBLIC_PATHS = {"/health", "/auth/login"}


def load_auth_users() -> Dict[str, dict]:
    auth_users_json = os.getenv("AUTH_USERS_JSON")
    if not auth_users_json:
        raise RuntimeError(
            "Brak konfiguracji logowania. Ustaw zmienna srodowiskowa AUTH_USERS_JSON."
        )

    try:
        parsed_users = json.loads(auth_users_json)
    except json.JSONDecodeError as exc:
        raise RuntimeError("AUTH_USERS_JSON musi byc poprawnym JSON-em.") from exc

    if not isinstance(parsed_users, dict) or not parsed_users:
        raise RuntimeError("AUTH_USERS_JSON musi byc niepustym obiektem JSON.")

    normalized_users: Dict[str, dict] = {}
    for username, user_config in parsed_users.items():
        if not isinstance(username, str) or not username.strip():
            raise RuntimeError("AUTH_USERS_JSON zawiera nieprawidlowa nazwe uzytkownika.")
        if not isinstance(user_config, dict):
            raise RuntimeError(f"Konfiguracja uzytkownika '{username}' musi byc obiektem.")

        password = user_config.get("password")
        display_name = user_config.get("display_name")
        if not isinstance(password, str) or not password:
            raise RuntimeError(f"Uzytkownik '{username}' musi miec niepuste pole 'password'.")
        if not isinstance(display_name, str) or not display_name:
            raise RuntimeError(f"Uzytkownik '{username}' musi miec niepuste pole 'display_name'.")

        normalized_users[username.strip()] = {
            "password": password,
            "display_name": display_name,
        }

    return normalized_users

SERVICE_API_TOKEN = os.getenv("API_AUTH_TOKEN")

if not SERVICE_API_TOKEN:
    raise RuntimeError(
        "Brak konfiguracji auth. Ustaw zmienna srodowiskowa API_AUTH_TOKEN."
    )

AUTH_USERS = load_auth_users()

ACTIVE_SESSIONS: Dict[str, dict] = {}
SESSION_LOCK = threading.RLock()

allowed_origins = [
    origin
    for origin in [
        "http://localhost:5173",
        "http://127.0.0.1:5173",
        os.getenv("FRONTEND_URL", "").rstrip("/"),
    ]
    if origin
]

app.add_middleware(
    CORSMiddleware,
    allow_origins=allowed_origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)


def build_auth_error_response(status_code: int, detail: str) -> StreamingResponse:
    return StreamingResponse(
        iter([json.dumps({"detail": detail})]),
        status_code=status_code,
        media_type="application/json",
        headers={"WWW-Authenticate": 'Bearer realm="py-pdf"'},
    )


def is_valid_service_token(authorization_header: str) -> bool:
    auth_type, _, auth_value = authorization_header.partition(" ")
    if auth_type.lower() != "bearer" or not auth_value:
        return False

    return secrets.compare_digest(auth_value, SERVICE_API_TOKEN)


def create_session(username: str) -> str:
    token = secrets.token_urlsafe(32)
    with SESSION_LOCK:
        ACTIVE_SESSIONS[token] = {
            "username": username,
            "created_at": datetime.now(timezone.utc).isoformat(),
        }
    return token


def get_session_from_bearer(authorization_header: str) -> Optional[dict]:
    auth_type, _, auth_value = authorization_header.partition(" ")
    if auth_type.lower() != "bearer" or not auth_value:
        return None

    with SESSION_LOCK:
        return ACTIVE_SESSIONS.get(auth_value)


@app.middleware("http")
async def require_bearer_auth(request: Request, call_next):
    if request.method == "OPTIONS" or request.url.path in PUBLIC_PATHS:
        return await call_next(request)

    authorization_header = request.headers.get("Authorization", "")
    if not authorization_header:
        return build_auth_error_response(HTTP_401_UNAUTHORIZED, "Brak autoryzacji.")

    if is_valid_service_token(authorization_header):
        request.state.user = {"username": "n8n", "type": "service"}
        return await call_next(request)

    session = get_session_from_bearer(authorization_header)
    if session:
        request.state.user = {**session, "type": "user"}
        return await call_next(request)

    return build_auth_error_response(HTTP_401_UNAUTHORIZED, "Nieprawidlowa autoryzacja.")


@app.get("/health")
async def healthcheck():
    return {"status": "ok"}

# --- KONFIGURACJA OAUTH2 ---
SCOPES = ['https://www.googleapis.com/auth/drive']
CLIENT_SECRETS_FILE = 'client_secrets.json' # Plik z Kroku 1
JOBS_DIR = Path("job_data")
JOB_LOCK = threading.RLock()

JOBS_DIR.mkdir(exist_ok=True)

def get_user_credentials():
    creds = None
    # Plik token.json przechowuje tokeny dostępu użytkownika
    if os.path.exists('token.json'):
        creds = Credentials.from_authorized_user_file('token.json', SCOPES)
    
    # Jeśli nie ma tokena lub jest nieważny - zaloguj użytkownika
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(CLIENT_SECRETS_FILE, SCOPES)
            # To otworzy przeglądarkę przy pierwszym uruchomieniu!
            creds = flow.run_local_server(port=0)
        
        with open('token.json', 'w') as token:
            token.write(creds.to_json())
    return creds

class LoginRequest(BaseModel):
    username: str
    password: str


class SplitRequest(BaseModel):
    file_id: str
    folder_id: str


class DriveFolderInspectRequest(BaseModel):
    folder_link: str


PDF_TOOL_OPERATIONS = {"merge", "split"}


class InspectJobCreateResponse(BaseModel):
    job_id: str
    status: str
    status_url: str
    result_url: str


def utc_now_iso() -> str:
    return datetime.now(timezone.utc).isoformat()


def get_job_file_path(job_id: str) -> Path:
    return JOBS_DIR / f"{job_id}.json"


def read_job(job_id: str) -> dict:
    job_file = get_job_file_path(job_id)
    if not job_file.exists():
        raise HTTPException(status_code=404, detail="Job nie istnieje.")

    with job_file.open("r", encoding="utf-8") as job_stream:
        return json.load(job_stream)


def list_jobs() -> List[dict]:
    jobs = []

    with JOB_LOCK:
        for job_file in JOBS_DIR.glob("*.json"):
            with job_file.open("r", encoding="utf-8") as job_stream:
                jobs.append(json.load(job_stream))

    jobs.sort(key=lambda job: job.get("created_at") or "", reverse=True)
    return jobs


def write_job(job_data: dict) -> None:
    job_file = get_job_file_path(job_data["job_id"])
    temp_file = job_file.with_suffix(".json.tmp")

    with JOB_LOCK:
        with temp_file.open("w", encoding="utf-8") as job_stream:
            json.dump(job_data, job_stream, ensure_ascii=True, indent=2)
        temp_file.replace(job_file)


def update_job(job_id: str, **fields) -> dict:
    with JOB_LOCK:
        job_data = read_job(job_id)
        job_data.update(fields)
        job_data["updated_at"] = utc_now_iso()

        job_file = get_job_file_path(job_id)
        temp_file = job_file.with_suffix(".json.tmp")
        with temp_file.open("w", encoding="utf-8") as job_stream:
            json.dump(job_data, job_stream, ensure_ascii=True, indent=2)
        temp_file.replace(job_file)

    return job_data


def create_job(folder_link: str) -> dict:
    job_id = str(uuid.uuid4())
    job_data = {
        "job_id": job_id,
        "status": "queued",
        "cancel_requested": False,
        "folder_link": folder_link,
        "folder_id": None,
        "folder_name": None,
        "total_files": None,
        "processed_files": 0,
        "progress_pct": 0,
        "result": None,
        "error": None,
        "created_at": utc_now_iso(),
        "updated_at": utc_now_iso(),
        "started_at": None,
        "cancelled_at": None,
        "finished_at": None,
    }
    write_job(job_data)
    return job_data


def is_job_cancel_requested(job_id: str) -> bool:
    job_data = read_job(job_id)
    return bool(job_data.get("cancel_requested"))


def extract_google_drive_folder_id(folder_link: str) -> str:
    folder_link = folder_link.strip()

    folder_patterns = [
        r"drive/folders/([a-zA-Z0-9_-]+)",
        r"folders/([a-zA-Z0-9_-]+)",
    ]
    for pattern in folder_patterns:
        match = re.search(pattern, folder_link)
        if match:
            return match.group(1)

    parsed_url = urlparse(folder_link)
    query_params = parse_qs(parsed_url.query)
    if "id" in query_params and query_params["id"]:
        return query_params["id"][0]

    if re.fullmatch(r"[a-zA-Z0-9_-]{10,}", folder_link):
        return folder_link

    raise HTTPException(status_code=400, detail="Nieprawidlowy link lub identyfikator folderu Google Drive.")


def points_to_mm(points: float) -> float:
    return round(points * 0.3527, 2)


def sanitize_pdf_basename(filename: Optional[str]) -> str:
    base_name = Path(filename or "plik.pdf").stem.strip() or "plik"
    base_name = re.sub(r'[\/:*?"<>|]+', '_', base_name)
    base_name = re.sub(r'\s+', ' ', base_name).strip()
    return base_name or "plik"


def merge_pdf_documents(files: List[tuple[str, bytes]]) -> bytes:
    merged_document = fitz.open()

    try:
        for _, file_bytes in files:
            pdf_document = fitz.open(stream=file_bytes, filetype="pdf")
            try:
                if len(pdf_document) == 0:
                    raise HTTPException(status_code=400, detail="Jeden z przeslanych PDF-ow jest pusty.")
                merged_document.insert_pdf(pdf_document)
            finally:
                pdf_document.close()

        output_stream = io.BytesIO()
        merged_document.save(output_stream)
        return output_stream.getvalue()
    finally:
        merged_document.close()


def split_pdf_documents(files: List[tuple[str, bytes]]) -> bytes:
    output_stream = io.BytesIO()

    with zipfile.ZipFile(output_stream, mode="w", compression=zipfile.ZIP_DEFLATED) as archive:
        for filename, file_bytes in files:
            pdf_document = fitz.open(stream=file_bytes, filetype="pdf")
            try:
                if len(pdf_document) == 0:
                    raise HTTPException(status_code=400, detail="Jeden z przeslanych PDF-ow jest pusty.")

                base_name = sanitize_pdf_basename(filename)

                for page_index in range(len(pdf_document)):
                    single_page_pdf = fitz.open()
                    try:
                        single_page_pdf.insert_pdf(pdf_document, from_page=page_index, to_page=page_index)
                        page_stream = io.BytesIO()
                        single_page_pdf.save(page_stream)
                        archive.writestr(f"{base_name}_({page_index + 1}).pdf", page_stream.getvalue())
                    finally:
                        single_page_pdf.close()
            finally:
                pdf_document.close()

    output_stream.seek(0)
    return output_stream.getvalue()


def split_single_pdf_document(filename: str, file_bytes: bytes) -> bytes:
    return split_pdf_documents([(filename, file_bytes)])


def create_drive_folder(service, parent_folder_id: str, folder_name: str) -> dict:
    folder_metadata = {
        "name": folder_name,
        "mimeType": "application/vnd.google-apps.folder",
        "parents": [parent_folder_id.strip()],
    }

    return service.files().create(
        body=folder_metadata,
        fields="id, name, webViewLink",
        supportsAllDrives=True,
    ).execute()


def build_dimensions_table_html(
    page_results: List[dict],
    folder_link: Optional[str] = None,
) -> str:
    total_pages = len(page_results)
    rows = [
        "<tr>"
        f"<td style=\"border:1px solid #ccc;padding:8px;text-align:center;\">{index + 1}</td>"
        f"<td style=\"border:1px solid #ccc;padding:8px;text-align:center;\">{escape(page_result['fileName'])}</td>"
        f"<td style=\"border:1px solid #ccc;padding:8px;\"><a href=\"{escape(page_result['link'] or '')}\">Otwórz plik</a></td>"
        f"<td style=\"border:1px solid #ccc;padding:8px;text-align:center;\">{page_result['page']}</td>"
        f"<td style=\"border:1px solid #ccc;padding:8px;text-align:center;\">{total_pages}</td>"
        f"<td style=\"border:1px solid #ccc;padding:8px;text-align:center;\">{page_result['width_mm']}</td>"
        f"<td style=\"border:1px solid #ccc;padding:8px;text-align:center;\">{page_result['height_mm']}</td>"
        "</tr>"
        for index, page_result in enumerate(page_results)
    ]

    return (
        "<html><body style=\"font-family:Arial,sans-serif;\">"
        "<h2>Raport PDF</h2>"
        f"<h3>Link do folderu: <a href=\"{escape(folder_link or '')}\">{escape(folder_link or '')}</a></h3>"
        f"<p><strong>Liczba wygenerowanych plików:</strong> {total_pages}</p>"
        "<table style=\"border-collapse:collapse;width:100%;font-size:14px;\">"
        "<thead><tr style=\"background:#f3f3f3;\">"
        "<th style=\"border:1px solid #ccc;padding:8px;\">#</th>"
        "<th style=\"border:1px solid #ccc;padding:8px;\">Nazwa pliku</th>"
        "<th style=\"border:1px solid #ccc;padding:8px;\">Nowy plik</th>"
        "<th style=\"border:1px solid #ccc;padding:8px;\">Strona</th>"
        "<th style=\"border:1px solid #ccc;padding:8px;\">Liczba stron</th>"
        "<th style=\"border:1px solid #ccc;padding:8px;\">Szerokość (mm)</th>"
        "<th style=\"border:1px solid #ccc;padding:8px;\">Wysokość (mm)</th>"
        "</tr></thead>"
        f"<tbody>{''.join(rows)}</tbody>"
        "</table></body></html>"
    )


def upload_split_pdf_to_drive(
    service,
    filename: str,
    file_bytes: bytes,
    parent_folder_id: str,
    uploader_email: Optional[str] = None,
) -> dict:
    pdf_document = fitz.open(stream=file_bytes, filetype="pdf")

    try:
        total_pages = len(pdf_document)
        if total_pages == 0:
            raise HTTPException(status_code=400, detail="Przeslany PDF jest pusty.")

        results = []
        source_base_name = sanitize_pdf_basename(filename)
        target_folder = create_drive_folder(service, parent_folder_id, source_base_name)

        for i in range(total_pages):
            page = pdf_document[i]
            rect = page.rect
            w_mm = round(rect.width * 0.3527, 2)
            h_mm = round(rect.height * 0.3527, 2)

            new_pdf = fitz.open()
            try:
                new_pdf.insert_pdf(pdf_document, from_page=i, to_page=i)

                output_stream = io.BytesIO()
                new_pdf.save(output_stream)
                output_stream.seek(0)

                new_file_metadata = {
                    "name": f"{source_base_name}_({i + 1}).pdf",
                    "parents": [target_folder["id"]],
                }

                media = MediaIoBaseUpload(
                    output_stream,
                    mimetype="application/pdf",
                    resumable=True,
                )

                uploaded_file = service.files().create(
                    body=new_file_metadata,
                    media_body=media,
                    fields="id, webViewLink",
                    supportsAllDrives=True,
                ).execute()
            finally:
                new_pdf.close()

            results.append({
                "page": i + 1,
                "file_id": uploaded_file.get("id"),
                "link": uploaded_file.get("webViewLink"),
                "fileName": new_file_metadata["name"],
                "target_folder_id": target_folder["id"],
                "target_folder_name": target_folder["name"],
                "target_folder_link": target_folder.get("webViewLink"),
                "width_mm": w_mm,
                "height_mm": h_mm,
                "uploader_email": uploader_email,
            })

        return {
            "source_file_name": filename,
            "target_folder_id": target_folder["id"],
            "target_folder_name": target_folder["name"],
            "target_folder_link": target_folder.get("webViewLink"),
            "pages": results,
            "dimensions_table_html": build_dimensions_table_html(
                results,
                target_folder.get("webViewLink"),
            ),
        }
    finally:
        pdf_document.close()


def read_pdf_dimensions(service, file_id: str) -> dict:
    drive_request = service.files().get_media(
        fileId=file_id,
        supportsAllDrives=True
    )

    file_stream = io.BytesIO()
    downloader = MediaIoBaseDownload(file_stream, drive_request)

    done = False
    while not done:
        _, done = downloader.next_chunk()

    file_stream.seek(0)
    pdf_document = fitz.open(stream=file_stream, filetype="pdf")

    page_dimensions = []
    for page_index in range(len(pdf_document)):
        rect = pdf_document[page_index].rect
        page_dimensions.append({
            "page": page_index + 1,
            "width_mm": points_to_mm(rect.width),
            "height_mm": points_to_mm(rect.height),
        })

    pdf_document.close()

    unique_sizes = {
        (page["width_mm"], page["height_mm"])
        for page in page_dimensions
    }

    result = {
        "page_count": len(page_dimensions),
        "pages": page_dimensions,
        "dimensions_source": "pdf_content",
    }

    if len(unique_sizes) == 1 and page_dimensions:
        result["width_mm"] = page_dimensions[0]["width_mm"]
        result["height_mm"] = page_dimensions[0]["height_mm"]

    return result


def build_file_inspection_result(service, file_item: dict) -> dict:
    result = {
        "file_id": file_item.get("id"),
        "name": file_item.get("name"),
        "mime_type": file_item.get("mimeType"),
        "web_view_link": file_item.get("webViewLink"),
        "folder_path": file_item.get("folder_path"),
        "size_bytes": int(file_item["size"]) if file_item.get("size") else None,
        "width_mm": None,
        "height_mm": None,
        "page_count": None,
        "pages": None,
        "dimensions_source": "unavailable",
    }

    if file_item.get("mimeType") == "application/pdf":
        result.update(read_pdf_dimensions(service, file_item["id"]))
        return result

    return result


def list_folder_children(service, folder_id: str) -> List[dict]:
    items = []
    page_token: Optional[str] = None

    while True:
        response = service.files().list(
            q=f"'{folder_id}' in parents and trashed = false",
            fields="nextPageToken, files(id, name, mimeType, size, webViewLink)",
            includeItemsFromAllDrives=True,
            supportsAllDrives=True,
            pageToken=page_token
        ).execute()

        items.extend(response.get("files", []))
        page_token = response.get("nextPageToken")

        if not page_token:
            break

    return items


def collect_pdf_files_recursively(service, root_folder_id: str, root_folder_name: str) -> List[dict]:
    pdf_files = []
    folders_to_visit = [
        {
            "id": root_folder_id,
            "path": root_folder_name,
        }
    ]

    while folders_to_visit:
        current_folder = folders_to_visit.pop()
        child_items = list_folder_children(service, current_folder["id"])

        for item in child_items:
            if item.get("mimeType") == "application/vnd.google-apps.folder":
                folders_to_visit.append({
                    "id": item["id"],
                    "path": f'{current_folder["path"]}/{item["name"]}',
                })
                continue

            if item.get("mimeType") == "application/pdf":
                item["folder_path"] = current_folder["path"]
                pdf_files.append(item)

    return pdf_files


def inspect_drive_folder_sync(folder_link: str) -> dict:
    creds = get_user_credentials()
    service = build('drive', 'v3', credentials=creds)

    folder_id = extract_google_drive_folder_id(folder_link)
    folder_meta = service.files().get(
        fileId=folder_id,
        fields="id, name, mimeType",
        supportsAllDrives=True
    ).execute()

    if folder_meta.get("mimeType") != "application/vnd.google-apps.folder":
        raise HTTPException(status_code=400, detail="Podany link nie wskazuje na folder Google Drive.")

    files = collect_pdf_files_recursively(service, folder_id, folder_meta.get("name"))
    results = [build_file_inspection_result(service, file_item) for file_item in files]

    return {
        "folder_id": folder_meta.get("id"),
        "folder_name": folder_meta.get("name"),
        "file_count": len(results),
        "files": results,
    }


def run_inspection_job(job_id: str) -> None:
    try:
        job_data = read_job(job_id)
        print(f"[JOB {job_id}] queued -> running")
        update_job(
            job_id,
            status="running",
            started_at=utc_now_iso(),
            error=None,
        )

        if is_job_cancel_requested(job_id):
            print(f"[JOB {job_id}] cancelled before start")
            update_job(
                job_id,
                status="cancelled",
                cancelled_at=utc_now_iso(),
                finished_at=utc_now_iso(),
            )
            return

        creds = get_user_credentials()
        service = build('drive', 'v3', credentials=creds)

        folder_id = extract_google_drive_folder_id(job_data["folder_link"])
        folder_meta = service.files().get(
            fileId=folder_id,
            fields="id, name, mimeType",
            supportsAllDrives=True
        ).execute()

        if folder_meta.get("mimeType") != "application/vnd.google-apps.folder":
            raise HTTPException(status_code=400, detail="Podany link nie wskazuje na folder Google Drive.")

        files = collect_pdf_files_recursively(service, folder_id, folder_meta.get("name"))
        total_files = len(files)
        print(f"[JOB {job_id}] folder='{folder_meta.get('name')}' pdf_count={total_files}")
        update_job(
            job_id,
            folder_id=folder_meta.get("id"),
            folder_name=folder_meta.get("name"),
            total_files=total_files,
            processed_files=0,
            progress_pct=0,
        )

        results = []
        for index, file_item in enumerate(files, start=1):
            if is_job_cancel_requested(job_id):
                print(f"[JOB {job_id}] cancelled at {index - 1}/{total_files}")
                update_job(
                    job_id,
                    status="cancelled",
                    cancelled_at=utc_now_iso(),
                    finished_at=utc_now_iso(),
                    result={
                        "folder_id": folder_meta.get("id"),
                        "folder_name": folder_meta.get("name"),
                        "file_count": len(results),
                        "files": results,
                    },
                )
                return

            results.append(build_file_inspection_result(service, file_item))
            progress_pct = 100 if total_files == 0 else round(index / total_files * 100, 2)
            print(f"[JOB {job_id}] processed {index}/{total_files} ({progress_pct}%) file='{file_item.get('name')}'")
            update_job(
                job_id,
                processed_files=index,
                progress_pct=progress_pct,
            )

        print(f"[JOB {job_id}] completed {total_files}/{total_files}")
        update_job(
            job_id,
            status="completed",
            progress_pct=100,
            processed_files=total_files,
            finished_at=utc_now_iso(),
            result={
                "folder_id": folder_meta.get("id"),
                "folder_name": folder_meta.get("name"),
                "file_count": len(results),
                "files": results,
            },
        )
    except Exception as e:
        print(f"[JOB {job_id}] failed: {str(e)}")
        update_job(
            job_id,
            status="failed",
            error=str(e),
            finished_at=utc_now_iso(),
        )

@app.post("/auth/login")
async def login(request: LoginRequest):
    username = request.username.strip()
    user = AUTH_USERS.get(username)

    if not user or not secrets.compare_digest(user["password"], request.password):
        raise HTTPException(status_code=401, detail="Nieprawidlowy login lub haslo.")

    token = create_session(username)

    return {
        "access_token": token,
        "token_type": "bearer",
        "user": {
            "username": username,
            "display_name": user["display_name"],
        },
    }


@app.post("/pdf-tools")
async def process_pdf_tools(
    operation: str = Form(...),
    files: List[UploadFile] = File(...),
):
    selected_operation = operation.strip().lower()

    if selected_operation not in PDF_TOOL_OPERATIONS:
        raise HTTPException(status_code=400, detail="Nieprawidlowa operacja. Uzyj 'merge' albo 'split'.")

    if not files:
        raise HTTPException(status_code=400, detail="Dodaj przynajmniej jeden plik PDF.")

    loaded_files: List[tuple[str, bytes]] = []

    for upload in files:
        filename = upload.filename or "plik.pdf"
        if not filename.lower().endswith(".pdf"):
            raise HTTPException(status_code=400, detail=f"Plik '{filename}' nie jest PDF-em.")

        file_bytes = await upload.read()
        if not file_bytes:
            raise HTTPException(status_code=400, detail=f"Plik '{filename}' jest pusty.")

        loaded_files.append((filename, file_bytes))

    try:
        if selected_operation == "merge":
            merged_pdf = merge_pdf_documents(loaded_files)
            headers = {"Content-Disposition": 'attachment; filename="merged.pdf"'}
            return StreamingResponse(io.BytesIO(merged_pdf), media_type="application/pdf", headers=headers)

        split_archive = split_pdf_documents(loaded_files)
        headers = {"Content-Disposition": 'attachment; filename="split_pdf.zip"'}
        return StreamingResponse(io.BytesIO(split_archive), media_type="application/zip", headers=headers)
    except HTTPException:
        raise
    except Exception as e:
        print(f"BLAD PDF TOOLS: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/split-pdf-file")
async def split_pdf_file(file: UploadFile = File(...)):
    filename = file.filename or "plik.pdf"
    if not filename.lower().endswith(".pdf"):
        raise HTTPException(status_code=400, detail=f"Plik '{filename}' nie jest PDF-em.")

    file_bytes = await file.read()
    if not file_bytes:
        raise HTTPException(status_code=400, detail=f"Plik '{filename}' jest pusty.")

    try:
        split_archive = split_single_pdf_document(filename, file_bytes)
        archive_name = f"{sanitize_pdf_basename(filename)}_split.zip"
        headers = {"Content-Disposition": f'attachment; filename="{archive_name}"'}
        return StreamingResponse(io.BytesIO(split_archive), media_type="application/zip", headers=headers)
    except HTTPException:
        raise
    except Exception as e:
        print(f"BLAD SPLIT PDF FILE: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/split-pdf-upload")
async def split_pdf_upload(
    folder_id: str = Form(...),
    file: UploadFile = File(...),
):
    filename = file.filename or "plik.pdf"
    if not filename.lower().endswith(".pdf"):
        raise HTTPException(status_code=400, detail=f"Plik '{filename}' nie jest PDF-em.")

    file_bytes = await file.read()
    if not file_bytes:
        raise HTTPException(status_code=400, detail=f"Plik '{filename}' jest pusty.")

    creds = get_user_credentials()
    service = build('drive', 'v3', credentials=creds)

    try:
        return upload_split_pdf_to_drive(
            service=service,
            filename=filename,
            file_bytes=file_bytes,
            parent_folder_id=folder_id,
            uploader_email=None,
        )
    except HTTPException:
        raise
    except Exception as e:
        print(f"BLAD SPLIT PDF UPLOAD: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/split-pdf-legacy")
async def split_pdf_legacy(request: SplitRequest):
    creds = get_user_credentials()
    service = build('drive', 'v3', credentials=creds)

    try:
        print(f"Pobieram metadane pliku (legacy): {request.file_id}")
        file_meta = service.files().get(
            fileId=request.file_id,
            fields="name, owners",
            supportsAllDrives=True
        ).execute()

        owners = file_meta.get('owners', [])
        uploader_email = owners[0].get('emailAddress') if owners else "n8n.deeprint@gmail.com"
        print(f"Wlasciciel pliku (legacy): {uploader_email}")

        drive_request = service.files().get_media(
            fileId=request.file_id,
            supportsAllDrives=True
        )

        file_stream = io.BytesIO()
        downloader = MediaIoBaseDownload(file_stream, drive_request)

        done = False
        while not done:
            status, done = downloader.next_chunk()
            if status:
                print(f"Pobrano (legacy): {int(status.progress() * 100)}%")

        file_stream.seek(0)
        pdf_document = fitz.open(stream=file_stream, filetype="pdf")
        total_pages = len(pdf_document)
        results = []

        for i in range(total_pages):
            page = pdf_document[i]
            rect = page.rect

            w_mm = round(rect.width * 0.3527, 2)
            h_mm = round(rect.height * 0.3527, 2)

            new_pdf = fitz.open()
            new_pdf.insert_pdf(pdf_document, from_page=i, to_page=i)

            output_stream = io.BytesIO()
            new_pdf.save(output_stream)
            output_stream.seek(0)

            new_file_metadata = {
                'name': f'{file_meta.get("name")}_{i+1}',
                'parents': [request.folder_id.strip()]
            }

            media = MediaIoBaseUpload(
                output_stream,
                mimetype='application/pdf',
                resumable=True
            )

            uploaded_file = service.files().create(
                body=new_file_metadata,
                media_body=media,
                fields='id, webViewLink',
                supportsAllDrives=True
            ).execute()

            results.append({
                "page": i + 1,
                "file_id": uploaded_file.get('id'),
                "link": uploaded_file.get('webViewLink'),
                "fileName": file_meta.get("name"),
                "width_mm": w_mm,
                "height_mm": h_mm,
                "uploader_email": uploader_email
            })

            new_pdf.close()
            print(f"Zakonczono strone legacy {i+1}/{total_pages}")

        pdf_document.close()
        return results

    except Exception as e:
        print(f"BLAD KRYTYCZNY LEGACY: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/split-pdf")
async def split_pdf(request: SplitRequest):
    creds = get_user_credentials()
    service = build('drive', 'v3', credentials=creds)
    
    try:
        # 1. POBIERANIE METADANYCH (EMAIL WŁAŚCICIELA)
        print(f"Pobieram metadane pliku: {request.file_id}")
        file_meta = service.files().get(
            fileId=request.file_id, 
            fields="name, owners",
            supportsAllDrives=True
        ).execute()
        
        # Wyciągamy maila osoby, która wrzuciła plik
        owners = file_meta.get('owners', [])
        uploader_email = owners[0].get('emailAddress') if owners else "n8n.deeprint@gmail.com"
        print(f"Właściciel pliku: {uploader_email}")
        
        # 2. POBIERANIE ZAWARTOŚCI PLIKU (MEDIA)
        drive_request = service.files().get_media(
            fileId=request.file_id,
            supportsAllDrives=True
        )
        
        file_stream = io.BytesIO()
        downloader = MediaIoBaseDownload(file_stream, drive_request)
        
        done = False
        while not done:
            status, done = downloader.next_chunk()
            if status:
                print(f"Pobrano: {int(status.progress() * 100)}%")

        # 3. PRZETWARZANIE PDF
        file_stream.seek(0)
        pdf_document = fitz.open(stream=file_stream, filetype="pdf")
        total_pages = len(pdf_document)
        results = []
        source_base_name = sanitize_pdf_basename(file_meta.get("name"))
        target_folder = create_drive_folder(service, request.folder_id, source_base_name)

        for i in range(total_pages):
            page = pdf_document[i]
            rect = page.rect
            
            # Konwersja pt na mm (1 pt = 0.3527 mm)
            w_mm = round(rect.width * 0.3527, 2)
            h_mm = round(rect.height * 0.3527, 2)

            # Tworzenie PDF z pojedynczą stroną
            new_pdf = fitz.open()
            new_pdf.insert_pdf(pdf_document, from_page=i, to_page=i)
            
            output_stream = io.BytesIO()
            new_pdf.save(output_stream)
            output_stream.seek(0)
            
            # 4. WGRYWANIE STRONY NA DYSK
            new_file_metadata = {
                'name': f'{source_base_name}_({i + 1}).pdf',
                'parents': [target_folder["id"]]
            }
            
            media = MediaIoBaseUpload(
                output_stream, 
                mimetype='application/pdf', 
                resumable=True
            )
            
            uploaded_file = service.files().create(
                body=new_file_metadata,
                media_body=media,
                fields='id, webViewLink',
                supportsAllDrives=True
            ).execute()
            
            # Zbieramy dane dla n8n
            results.append({
                "page": i + 1,
                "file_id": uploaded_file.get('id'),
                "link": uploaded_file.get('webViewLink'),
                "fileName": new_file_metadata["name"],
                "target_folder_id": target_folder["id"],
                "target_folder_name": target_folder["name"],
                "target_folder_link": target_folder.get("webViewLink"),
                "width_mm": w_mm,
                "height_mm": h_mm,
                "uploader_email": uploader_email
            })
            
            new_pdf.close()
            print(f"Zakończono stronę {i+1}/{total_pages}")

        pdf_document.close()
        return {
            "source_file_name": file_meta.get("name"),
            "target_folder_id": target_folder["id"],
            "target_folder_name": target_folder["name"],
            "target_folder_link": target_folder.get("webViewLink"),
            "pages": results,
            "dimensions_table_html": build_dimensions_table_html(
                results,
                target_folder.get("webViewLink"),
            ),
        }

    except Exception as e:
        print(f"BŁĄD KRYTYCZNY: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))

@app.post("/inspect-drive-folder")
async def inspect_drive_folder(request: DriveFolderInspectRequest):
    try:
        return inspect_drive_folder_sync(request.folder_link)

    except HTTPException:
        raise
    except Exception as e:
        print(f"BLAD INSPEKCJI FOLDERU: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/inspect-drive-folder/jobs", response_model=InspectJobCreateResponse, status_code=202)
async def create_inspect_drive_folder_job(request: DriveFolderInspectRequest, background_tasks: BackgroundTasks):
    job_data = create_job(request.folder_link)
    background_tasks.add_task(run_inspection_job, job_data["job_id"])

    return {
        "job_id": job_data["job_id"],
        "status": job_data["status"],
        "status_url": f"/inspect-drive-folder/jobs/{job_data['job_id']}",
        "result_url": f"/inspect-drive-folder/jobs/{job_data['job_id']}/result",
    }


@app.get("/inspect-drive-folder/jobs")
async def get_inspect_drive_folder_jobs():
    jobs = list_jobs()

    return {
        "count": len(jobs),
        "jobs": [
            {
                "job_id": job["job_id"],
                "status": job["status"],
                "cancel_requested": job["cancel_requested"],
                "folder_link": job["folder_link"],
                "folder_id": job["folder_id"],
                "folder_name": job["folder_name"],
                "total_files": job["total_files"],
                "processed_files": job["processed_files"],
                "progress_pct": job["progress_pct"],
                "error": job["error"],
                "created_at": job["created_at"],
                "started_at": job["started_at"],
                "cancelled_at": job["cancelled_at"],
                "finished_at": job["finished_at"],
                "updated_at": job["updated_at"],
                "status_url": f"/inspect-drive-folder/jobs/{job['job_id']}",
                "result_url": f"/inspect-drive-folder/jobs/{job['job_id']}/result",
            }
            for job in jobs
        ],
    }


@app.get("/inspect-drive-folder/jobs/{job_id}")
async def get_inspect_drive_folder_job_status(job_id: str):
    job_data = read_job(job_id)
    return {
        "job_id": job_data["job_id"],
        "status": job_data["status"],
        "cancel_requested": job_data["cancel_requested"],
        "folder_link": job_data["folder_link"],
        "folder_id": job_data["folder_id"],
        "folder_name": job_data["folder_name"],
        "total_files": job_data["total_files"],
        "processed_files": job_data["processed_files"],
        "progress_pct": job_data["progress_pct"],
        "error": job_data["error"],
        "created_at": job_data["created_at"],
        "started_at": job_data["started_at"],
        "cancelled_at": job_data["cancelled_at"],
        "finished_at": job_data["finished_at"],
        "updated_at": job_data["updated_at"],
    }


@app.post("/inspect-drive-folder/jobs/{job_id}/cancel")
async def cancel_inspect_drive_folder_job(job_id: str):
    job_data = read_job(job_id)

    if job_data["status"] in ["completed", "failed", "cancelled"]:
        return {
            "job_id": job_data["job_id"],
            "status": job_data["status"],
            "cancel_requested": job_data["cancel_requested"],
            "message": "Job jest juz zakonczony i nie moze zostac anulowany.",
        }

    print(f"[JOB {job_id}] cancellation requested")
    job_data = update_job(job_id, cancel_requested=True)

    return {
        "job_id": job_data["job_id"],
        "status": job_data["status"],
        "cancel_requested": job_data["cancel_requested"],
        "message": "Zlecono anulowanie joba. Worker zatrzyma go przy najblizszym punkcie kontroli.",
    }


@app.get("/inspect-drive-folder/jobs/{job_id}/result")
async def get_inspect_drive_folder_job_result(job_id: str):
    job_data = read_job(job_id)

    if job_data["status"] == "failed":
        raise HTTPException(status_code=500, detail=job_data["error"] or "Job zakonczyl sie bledem.")

    if job_data["status"] == "cancelled":
        return {
            "job_id": job_data["job_id"],
            "status": job_data["status"],
            "cancel_requested": job_data["cancel_requested"],
            "cancelled_at": job_data["cancelled_at"],
            "result": job_data["result"],
        }

    if job_data["status"] != "completed":
        raise HTTPException(status_code=409, detail="Job nie jest jeszcze zakonczony.")

    return job_data["result"]


if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=5555)