app.py

"""
MarketVision — Flask-приложение для генерации карточек маркетплейса.
Фото → Vision (ProxyAPI) → GigaChat (текст) → GPT-Image (ProxyAPI).
"""

import os
import threading
import time
import uuid
from pathlib import Path

from dotenv import load_dotenv
from flask import Flask, jsonify, render_template, request, send_from_directory, send_file
from werkzeug.utils import secure_filename

from core.config import (
    MARKETPLACES,
    OUTPUTS_DIR,
    TONES,
    VISUAL_STYLES,
    new_task_dir,
    refresh_env,
    telegram_configured,
)
from core.pipeline import run_marketvision_pipeline
from core.telegram_send import send_card_json, send_result_to_telegram

load_dotenv()
refresh_env()

app = Flask(__name__)
app.config["SECRET_KEY"] = os.getenv("FLASK_SECRET_KEY", os.urandom(24).hex())
app.config["MAX_CONTENT_LENGTH"] = 8 * 1024 * 1024  # 8 MB

ALLOWED_EXTENSIONS = {".jpg", ".jpeg", ".png", ".webp"}

tasks_status: dict[str, dict] = {}
tasks_lock = threading.Lock()


def allowed_file(filename: str) -> bool:
    return Path(filename).suffix.lower() in ALLOWED_EXTENSIONS


def update_task(task_id: str, **fields) -> None:
    with tasks_lock:
        tasks_status.setdefault(task_id, {})
        tasks_status[task_id].update(fields)


def process_task(
    task_id: str,
    image_path: Path,
    category: str,
    tone: str,
    marketplace: str,
    visual_style: str,
    extra_notes: str,
) -> None:
    try:
        refresh_env()
        update_task(
            task_id,
            status="processing",
            progress=5,
            message="Старт пайплайна…",
        )

        def on_progress(percent: int, message: str) -> None:
            update_task(
                task_id,
                status="processing",
                progress=percent,
                message=message,
            )

        result = run_marketvision_pipeline(
            task_id=task_id,
            image_path=image_path,
            category=category,
            tone=tone,
            marketplace=marketplace,
            visual_style=visual_style,
            extra_notes=extra_notes,
            on_progress=on_progress,
        )

        update_task(
            task_id,
            status="completed",
            progress=100,
            message="Готово!",
            result=result,
        )
    except Exception as exc:
        update_task(
            task_id,
            status="error",
            progress=0,
            message=str(exc),
        )


@app.route("/")
def index():
    refresh_env()
    return render_template(
        "index.html",
        visual_styles=VISUAL_STYLES,
        marketplaces=MARKETPLACES,
        tones=TONES,
        telegram_enabled=telegram_configured(),
    )


@app.route("/api/generate", methods=["POST"])
def api_generate():
    if "image" not in request.files:
        return jsonify({"error": "Загрузите фото товара"}), 400

    file = request.files["image"]
    if not file.filename:
        return jsonify({"error": "Файл не выбран"}), 400
    if not allowed_file(file.filename):
        return jsonify({"error": "Допустимы JPG, PNG, WEBP"}), 400

    category = request.form.get("category", "").strip()
    tone = request.form.get("tone", "business")
    marketplace = request.form.get("marketplace", "universal")
    visual_style = request.form.get("visual_style", "lifestyle")
    extra_notes = request.form.get("extra_notes", "").strip()

    task_id = f"{int(time.time() * 1000)}_{uuid.uuid4().hex[:8]}"
    task_dir = new_task_dir(task_id)

    ext = Path(secure_filename(file.filename)).suffix.lower() or ".jpg"
    input_path = task_dir / f"input{ext}"
    file.save(input_path)

    update_task(
        task_id,
        status="queued",
        progress=0,
        message="Задача в очереди…",
    )

    thread = threading.Thread(
        target=process_task,
        args=(
            task_id,
            input_path,
            category,
            tone,
            marketplace,
            visual_style,
            extra_notes,
        ),
        daemon=True,
    )
    thread.start()

    return jsonify({"task_id": task_id})


@app.route("/api/status/<task_id>")
def api_status(task_id: str):
    with tasks_lock:
        task = tasks_status.get(task_id)
    if not task:
        return jsonify({"error": "Задача не найдена"}), 404
    return jsonify(task)


@app.route("/api/telegram/<task_id>", methods=["POST"])
def api_telegram(task_id: str):
    with tasks_lock:
        task = tasks_status.get(task_id)

    if not task or task.get("status") != "completed":
        return jsonify({"error": "Сначала дождитесь завершения генерации"}), 400

    if not telegram_configured():
        return jsonify(
            {
                "error": "Добавьте TELEGRAM_BOT_TOKEN и TELEGRAM_CHAT_ID в .env",
            }
        ), 400

    task_dir = OUTPUTS_DIR / task_id
    card = task.get("result", {}).get("card", {})
    if not card and (task_dir / "card.json").exists():
        import json

        card = json.loads((task_dir / "card.json").read_text(encoding="utf-8"))

    try:
        tg_response = send_result_to_telegram(task_dir, card)
        send_card_json(task_dir)
        return jsonify({"ok": True, "telegram": tg_response})
    except Exception as exc:
        return jsonify({"error": str(exc)}), 500


@app.route("/outputs/<task_id>/<path:filename>")
def serve_output(task_id: str, filename: str):
    directory = OUTPUTS_DIR / task_id
    if not directory.exists():
        return jsonify({"error": "Не найдено"}), 404
    return send_from_directory(directory, filename)


@app.route("/api/download/<task_id>/card")
def download_card(task_id: str):
    path = OUTPUTS_DIR / task_id / "card.md"
    if not path.is_file():
        return jsonify({"error": "card.md не найден"}), 404
    return send_file(
        path,
        as_attachment=True,
        download_name=f"marketvision_{task_id}_card.md",
        mimetype="text/markdown; charset=utf-8",
    )


@app.route("/api/download/<task_id>/image")
def download_image(task_id: str):
    path = OUTPUTS_DIR / task_id / "generated.png"
    if not path.is_file():
        return jsonify({"error": "Изображение не найдено"}), 404
    return send_file(
        path,
        as_attachment=True,
        download_name=f"marketvision_{task_id}_visual.png",
        mimetype="image/png",
    )


if __name__ == "__main__":
    port = int(os.getenv("FLASK_PORT", "5000"))
    app.run(debug=True, host="0.0.0.0", port=port)