from pathlib import Path
from datetime import datetime
from uuid import uuid4
import json

from flask import Flask, send_from_directory, request, jsonify
from flask_cors import CORS
from PIL import Image
import ollama

BASE_DIR = Path(__file__).resolve().parent
PICTURES_DIR = BASE_DIR / "pictures"
OBJECTS_DIR = BASE_DIR / "objects_image"
SENTENCE_DIR = BASE_DIR / "sentence_object"
PROMPTS_DIR = BASE_DIR / "prompts"

app = Flask(
    __name__,
    template_folder=str(BASE_DIR / "templates"),
    static_folder=str(BASE_DIR / "static"),
)
CORS(app)


def read_prompt(filepath: Path, fallback: str) -> str:
    """
    Hilfsfunktion, um Prompt-Dateien zu lesen.
    """
    try:
        if filepath.exists():
            return filepath.read_text(encoding="utf-8").strip()
    except Exception:
        pass
    return fallback.strip()


@app.route("/api/images", methods=["GET"])
def list_images():
    """
    Gibt alle Bilder im pictures-Ordner zurück.
    Query-Parameter: ?mode=draw (Standard) oder ?mode=generate
    draw     → Bilder ohne _saved-Suffix
    generate → Bilder mit _saved-Suffix
    """
    mode = request.args.get("mode", "draw")
    PICTURES_DIR.mkdir(parents=True, exist_ok=True)
    if mode == "generate":
        image_paths = sorted(
            [f for f in PICTURES_DIR.iterdir() if f.is_file() and f.stem.endswith("_saved")],
            key=lambda p: p.stat().st_mtime,
        )
    else:
        image_paths = sorted(
            [f for f in PICTURES_DIR.iterdir() if f.is_file() and not f.stem.endswith("_saved")],
            key=lambda p: p.stat().st_mtime,
        )
    return jsonify({"images": [p.name for p in image_paths]})


REACT_BUILD_DIR = BASE_DIR / "static" / "react"


def _serve_spa():
    """Liefert die React SPA index.html für alle Frontend-Routen."""
    return send_from_directory(REACT_BUILD_DIR, "index.html")


@app.route("/")
@app.route("/draw")
@app.route("/generate")
def serve_spa():
    return _serve_spa()


@app.route("/assets/<path:filename>")
def serve_react_assets(filename: str):
    """Liefert JS/CSS-Assets aus dem Vite-Build."""
    return send_from_directory(REACT_BUILD_DIR / "assets", filename)


@app.route("/pictures/<path:filename>")
def serve_picture(filename: str):
    # Statisches Ausliefern der Originalbilder
    return send_from_directory(PICTURES_DIR, filename)


@app.route("/objects_image/<path:filename>")
def serve_object_image(filename: str):
    # Ausliefern der gespeicherten Ausschnitt-Bilder
    return send_from_directory(OBJECTS_DIR, filename)


@app.route("/api/objects", methods=["GET"])
def list_objects_for_image():
    """
    Gibt alle gespeicherten Objekte (Ausschnitte) zu einem Quellbild zurück.

    Query-Parameter:
      ?filename=testbild.png
    """
    filename = request.args.get("filename")
    if not filename:
        return jsonify({"error": "Missing filename query parameter"}), 400

    # Für *_saved-Bilder auch Objekte berücksichtigen, deren source_filename
    # noch auf den ursprünglichen Namen ohne "_saved" zeigt (Kompatibilität)
    base_filename = filename
    legacy_filename = None
    if base_filename.endswith(".png") or base_filename.endswith(".jpg") or base_filename.endswith(".jpeg") or base_filename.endswith(".webp"):
        stem = base_filename.rsplit(".", 1)[0]
        suffix = base_filename.rsplit(".", 1)[1]
        if stem.endswith("_saved"):
            legacy_filename = f"{stem[:-6]}.{suffix}"

    OBJECTS_DIR.mkdir(parents=True, exist_ok=True)
    objects = []
    for meta_file in OBJECTS_DIR.glob("*.txt"):
        try:
            meta = json.loads(meta_file.read_text(encoding="utf-8"))
        except Exception:
            continue

        src_name = meta.get("source_filename")
        if src_name != filename and (legacy_filename is None or src_name != legacy_filename):
            continue

        objects.append(
            {
                "id": meta.get("id"),
                "image_file": meta.get("image_file"),
                "title_de": meta.get("title_de", ""),
                "position_de": meta.get("position_de", ""),
                "action_de": meta.get("action_de", ""),
                "condition_de": meta.get("condition_de", ""),
                # Von KI erzeugte Details (optional)
                "label_en": meta.get("label_en"),
                "label_de": meta.get("label_de"),
                "label_se": meta.get("label_se"),
                "color_en": meta.get("color_en"),
                "adjective_en": meta.get("adjective_en"),
                "action_verb_en": meta.get("action_verb_en"),
                "preposition_en": meta.get("preposition_en"),
                "relative_position_en": meta.get("relative_position_en"),
                "season_en": meta.get("season_en"),
                "mode": meta.get("mode"),
                "bbox": meta.get("bbox"),
                "polygon": meta.get("polygon"),
                "hierarchy": meta.get("hierarchy", 1),
                "parent_id": meta.get("parent_id"),
                "created_at": meta.get("created_at"),
            }
        )

    # Älteste zuerst sortieren (1 = ältestes Objekt)
    objects.sort(key=lambda o: o.get("created_at") or "")

    # Laufende Nummer je Bild (1..n) nach obiger Sortierung
    for idx, obj in enumerate(objects, start=1):
        obj["index"] = idx

    return jsonify({"objects": objects})


@app.route("/api/object/<obj_id>/hierarchy", methods=["POST"])
def update_object_hierarchy(obj_id: str):
    """
    Aktualisiert die Hierarchie (1, 2 oder 3) eines gespeicherten Objekts.
    """
    data = request.get_json(force=True, silent=True) or {}
    try:
        hierarchy = int(data.get("hierarchy"))
    except (TypeError, ValueError):
        return jsonify({"error": "Invalid hierarchy"}), 400

    if hierarchy not in (1, 2, 3):
        return jsonify({"error": "Hierarchy must be 1, 2 or 3"}), 400

    meta_path = OBJECTS_DIR / f"{obj_id}.txt"
    if not meta_path.exists():
        return jsonify({"error": "Object not found"}), 404

    try:
        meta = json.loads(meta_path.read_text(encoding="utf-8"))
    except Exception:
        return jsonify({"error": "Could not read meta file"}), 500

    meta["hierarchy"] = hierarchy
    meta_path.write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")

    return jsonify({"id": obj_id, "hierarchy": hierarchy})


@app.route("/api/object/<obj_id>", methods=["POST"])
def update_object_meta(obj_id: str):
    """
    Aktualisiert Text-Metadaten (title_de, position_de, action_de, condition_de)
    eines gespeicherten Objekts.
    """
    data = request.get_json(force=True, silent=True) or {}

    meta_path = OBJECTS_DIR / f"{obj_id}.txt"
    if not meta_path.exists():
        return jsonify({"error": "Object not found"}), 404

    try:
        meta = json.loads(meta_path.read_text(encoding="utf-8"))
    except Exception:
        return jsonify({"error": "Could not read meta file"}), 500

    for key in ("title_de", "position_de", "action_de", "condition_de"):
        if key in data:
            meta[key] = data.get(key, "")

    meta_path.write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")

    return jsonify({k: meta.get(k) for k in ("id", "title_de", "position_de", "action_de", "condition_de")})


@app.route("/api/object/<obj_id>/parent", methods=["POST"])
def update_object_parent(obj_id: str):
    """
    Aktualisiert die Parent-Relation eines Objekts.
    Erwartet JSON: { "parent_id": "<uuid>" | null }
    """
    data = request.get_json(force=True, silent=True) or {}
    parent_id = data.get("parent_id")

    meta_path = OBJECTS_DIR / f"{obj_id}.txt"
    if not meta_path.exists():
        return jsonify({"error": "Object not found"}), 404

    try:
        meta = json.loads(meta_path.read_text(encoding="utf-8"))
    except Exception:
        return jsonify({"error": "Could not read meta file"}), 500

    # Optional: prüfen, ob parent_id existiert und zum selben Bild gehört
    if parent_id:
        parent_meta_path = OBJECTS_DIR / f"{parent_id}.txt"
        if not parent_meta_path.exists():
            return jsonify({"error": "Parent object not found"}), 400
        try:
            parent_meta = json.loads(parent_meta_path.read_text(encoding="utf-8"))
        except Exception:
            return jsonify({"error": "Could not read parent meta file"}), 500

        if parent_meta.get("source_filename") != meta.get("source_filename"):
            return jsonify({"error": "Parent must belong to same source image"}), 400

    meta["parent_id"] = parent_id or None
    meta_path.write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")

    return jsonify({"id": obj_id, "parent_id": meta.get("parent_id")})


@app.route("/api/object/<obj_id>/generate_details", methods=["POST"])
def generate_object_details(obj_id: str):
    """
    Erzeugt mit Llama 3.2 Vision zusätzliche englische Metadaten zu einem Objekt
    auf Basis des ausgeschnittenen Objektbildes + vorhandener deutscher Felder.
    """
    meta_path = OBJECTS_DIR / f"{obj_id}.txt"
    if not meta_path.exists():
        return jsonify({"error": "Object not found"}), 404

    try:
        meta = json.loads(meta_path.read_text(encoding="utf-8"))
    except Exception:
        return jsonify({"error": "Could not read meta file"}), 500

    image_file = meta.get("image_file")
    if not image_file:
        return jsonify({"error": "Object has no image_file"}), 400

    image_path = OBJECTS_DIR / image_file
    if not image_path.exists():
        return jsonify({"error": "Object image not found"}), 404

    # Prompt laden
    prompt_template = read_prompt(
        PROMPTS_DIR / "create_details.txt",
        "Analyze this object and return one JSON object with the requested fields.",
    )

    title_de = meta.get("title_de", "") or ""
    action_de = meta.get("action_de", "") or ""
    condition_de = meta.get("condition_de", "") or ""

    # Platzhalter im Prompt ersetzen (einfache .format-Verwendung)
    try:
        prompt = prompt_template.format(
            title_de=title_de,
            action_de=action_de,
            condition_de=condition_de,
        )
    except Exception:
        # Falls das Format fehlschlägt, einfach Rohprompt + Kontext anhängen
        prompt = (
            f"{prompt_template}\n\n"
            f"Titel (Deutsch): {title_de}\n"
            f"Status (Deutsch): {action_de}\n"
            f"Zustand (Deutsch): {condition_de}\n"
        )

    # Bild als Bytes laden
    try:
        img_bytes = image_path.read_bytes()
    except Exception:
        return jsonify({"error": "Could not read object image"}), 500

    try:
        response = ollama.chat(
            model="llama3.2-vision",
            messages=[{"role": "user", "content": prompt, "images": [img_bytes]}],
            format="json",
            options={"temperature": 0},
        )
    except Exception as e:
        return jsonify({"error": f"LLM request failed: {e}"}), 500

    content = response.get("message", {}).get("content")
    if not content:
        return jsonify({"error": "Empty response from LLM"}), 500

    try:
        ai_data = json.loads(content)
    except Exception:
        # Fallback: versuchen, das erste JSON-Objekt zu extrahieren
        try:
            start = content.index("{")
            end = content.rindex("}") + 1
            ai_data = json.loads(content[start:end])
        except Exception:
            return jsonify({"error": "Could not parse JSON from LLM response"}), 500

    # Debug-Ausgabe des rohen AI-Outputs
    try:
        print(f"[generate_details] Raw AI data for {obj_id}: {json.dumps(ai_data, ensure_ascii=False)}")
    except Exception:
        print(f"[generate_details] Raw AI data for {obj_id} (non-serializable): {ai_data!r}")

    # Erwartete Felder übernehmen (gemäß neuem Prompt)
    fields = [
        "label_en",
        "label_de",
        "label_se",
        "color_en",
        "adjective_en",
        "action_verb_en",
        "preposition_en",
        "relative_position_en",
        "season_en",
    ]
    for key in fields:
        if key in ai_data:
            meta[key] = ai_data.get(key)

    # Metadatei zurückschreiben
    meta_path.write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")

    # Nur die neuen Felder zurückgeben (None als leeren String konvertieren)
    result = {key: (meta.get(key) or "") for key in fields}

    try:
        print(f"[generate_details] Stored meta for {obj_id}: {json.dumps(result, ensure_ascii=False)}")
    except Exception:
        print(f"[generate_details] Stored meta for {obj_id}: {result!r}")

    return jsonify(result)


def load_sentences_for_object(obj_id: str):
    """
    Lädt alle gespeicherten Sätze für ein Objekt aus sentence_object/<obj_id>.txt.
    Rückgabe: Liste von Dicts mit mindestens question_en, answer_en, created_at.
    """
    SENTENCE_DIR.mkdir(parents=True, exist_ok=True)
    sentence_path = SENTENCE_DIR / f"{obj_id}.txt"
    if not sentence_path.exists():
        return []
    try:
        data = json.loads(sentence_path.read_text(encoding="utf-8"))
        if isinstance(data, list):
            return data
        if isinstance(data, dict):
            # Fallback: einzelnes Objekt in Liste wrappen
            return [data]
        return []
    except Exception:
        return []


@app.route("/api/object/<obj_id>/sentences", methods=["GET"])
def get_object_sentences(obj_id: str):
    """
    Gibt alle bisher erzeugten KI-Sätze zu einem Objekt zurück.
    """
    sentences = load_sentences_for_object(obj_id)
    return jsonify({"object_id": obj_id, "sentences": sentences})


@app.route("/api/object/<obj_id>/generate_sentence", methods=["POST"])
def generate_object_sentence(obj_id: str):
    """
    Erzeugt mit Llama 3.1 einen neuen englischen Frage-Antwort-Satz
    zu einem Objekt basierend auf den KI-Details und bisherigen Sätzen.
    Speichert alle Sätze in sentence_object/<obj_id>.txt.
    """
    # Objekt-Metadaten laden (inkl. KI-Details)
    meta_path = OBJECTS_DIR / f"{obj_id}.txt"
    if not meta_path.exists():
        return jsonify({"error": "Object not found"}), 404

    try:
        meta = json.loads(meta_path.read_text(encoding="utf-8"))
    except Exception:
        return jsonify({"error": "Could not read meta file"}), 500

    # Relevante Felder für den Satz (KI-Details)
    details = {
        "label_en": meta.get("label_en"),
        "label_de": meta.get("label_de"),
        "label_se": meta.get("label_se"),
        "color_en": meta.get("color_en"),
        "adjective_en": meta.get("adjective_en"),
        "action_verb_en": meta.get("action_verb_en"),
        "preposition_en": meta.get("preposition_en"),
        "relative_position_en": meta.get("relative_position_en"),
        "season_en": meta.get("season_en"),
        "title_de": meta.get("title_de"),
        "position_de": meta.get("position_de"),
        "action_de": meta.get("action_de"),
        "condition_de": meta.get("condition_de"),
    }

    # Bisherige Sätze laden
    previous_sentences = load_sentences_for_object(obj_id)

    # Prompt laden
    prompt_template = read_prompt(
        PROMPTS_DIR / "create_sentence.txt",
        "Create one new English question_en and answer_en as JSON, based on the object details and avoiding previous sentences.",
    )

    # Vollständigen Prompt zusammensetzen
    try:
        details_json = json.dumps(details, ensure_ascii=False, indent=2)
        prev_json = json.dumps(previous_sentences, ensure_ascii=False, indent=2)
    except Exception:
        details_json = str(details)
        prev_json = str(previous_sentences)

    prompt = (
        f"{prompt_template}\n\n"
        f"OBJECT_DETAILS_JSON:\n{details_json}\n\n"
        f"PREVIOUS_SENTENCES_JSON:\n{prev_json}\n"
    )

    # LLM-Aufruf (nur Text, kein Bild nötig)
    try:
        response = ollama.chat(
            model="llama3.1",
            messages=[{"role": "user", "content": prompt}],
            format="json",
            options={"temperature": 0.2},
        )
    except Exception as e:
        return jsonify({"error": f"LLM request failed: {e}"}), 500

    content = response.get("message", {}).get("content")
    if not content:
        return jsonify({"error": "Empty response from LLM"}), 500

    try:
        ai_data = json.loads(content)
    except Exception:
        # Fallback: erstes JSON-Objekt extrahieren
        try:
            start = content.index("{")
            end = content.rindex("}") + 1
            ai_data = json.loads(content[start:end])
        except Exception:
            return jsonify({"error": "Could not parse JSON from LLM response"}), 500

    question_simple = (ai_data.get("question_simple_en") or "").strip()
    answer_simple = (ai_data.get("answer_simple_en") or "").strip()
    question_advanced = (ai_data.get("question_advanced_en") or "").strip()
    answer_advanced = (ai_data.get("answer_advanced_en") or "").strip()
    
    if not question_simple or not answer_simple or not question_advanced or not answer_advanced:
        return jsonify({"error": "LLM response missing required fields (question_simple_en, answer_simple_en, question_advanced_en, answer_advanced_en)"}), 500

    # Neuen Satz mit Timestamp anreichern
    entry = {
        "object_id": obj_id,
        "created_at": datetime.now().isoformat(),
        "question_simple_en": question_simple,
        "answer_simple_en": answer_simple,
        "question_advanced_en": question_advanced,
        "answer_advanced_en": answer_advanced,
    }

    sentences = previous_sentences + [entry]

    # In Datei speichern
    SENTENCE_DIR.mkdir(parents=True, exist_ok=True)
    sentence_path = SENTENCE_DIR / f"{obj_id}.txt"
    sentence_path.write_text(json.dumps(sentences, ensure_ascii=False, indent=2), encoding="utf-8")

    return jsonify({"object_id": obj_id, "sentence": entry, "count": len(sentences)})


@app.route("/api/image/save", methods=["POST"])
def save_image():
    """
    Markiert ein Bild und alle zugehörigen Objekte als 'gespeichert',
    indem der Dateiname um '_saved' erweitert wird und die Metadaten
    der Objekte angepasst werden.
    """
    data = request.get_json(force=True, silent=True) or {}
    filename = data.get("filename")
    if not filename:
        return jsonify({"error": "Missing filename"}), 400

    src_path = PICTURES_DIR / filename
    if not src_path.exists():
        return jsonify({"error": "Image not found"}), 404

    if src_path.stem.endswith("_saved"):
        return jsonify({"error": "Image already saved"}), 400

    new_name = f"{src_path.stem}_saved{src_path.suffix}"
    dst_path = PICTURES_DIR / new_name

    # Bild umbenennen
    src_path.rename(dst_path)

    # Zugehörige Objekte aktualisieren
    OBJECTS_DIR.mkdir(parents=True, exist_ok=True)
    for meta_file in OBJECTS_DIR.glob("*.txt"):
        try:
            meta = json.loads(meta_file.read_text(encoding="utf-8"))
        except Exception:
            continue

        if meta.get("source_filename") != filename:
            continue

        meta["source_filename"] = new_name
        meta_file.write_text(
            json.dumps(meta, ensure_ascii=False, indent=2),
            encoding="utf-8",
        )

    return jsonify({"old_name": filename, "new_name": new_name})


@app.route("/api/crop", methods=["POST"])
def crop_image():
    """
    Erwartet JSON:
    {
      "filename": "bild.jpg",
      "selections": [
        {
          "number": 1,
          "mode": "rect" | "polygon",
          "bbox": {"x": 10, "y": 20, "width": 200, "height": 150},  // für rect
          "polygon": [{"x": 10, "y": 20}, ...]  // für polygon
        },
        ...
      ],
      "title_de": "...",
      "position_de": "...",
      "action_de": "...",
      "condition_de": "..."
    }
    
    ODER (Legacy-Format für Kompatibilität):
    {
      "filename": "bild.jpg",
      "mode": "rect" | "polygon",
      "x": 10, "y": 20, "width": 200, "height": 150,  // für rect
      "polygon": [{"x": 10, "y": 20}, ...]  // für polygon
    }
    """
    data = request.get_json(force=True, silent=True) or {}

    if "filename" not in data:
        return jsonify({"error": "Missing filename"}), 400

    src_path = PICTURES_DIR / data["filename"]
    if src_path.stem.endswith("_saved"):
        return jsonify({"error": "Cannot crop on saved image"}), 400
    if not src_path.exists():
        return jsonify({"error": "Source image not found"}), 404

    OBJECTS_DIR.mkdir(parents=True, exist_ok=True)

    # UUID für Bild + Metadaten
    obj_id = uuid4().hex
    timestamp = datetime.now().isoformat()
    out_image_name = f"{obj_id}{src_path.suffix}"
    out_image_path = OBJECTS_DIR / out_image_name
    out_meta_path = OBJECTS_DIR / f"{obj_id}.txt"

    # Prüfen, ob neues Format (selections) oder Legacy-Format
    selections = data.get("selections")
    
    if selections and isinstance(selections, list) and len(selections) > 0:
        # Neues Format: mehrere Auswahlen
        processed_selections = []
        
        with Image.open(src_path) as img:
            img_w, img_h = img.size
            
            for sel in selections:
                sel_mode = sel.get("mode")
                if sel_mode == "rect":
                    bbox = sel.get("bbox")
                    if not bbox:
                        continue
                    try:
                        x = int(bbox.get("x", 0))
                        y = int(bbox.get("y", 0))
                        w = int(bbox.get("width", 0))
                        h = int(bbox.get("height", 0))
                    except (ValueError, TypeError):
                        continue
                    
                    if w <= 0 or h <= 0:
                        continue
                    
                    x2 = min(x + w, img_w)
                    y2 = min(y + h, img_h)
                    x1 = max(0, x)
                    y1 = max(0, y)
                    
                    if x1 >= x2 or y1 >= y2:
                        continue
                    
                    processed_selections.append({
                        "number": sel.get("number", len(processed_selections) + 1),
                        "mode": "rect",
                        "bbox": {"x": x1, "y": y1, "width": x2 - x1, "height": y2 - y1},
                    })
                    
                elif sel_mode == "polygon":
                    polygon = sel.get("polygon")
                    if not isinstance(polygon, list) or len(polygon) < 3:
                        continue
                    
                    try:
                        xs = [int(p.get("x", 0)) for p in polygon]
                        ys = [int(p.get("y", 0)) for p in polygon]
                    except (KeyError, TypeError, ValueError):
                        continue
                    
                    min_x = max(min(xs), 0)
                    min_y = max(min(ys), 0)
                    max_x = min(max(xs), img_w)
                    max_y = min(max(ys), img_h)
                    
                    if min_x >= max_x or min_y >= max_y:
                        continue
                    
                    processed_selections.append({
                        "number": sel.get("number", len(processed_selections) + 1),
                        "mode": "polygon",
                        "polygon": polygon,
                        "bbox": {"x": min_x, "y": min_y, "width": max_x - min_x, "height": max_y - min_y},
                    })
        
        if not processed_selections:
            return jsonify({"error": "No valid selections provided"}), 400
        
        # Erstes Bild aus erster Auswahl erstellen
        first_sel = processed_selections[0]
        try:
            with Image.open(src_path) as img:
                if first_sel["mode"] == "rect":
                    bbox = first_sel["bbox"]
                    x1 = bbox["x"]
                    y1 = bbox["y"]
                    x2 = x1 + bbox["width"]
                    y2 = y1 + bbox["height"]
                    cropped = img.crop((x1, y1, x2, y2))
                else:  # polygon - verwende Bounding-Box für das Bild
                    bbox = first_sel["bbox"]
                    x1 = bbox["x"]
                    y1 = bbox["y"]
                    x2 = x1 + bbox["width"]
                    y2 = y1 + bbox["height"]
                    cropped = img.crop((x1, y1, x2, y2))
                
                # Bild speichern (Format beibehalten)
                img_format = img.format or "PNG"
                cropped.save(out_image_path, format=img_format)
                print(f"[crop_image] Bild gespeichert: {out_image_path} (Größe: {cropped.size}, Format: {img_format})")
        except Exception as e:
            print(f"[crop_image] Fehler beim Erstellen des Bildes: {e}")
            return jsonify({"error": f"Failed to create image: {e}"}), 500
        
        # Metadaten mit allen Auswahlen speichern
        meta = {
            "id": obj_id,
            "created_at": timestamp,
            "source_filename": data["filename"],
            "mode": processed_selections[0]["mode"],  # Legacy-Feld
            "bbox": processed_selections[0]["bbox"],  # Legacy-Feld
            "image_file": out_image_name,
            "hierarchy": 1,
            "parent_id": None,
            "title_de": data.get("title_de", ""),
            "position_de": data.get("position_de", ""),
            "action_de": data.get("action_de", ""),
            "condition_de": data.get("condition_de", ""),
            "selections": processed_selections,  # Neue Feld: alle Auswahlen nummeriert
        }
        if processed_selections[0]["mode"] == "polygon":
            meta["polygon"] = processed_selections[0]["polygon"]  # Legacy-Feld
        
    else:
        # Legacy-Format: einzelne Auswahl (für Rückwärtskompatibilität)
        mode = data.get("mode", "rect")
        if mode not in {"rect", "polygon"}:
            return jsonify({"error": "Invalid mode"}), 400

        with Image.open(src_path) as img:
            img_w, img_h = img.size
            if mode == "rect":
                try:
                    x = int(data["x"])
                    y = int(data["y"])
                    w = int(data["width"])
                    h = int(data["height"])
                except (ValueError, TypeError, KeyError):
                    return jsonify({"error": "Invalid rectangle coordinates"}), 400

                if w <= 0 or h <= 0:
                    return jsonify({"error": "Width and height must be positive"}), 400

                x2 = min(x + w, img_w)
                y2 = min(y + h, img_h)
                x1 = max(0, x)
                y1 = max(0, y)

                if x1 >= x2 or y1 >= y2:
                    return jsonify({"error": "Crop area outside of image"}), 400

                cropped = img.crop((x1, y1, x2, y2))
                bbox = {"x": x1, "y": y1, "width": x2 - x1, "height": y2 - y1}
            else:  # polygon
                polygon = data.get("polygon") or []
                if not isinstance(polygon, list) or len(polygon) < 3:
                    return jsonify({"error": "Polygon must have at least 3 points"}), 400

                try:
                    xs = [int(p["x"]) for p in polygon]
                    ys = [int(p["y"]) for p in polygon]
                except (KeyError, TypeError, ValueError):
                    return jsonify({"error": "Invalid polygon coordinates"}), 400

                min_x = max(min(xs), 0)
                min_y = max(min(ys), 0)
                max_x = min(max(xs), img_w)
                max_y = min(max(ys), img_h)

                if min_x >= max_x or min_y >= max_y:
                    return jsonify({"error": "Polygon bounding box outside of image"}), 400

                cropped = img.crop((min_x, min_y, max_x, max_y))
                bbox = {
                    "x": min_x,
                    "y": min_y,
                    "width": max_x - min_x,
                    "height": max_y - min_y,
                }

            cropped.save(out_image_path)

        # Metadaten als JSON in .txt speichern
        meta = {
            "id": obj_id,
            "created_at": timestamp,
            "source_filename": data["filename"],
            "mode": mode,
            "bbox": bbox,
            "image_file": out_image_name,
            "hierarchy": 1,
            "parent_id": None,
            "title_de": data.get("title_de", ""),
            "position_de": data.get("position_de", ""),
            "action_de": data.get("action_de", ""),
            "condition_de": data.get("condition_de", ""),
        }
        if mode == "polygon":
            meta["polygon"] = data.get("polygon")

    out_meta_path.write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")

    return jsonify(
        {
            "id": obj_id,
            "image_file": out_image_name,
            "meta_file": out_meta_path.name,
        }
    )


if __name__ == "__main__":
    # Du kannst den Port hier anpassen, z.B. 8000 oder 5000.
    # Für externen Zugriff später einfach in Nginx/Reverse Proxy weiterleiten.
    app.run(host="0.0.0.0", port=8000, debug=True)