app.py

import threading
import io
import json
import os
import shutil
import subprocess
import sys
from collections import Counter
from pathlib import Path

import spaces
import gradio as gr
import torch
from PIL import Image, ImageDraw
from transformers import RTDetrForObjectDetection, RTDetrImageProcessor

# Hugging Face Spaces can mount persistent storage at /data.
# DATA_DIR can be overridden in Space Settings -> Variables.
if os.getenv("DATA_DIR"):
    BASE = Path(os.environ["DATA_DIR"])
elif Path("/data").exists() and os.access("/data", os.W_OK):
    BASE = Path("/data") / "icecream_counter"
else:
    BASE = Path("./data")

ROOT = Path(__file__).resolve().parent

# Self-heal the training script if a deployment omitted the training/ directory.
_TRAINING_SCRIPT_B64 = "import argparse
import json
from pathlib import Path

import torch
from PIL import Image
from torch.utils.data import Dataset, DataLoader
from tqdm import tqdm
from transformers import RTDetrImageProcessor, RTDetrForObjectDetection

BASE_MODEL = "PekingU/rtdetr_r50vd"

def load_classes(path):
    return [x.strip() for x in Path(path).read_text().splitlines() if x.strip()]

class COCODetectionDataset(Dataset):
    def __init__(self, image_dir, annotation_file, processor):
        self.image_dir = Path(image_dir)
        self.processor = processor
        coco = json.loads(Path(annotation_file).read_text())
        self.images = {x["id"]: x for x in coco["images"]}
        cats = sorted(coco["categories"], key=lambda x: x["id"])
        self.category_id_to_label = {c["id"]: i for i,c in enumerate(cats)}
        anns = {}
        for a in coco["annotations"]:
            if not a.get("iscrowd", 0):
                anns.setdefault(a["image_id"], []).append(a)
        self.records = []
        for image_id, info in self.images.items():
            self.records.append({
                "image_id": image_id, "file_name": info["file_name"],
                "width": info["width"], "height": info["height"],
                "annotations": anns.get(image_id, [])
            })

    def __len__(self): return len(self.records)

    def __getitem__(self, idx):
        r = self.records[idx]
        image = Image.open(self.image_dir / r["file_name"]).convert("RGB")
        anns = []
        for a in r["annotations"]:
            x,y,w,h = a["bbox"]
            if w <= 0 or h <= 0: continue
            anns.append({
                "id": a["id"], "image_id": int(idx),
                "category_id": self.category_id_to_label[a["category_id"]],
                "bbox": [x,y,w,h], "area": float(a.get("area",w*h)),
                "iscrowd": 0
            })
        encoded = self.processor(
            images=image,
            annotations={"image_id": int(idx), "annotations": anns},
            return_tensors="pt"
        )
        encoded["pixel_values"] = encoded["pixel_values"].squeeze(0)
        if "pixel_mask" in encoded:
            encoded["pixel_mask"] = encoded["pixel_mask"].squeeze(0)
        encoded["labels"] = encoded["labels"][0]
        return encoded

def collate_fn(batch):
    out = {"pixel_values": torch.stack([x["pixel_values"] for x in batch]),
           "labels": [x["labels"] for x in batch]}
    if "pixel_mask" in batch[0]:
        out["pixel_mask"] = torch.stack([x["pixel_mask"] for x in batch])
    return out

def move_to_device(obj, device):
    if torch.is_tensor(obj):
        return obj.to(device)
    if isinstance(obj, dict):
        return {k: move_to_device(v, device) for k, v in obj.items()}
    if isinstance(obj, list):
        return [move_to_device(v, device) for v in obj]
    if isinstance(obj, tuple):
        return tuple(move_to_device(v, device) for v in obj)
    return obj

def evaluate(model, loader, device):
    model.eval(); total=0; n=0
    with torch.no_grad():
        for batch in loader:
            batch=move_to_device(batch, device)
            total += float(model(**batch).loss.item()); n += 1
    model.train()
    return total/max(n,1)


def patch_rtdetr_box_iou_device():
    """Make RT-DETR box IoU helpers device-safe across Transformers releases.

    Some Transformers RT-DETR loss implementations can construct target boxes
    on CPU even when predictions are on CUDA. The failure then occurs inside
    loss_labels_vfl -> box_iou. Align both operands to the prediction device
    immediately before the IoU calculation.
    """
    try:
        import importlib

        loss_for_box = importlib.import_module(
            "transformers.loss.loss_for_object_detection"
        )
        modules = [loss_for_box]

        try:
            loss_rt = importlib.import_module("transformers.loss.loss_rt_detr")
            modules.append(loss_rt)
        except ImportError:
            pass

        original = getattr(loss_for_box, "box_iou", None)
        if original is None:
            raise RuntimeError("transformers.loss.loss_for_object_detection.box_iou not found")

        if getattr(original, "_icecream_device_patch", False):
            print("RT-DETR box_iou device patch already installed")
            return

        def device_safe_box_iou(boxes1, boxes2):
            if torch.is_tensor(boxes1) and torch.is_tensor(boxes2):
                if boxes1.device != boxes2.device:
                    boxes2 = boxes2.to(boxes1.device)
            return original(boxes1, boxes2)

        device_safe_box_iou._icecream_device_patch = True

        # loss_rt_detr imports box_iou into its own module namespace in the
        # Transformers versions that produced this traceback, so patch both.
        loss_for_box.box_iou = device_safe_box_iou
        for module in modules[1:]:
            if hasattr(module, "box_iou"):
                module.box_iou = device_safe_box_iou

        print("RT-DETR box_iou device patch installed")
    except Exception as exc:
        raise RuntimeError(f"Could not install RT-DETR box_iou device patch: {exc}") from exc

def patch_rtdetr_device_consistency():
    """Make RT-DETR Hungarian matching device-safe across Transformers releases.

    In the Transformers version used by the app, RTDetrHungarianMatcher lives
    in transformers.loss.loss_rt_detr (not modeling_rt_detr). Its forward path
    can receive target boxes on CPU while model predictions are on CUDA. That
    breaks both torch.cdist() and generalized_box_iou(). Patch the matcher's
    forward method directly so every tensor in the targets is moved to the
    prediction device before the original matcher runs.
    """
    try:
        import importlib

        loss_mod = None
        for module_name in (
            "transformers.loss.loss_rt_detr",
            "transformers.models.rt_detr.loss.loss_rt_detr",
        ):
            try:
                loss_mod = importlib.import_module(module_name)
                if hasattr(loss_mod, "RTDetrHungarianMatcher"):
                    break
            except ImportError:
                continue

        if loss_mod is None or not hasattr(loss_mod, "RTDetrHungarianMatcher"):
            raise RuntimeError("RTDetrHungarianMatcher could not be located in the installed Transformers package")

        matcher_cls = loss_mod.RTDetrHungarianMatcher
        original_forward = matcher_cls.forward
        if getattr(original_forward, "_icecream_device_patch", False):
            print("RT-DETR device-consistency patch already installed")
            return

        def move_targets(targets, device):
            fixed = []
            for target in targets:
                if isinstance(target, dict):
                    target = dict(target)
                    for key, value in list(target.items()):
                        if torch.is_tensor(value):
                            target[key] = value.to(device)
                elif hasattr(target, "items"):
                    target = dict(target)
                    for key, value in list(target.items()):
                        if torch.is_tensor(value):
                            target[key] = value.to(device)
                fixed.append(target)
            return fixed

        def device_safe_forward(self, outputs, targets, *args, **kwargs):
            device = None
            # RT-DETR passes a ModelOutput object here, not necessarily a dict.
            # Support both forms so we always discover the prediction device.
            for key in ("pred_boxes", "pred_logits"):
                value = None
                if isinstance(outputs, dict):
                    value = outputs.get(key)
                else:
                    value = getattr(outputs, key, None)
                if torch.is_tensor(value):
                    device = value.device
                    break
            if device is not None:
                targets = move_targets(targets, device)
            return original_forward(self, outputs, targets, *args, **kwargs)

        device_safe_forward._icecream_device_patch = True
        matcher_cls.forward = device_safe_forward
        print("RT-DETR Hungarian matcher device patch installed")

    except Exception as exc:
        raise RuntimeError(f"Could not install RT-DETR device patch: {exc}") from exc

def patch_rtdetr_denoising_device():
    """Patch the RT-DETR denoising helper without assuming matcher internals."""
    try:
        import transformers.models.rt_detr.modeling_rt_detr as rtdetr_mod
        import torch.nn as nn

        original = getattr(rtdetr_mod, "get_contrastive_denoising_training_group", None)
        if original is None or getattr(original, "_icecream_device_patch", False):
            return

        class DeviceSafeEmbedding(nn.Module):
            def __init__(self, embedding):
                super().__init__()
                self.embedding = embedding

            def forward(self, indices):
                if torch.is_tensor(indices):
                    indices = indices.to(self.embedding.weight.device)
                return self.embedding(indices)

        def wrapped(targets, num_classes, num_queries, class_embed,
                    num_denoising_queries=100, label_noise_ratio=0.5,
                    box_noise_scale=1.0, **kwargs):
            try:
                embed_device = class_embed.weight.device
            except Exception:
                try:
                    embed_device = next(class_embed.parameters()).device
                except Exception:
                    embed_device = None

            if embed_device is not None:
                fixed_targets = []
                for target in targets:
                    if isinstance(target, dict):
                        target = dict(target)
                        for key, value in list(target.items()):
                            if torch.is_tensor(value):
                                target[key] = value.to(embed_device)
                    fixed_targets.append(target)
                targets = fixed_targets
                class_embed = DeviceSafeEmbedding(class_embed)

            return original(
                targets=targets,
                num_classes=num_classes,
                num_queries=num_queries,
                class_embed=class_embed,
                num_denoising_queries=num_denoising_queries,
                label_noise_ratio=label_noise_ratio,
                box_noise_scale=box_noise_scale,
                **kwargs,
            )

        wrapped._icecream_device_patch = True
        rtdetr_mod.get_contrastive_denoising_training_group = wrapped
        print("RT-DETR denoising device patch installed")
    except Exception as exc:
        # Denoising is disabled below where supported, so this helper is
        # optional. Do not make training fail because an internal helper moved.
        print(f"RT-DETR denoising patch skipped: {exc}")

def main():
    p=argparse.ArgumentParser()
    p.add_argument("--train-dir",required=True); p.add_argument("--val-dir",required=True)
    p.add_argument("--classes",required=True); p.add_argument("--output-dir",default="model")
    p.add_argument("--epochs",type=int,default=30); p.add_argument("--batch-size",type=int,default=2)
    p.add_argument("--learning-rate",type=float,default=1e-5); p.add_argument("--weight-decay",type=float,default=1e-4)
    p.add_argument("--num-workers",type=int,default=2)
    a=p.parse_args()

    classes=load_classes(a.classes)
    id2label={i:n for i,n in enumerate(classes)}
    label2id={n:i for i,n in enumerate(classes)}

    proc=RTDetrImageProcessor.from_pretrained(BASE_MODEL)
    train=COCODetectionDataset(Path(a.train_dir)/"images",Path(a.train_dir)/"annotations.json",proc)
    val=COCODetectionDataset(Path(a.val_dir)/"images",Path(a.val_dir)/"annotations.json",proc)

    if len(train)==0 or len(val)==0:
        raise ValueError("Training and validation datasets must contain at least one image.")
    if len(train.category_id_to_label)!=len(classes) or len(val.category_id_to_label)!=len(classes):
        raise ValueError("COCO categories do not match classes.txt. Rebuild the dataset after saving the classes.")

    model=RTDetrForObjectDetection.from_pretrained(
        BASE_MODEL,num_labels=len(classes),id2label=id2label,label2id=label2id,
        ignore_mismatched_sizes=True
    )
    # Some Transformers RT-DETR releases enter the denoising path whenever
    # training, regardless of num_denoising. Keep the config disabled where
    # supported, but also install the device-safe embedding patch below.
    for cfg_owner in (model, getattr(model, "model", None)):
        cfg = getattr(cfg_owner, "config", None)
        if cfg is not None:
            for name in ("num_denoising", "num_denoising_queries"):
                if hasattr(cfg, name):
                    setattr(cfg, name, 0)
    device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)
    patch_rtdetr_box_iou_device()
    patch_rtdetr_device_consistency()
    patch_rtdetr_denoising_device()

    tr=DataLoader(train,batch_size=a.batch_size,shuffle=True,num_workers=0,collate_fn=collate_fn)
    va=DataLoader(val,batch_size=a.batch_size,shuffle=False,num_workers=0,collate_fn=collate_fn)
    opt=torch.optim.AdamW(model.parameters(),lr=a.learning_rate,weight_decay=a.weight_decay)

    outdir=Path(a.output_dir); outdir.mkdir(parents=True,exist_ok=True)
    best=float("inf")

    for epoch in range(a.epochs):
        model.train(); running=0
        bar=tqdm(tr,desc=f"epoch {epoch+1}/{a.epochs}")
        for step,batch in enumerate(bar):
            batch=move_to_device(batch, device)
            # RT-DETR's loss matcher uses nested target tensors (boxes/classes).
            # Move every tensor in labels to the same device as the model.
            if "labels" in batch:
                # RT-DETR expects every nested target tensor on the same device as the model.
                for target in batch["labels"]:
                    if isinstance(target, dict):
                        for key, value in list(target.items()):
                            if torch.is_tensor(value):
                                target[key] = value.to(device)
            loss=model(**batch).loss
            loss.backward(); opt.step(); opt.zero_grad(set_to_none=True)
            running += float(loss.item())
            bar.set_postfix(loss=f"{running/(step+1):.4f}")
        vl=evaluate(model,va,device)
        print(f"validation_loss={vl:.4f}")
        if vl<best:
            best=vl
            model.save_pretrained(outdir)
            proc.save_pretrained(outdir)
            (outdir/"classes.json").write_text(json.dumps({"id2label":id2label,"label2id":label2id},indent=2))
    model.save_pretrained(outdir); proc.save_pretrained(outdir)

if __name__=="__main__": main()
"
TRAINING_DIR = ROOT / "training"
TRAIN_SCRIPT = TRAINING_DIR / "train.py"
if not TRAIN_SCRIPT.exists():
    TRAINING_DIR.mkdir(parents=True, exist_ok=True)
    TRAIN_SCRIPT.write_bytes(__import__("base64").b64decode(_TRAINING_SCRIPT_B64))
IMAGE_DIR = BASE / "images"
DATASET_FILE = BASE / "dataset.json"
MODEL_DIR = BASE / "model"
GENERATED_DIR = BASE / "generated_dataset"
CLASSES_FILE = BASE / "classes.txt"

IMAGE_DIR.mkdir(parents=True, exist_ok=True)
BASE.mkdir(parents=True, exist_ok=True)
MODEL_DIR.mkdir(parents=True, exist_ok=True)

DEFAULT_CLASSES = [
    "Carnavalita", "Kimo-COno", "Squizz", "Oreo", "Moro",
    "Dulce", "KitKat", "Cadbury", "Mega", "other"
]
if not CLASSES_FILE.exists():
    CLASSES_FILE.write_text("\n".join(DEFAULT_CLASSES) + "\n", encoding="utf-8")

CONFIDENCE_THRESHOLD = float(os.getenv("CONFIDENCE_THRESHOLD", "0.35"))
MAX_IMAGE_MB = int(os.getenv("MAX_IMAGE_MB", "15"))

_training = {"running": False, "message": "not started", "error": None}
_model = None
_processor = None
_model_lock = threading.Lock()
_annotation_click = None


def load_dataset():
    if not DATASET_FILE.exists():
        return {"images": [], "classes": read_classes()}
    try:
        data = json.loads(DATASET_FILE.read_text(encoding="utf-8"))
        data.setdefault("images", [])
        data["classes"] = read_classes()
        return data
    except Exception:
        return {"images": [], "classes": read_classes()}


def save_dataset(data):
    data["classes"] = read_classes()
    tmp = DATASET_FILE.with_suffix(".tmp")
    tmp.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
    tmp.replace(DATASET_FILE)


def read_classes():
    if not CLASSES_FILE.exists():
        return []
    return [x.strip() for x in CLASSES_FILE.read_text(encoding="utf-8").splitlines() if x.strip()]


def image_path(image_id):
    return IMAGE_DIR / f"{image_id}.jpg"


def model_ready():
    return (MODEL_DIR / "config.json").exists()


def load_model():
    global _model, _processor
    if not model_ready():
        raise RuntimeError("No trained model yet. Train the model first.")
    with _model_lock:
        if _model is None:
            _processor = RTDetrImageProcessor.from_pretrained(str(MODEL_DIR))
            _model = RTDetrForObjectDetection.from_pretrained(str(MODEL_DIR))
            _model.to("cuda" if torch.cuda.is_available() else "cpu")
            _model.eval()
    return _processor, _model


def dataset_status():
    data = load_dataset()
    annotated = sum(bool(x.get("annotations")) for x in data["images"])
    return (
        f"**Dataset:** {len(data['images'])} images  |  "
        f"**Annotated:** {annotated}  |  "
        f"**Classes:** {len(read_classes())}  |  "
        f"**Model:** {'READY' if model_ready() else 'NOT TRAINED'}  |  "
        f"**Storage:** `{BASE}`"
    )


def image_choices():
    data = load_dataset()
    return [(x["filename"], x["id"]) for x in data["images"]]


def upload_training_images(files):
    if not files:
        return dataset_status(), gr.update(choices=image_choices()), "No files selected."

    data = load_dataset()
    saved = 0
    skipped = []
    for f in files:
        try:
            # Gradio 6 may return FileData objects or plain dictionaries.
            if isinstance(f, dict):
                raw_path = f.get("path") or f.get("name") or f.get("filepath")
            else:
                raw_path = getattr(f, "path", None) or getattr(f, "name", None) or f
            path = Path(raw_path)
            raw = path.read_bytes()
            if len(raw) > MAX_IMAGE_MB * 1024 * 1024:
                skipped.append(f"{path.name}: over {MAX_IMAGE_MB} MB")
                continue
            im = Image.open(io.BytesIO(raw)).convert("RGB")
            image_id = __import__("uuid").uuid4().hex
            out = image_path(image_id)
            im.save(out, "JPEG", quality=95)
            data["images"].append({
                "id": image_id,
                "filename": path.name,
                "width": im.width,
                "height": im.height,
                "annotations": [],
            })
            saved += 1
        except Exception as e:
            skipped.append(f"{path.name}: {e}")

    save_dataset(data)
    msg = f"Saved {saved} image(s)."
    if skipped:
        msg += "\nSkipped:\n- " + "\n- ".join(skipped)
    return dataset_status(), gr.update(choices=image_choices()), msg


def image_data_uri(image_id):
    import base64
    p = image_path(image_id)
    if not p.exists():
        return ""
    return "data:image/jpeg;base64," + base64.b64encode(p.read_bytes()).decode("ascii")


def annotation_canvas_html(image_id):
    if not image_id:
        return '<div class="anno-empty">Select an image from the Dataset tab.</div>'
    data = load_dataset()
    item = next((x for x in data["images"] if x["id"] == image_id), None)
    if not item:
        return '<div class="anno-empty">Image not found.</div>'
    src = image_data_uri(image_id)
    boxes = json.dumps(item.get("annotations", []), ensure_ascii=False)
    return """<div class="anno-wrap">
<div class="anno-toolbar"><b>Draw boxes directly on the image</b><span>Click + drag + release = create box</span><span>Choose the class first</span></div>
<div class="anno-canvas-wrap"><canvas id="anno-canvas"></canvas></div>
<div class="anno-help" id="anno-hint">Drag from one corner of the object to the opposite corner, then release. The coordinates are filled automatically; click <b>Save Box</b>. Repeat for every object.</div>
</div>
<script>
(function(){
const imgSrc=%s, imageW=%d, imageH=%d, saved=%s;
const canvas=document.getElementById('anno-canvas'); if(!canvas)return;
const ctx=canvas.getContext('2d'), img=new Image(); let drawing=false,sx=0,sy=0,current=null;
function fit(){const maxW=Math.min(1100,window.innerWidth-80),maxH=Math.max(400,window.innerHeight*.62),scale=Math.min(maxW/imageW,maxH/imageH,1);canvas.width=Math.max(1,Math.round(imageW*scale));canvas.height=Math.max(1,Math.round(imageH*scale));canvas.dataset.scale=scale;redraw();}
function redraw(){if(!img.complete)return;const sc=+canvas.dataset.scale||1;ctx.clearRect(0,0,canvas.width,canvas.height);ctx.drawImage(img,0,0,canvas.width,canvas.height);saved.forEach((a,i)=>{const b=a.box||[];const x=b[0]*sc,y=b[1]*sc,w=b[2]*sc,h=b[3]*sc;ctx.strokeStyle='#ff3030';ctx.lineWidth=3;ctx.strokeRect(x,y,w,h);ctx.fillStyle='#ff3030';ctx.fillRect(x,Math.max(0,y-22),120,22);ctx.fillStyle='#fff';ctx.font='14px sans-serif';ctx.fillText((i+1)+'. '+a.class,x+5,Math.max(16,y-6));});if(current){ctx.strokeStyle='#00ff88';ctx.lineWidth=3;ctx.setLineDash([7,5]);ctx.strokeRect(current.x,current.y,current.w,current.h);ctx.setLineDash([]);}}
function pos(e){const r=canvas.getBoundingClientRect();return{x:e.clientX-r.left,y:e.clientY-r.top};}
function setField(id,val){const box=document.querySelector('#'+id);const el=box?.querySelector('input,textarea');if(!el)return;const setter=Object.getOwnPropertyDescriptor(HTMLInputElement.prototype,'value')?.set||Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype,'value')?.set;if(setter)setter.call(el,String(val));else el.value=String(val);el.dispatchEvent(new Event('input',{bubbles:true}));el.dispatchEvent(new Event('change',{bubbles:true}));}
canvas.addEventListener('pointerdown',e=>{e.preventDefault();canvas.setPointerCapture(e.pointerId);const p=pos(e);sx=p.x;sy=p.y;drawing=true;current={x:sx,y:sy,w:0,h:0};redraw();});
canvas.addEventListener('pointermove',e=>{if(!drawing)return;const p=pos(e);current={x:Math.min(sx,p.x),y:Math.min(sy,p.y),w:Math.abs(p.x-sx),h:Math.abs(p.y-sy)};redraw();});
canvas.addEventListener('pointerup',e=>{if(!drawing)return;drawing=false;const p=pos(e),sc=+canvas.dataset.scale||1;const x=Math.min(sx,p.x)/sc,y=Math.min(sy,p.y)/sc,w=Math.abs(p.x-sx)/sc,h=Math.abs(p.y-sy)/sc;current=null;redraw();if(w<3||h<3)return;setField('anno-x',Math.round(x));setField('anno-y',Math.round(y));setField('anno-w',Math.round(w));setField('anno-h',Math.round(h));const hint=document.getElementById('anno-hint');if(hint)hint.textContent='Box created. Click “Save Box” to store it.';});
canvas.addEventListener('pointercancel',()=>{drawing=false;current=null;redraw();});
img.onload=fit;img.src=imgSrc;window.addEventListener('resize',fit);
})();</script>""" % (json.dumps(src), int(item["width"]), int(item["height"]), boxes)



def annotation_preview_image(image_id):
    """Return the real PIL image for Gradio's Image component."""
    if not image_id:
        return None
    p = image_path(image_id)
    if not p.exists():
        return None
    try:
        return Image.open(p).convert("RGB")
    except Exception:
        return None


def annotation_preview_with_boxes(image_id):
    image = annotation_preview_image(image_id)
    if image is None:
        return None
    data = load_dataset()
    item = next((x for x in data["images"] if x["id"] == image_id), None)
    if not item:
        return image
    out = image.copy()
    draw = ImageDraw.Draw(out)
    for i, a in enumerate(item.get("annotations", []), 1):
        x, y, w, h = a["box"]
        draw.rectangle([x, y, x+w, y+h], outline="red", width=5)
        label = f"{i}. {a['class']}"
        y0 = max(0, y-24)
        draw.rectangle([x, y0, x+max(130, len(label)*9), y0+24], fill="red")
        draw.text((x+4, y0+4), label, fill="white")
    return out


def refresh_editor(image_id):
    if not image_id:
        return None, "Select an image.", []
    data=load_dataset()
    item=next((x for x in data["images"] if x["id"]==image_id),None)
    if not item:
        return None,"Image not found.",[]
    return annotation_preview_with_boxes(image_id), f"**{item['filename']}** — {item['width']} × {item['height']} px", item.get("annotations",[])

def draw_annotations(image_id):
    """Render the annotation canvas for the selected image."""
    return annotation_canvas_html(image_id)


def add_annotation(image_id, cls, x, y, w, h):
    if not image_id:return annotation_preview_with_boxes(image_id),"Select an image first.",[]
    if not cls:return annotation_preview_with_boxes(image_id),"Select a class first.",[]
    try:x,y,w,h=map(float,[x,y,w,h])
    except:return annotation_preview_with_boxes(image_id),"Enter box coordinates first.",[]
    if w<=0 or h<=0:return annotation_preview_with_boxes(image_id),"Box must have a width and height.",[]
    data=load_dataset()
    item=next((z for z in data["images"] if z["id"]==image_id),None)
    if not item:return None,"Image not found.",[]
    x=max(0,min(x,item["width"]-1)); y=max(0,min(y,item["height"]-1))
    w=min(w,item["width"]-x); h=min(h,item["height"]-y)
    item.setdefault("annotations",[]).append({"class":cls,"box":[x,y,w,h]})
    save_dataset(data)
    return annotation_preview_with_boxes(image_id),f"Saved {cls}: [{x:.0f}, {y:.0f}, {w:.0f}, {h:.0f}]",item["annotations"]


def remove_annotation(image_id,index):
    if not image_id:return annotation_preview_with_boxes(image_id),"Select an image first.",[]
    data=load_dataset()
    item=next((z for z in data["images"] if z["id"]==image_id),None)
    if not item:return None,"Image not found.",[]
    try:idx=int(index)-1
    except:return annotation_preview_with_boxes(image_id),"Enter an annotation number.",item.get("annotations",[])
    anns=item.get("annotations",[])
    if idx<0 or idx>=len(anns):return annotation_preview_with_boxes(image_id),"Annotation number not found.",anns
    deleted=anns.pop(idx);save_dataset(data)
    return annotation_preview_with_boxes(image_id),f"Deleted annotation {index}: {deleted['class']}",anns


def clear_annotations(image_id):
    if not image_id:return annotation_preview_with_boxes(image_id),"Select an image first.",[]
    data=load_dataset()
    item=next((z for z in data["images"] if z["id"]==image_id),None)
    if not item:return None,"Image not found.",[]
    item["annotations"]=[];save_dataset(data)
    return annotation_preview_with_boxes(image_id),"Annotations cleared.",[]


def save_classes(text):
    classes = [x.strip() for x in (text or "").splitlines() if x.strip()]
    if not classes:
        return "At least one class is required.", gr.update(choices=read_classes()), dataset_status()
    if len(set(classes)) != len(classes):
        return "Classes must be unique.", gr.update(choices=read_classes()), dataset_status()
    CLASSES_FILE.write_text("\n".join(classes) + "\n", encoding="utf-8")
    data = load_dataset()
    save_dataset(data)
    return f"Saved {len(classes)} classes.", gr.update(choices=classes, value=classes[0]), dataset_status()


def handle_annotation_click(image_id, cls, click_state, evt: gr.SelectData):
    """Use two clicks on the real Gradio image to define a box.
    First click = top-left corner, second click = opposite corner.
    This avoids the unreliable HTML canvas/script path and works in Gradio itself.
    """
    if not image_id:
        return 0, 0, 0, 0, [], "Select an image first."
    if not cls:
        return 0, 0, 0, 0, [], "Select a class first."
    data = load_dataset()
    item = next((x for x in data["images"] if x["id"] == image_id), None)
    if not item:
        return 0, 0, 0, 0, [], "Image not found."
    try:
        point = evt.index
        px, py = float(point[0]), float(point[1])
    except Exception:
        return 0, 0, 0, 0, click_state or [], "Could not read the image click position."
    px = max(0, min(px, item["width"] - 1))
    py = max(0, min(py, item["height"] - 1))
    state = list(click_state or [])
    if not state:
        return round(px), round(py), 0, 0, [px, py], f"First corner: ({px:.0f}, {py:.0f}). Now click the opposite corner."
    x0, y0 = state[:2]
    x = min(x0, px); y = min(y0, py)
    w = abs(px - x0); h = abs(py - y0)
    if w < 2 or h < 2:
        return round(x), round(y), 0, 0, [], "Box is too small. Click the first corner again."
    return round(x), round(y), round(w), round(h), [], f"Box ready: [{x:.0f}, {y:.0f}, {w:.0f}, {h:.0f}] for {cls}. Click Save Box."


def build_coco():
    data = load_dataset()
    classes = read_classes()
    if not classes:
        raise RuntimeError("No classes configured.")
    items = [x for x in data["images"] if x.get("annotations")]
    if not items:
        raise RuntimeError("Annotate at least 1 image before training.")

    # With only one annotated image, use it for both training and validation so
    # the first training run is possible. With 2+ images, use an 80/20 split.
    if len(items) == 1:
        train_items, val_items = items, items
    else:
        split = max(1, int(len(items) * 0.8))
        if split >= len(items):
            split = len(items) - 1
        train_items, val_items = items[:split], items[split:]
    category_id = {name: i + 1 for i, name in enumerate(classes)}

    def make_coco(selected):
        images, annotations = [], []
        ann_id = 1
        for item in selected:
            images.append({
                "id": item["id"],
                "file_name": item["id"] + ".jpg",
                "width": item["width"],
                "height": item["height"],
            })
            for ann in item["annotations"]:
                x, y, w, h = ann["box"]
                annotations.append({
                    "id": ann_id,
                    "image_id": item["id"],
                    "category_id": category_id[ann["class"]],
                    "bbox": [x, y, w, h],
                    "area": w*h,
                    "iscrowd": 0,
                })
                ann_id += 1
        return {
            "images": images,
            "annotations": annotations,
            "categories": [{"id": i+1, "name": n} for i, n in enumerate(classes)]
        }

    if GENERATED_DIR.exists():
        shutil.rmtree(GENERATED_DIR)
    for name, selected in [("train", train_items), ("val", val_items)]:
        d = GENERATED_DIR / name
        (d / "images").mkdir(parents=True, exist_ok=True)
        for item in selected:
            shutil.copy2(image_path(item["id"]), d / "images" / f"{item['id']}.jpg")
        (d / "annotations.json").write_text(
            json.dumps(make_coco(selected), indent=2), encoding="utf-8"
        )


def run_training(epochs, batch_size, learning_rate):
    global _training, _model
    try:
        _training = {"running": True, "message": "building COCO dataset", "error": None}
        build_coco()
        _training["message"] = "training RT-DETR"
        cmd = [
            sys.executable, str(TRAIN_SCRIPT),
            "--train-dir", str(GENERATED_DIR / "train"),
            "--val-dir", str(GENERATED_DIR / "val"),
            "--classes", str(CLASSES_FILE),
            "--output-dir", str(MODEL_DIR),
            "--epochs", str(int(epochs)),
            "--batch-size", str(int(batch_size)),
            "--learning-rate", str(float(learning_rate)),
        ]
        result = subprocess.run(cmd, cwd=ROOT, capture_output=True, text=True)
        if result.returncode != 0:
            details = result.stderr.strip() or result.stdout.strip() or f"training process exited with code {result.returncode}"
            raise RuntimeError(details[-12000:])
        _model = None
        _training = {"running": False, "message": "training complete", "error": None}
    except Exception as e:
        _training = {"running": False, "message": "training failed", "error": str(e)}


@spaces.GPU(duration=120)
def start_training(epochs, batch_size, learning_rate):
    """Start training from the Gradio event itself.

    Calling the @spaces.GPU function directly is important on Hugging Face
    ZeroGPU: starting it from a normal Python background thread can bypass the
    GPU allocation context, making the button appear to do nothing.
    """
    global _training
    if _training["running"]:
        return json.dumps(_training, indent=2)
    # Validate parameters before requesting GPU time.
    try:
        epochs = max(1, int(epochs))
        batch_size = max(1, int(batch_size))
        learning_rate = float(learning_rate)
        if learning_rate <= 0:
            raise ValueError("Learning rate must be greater than 0.")
    except Exception as e:
        _training = {"running": False, "message": "training failed", "error": f"Invalid training settings: {e}"}
        return json.dumps(_training, indent=2)

    annotated = sum(bool(x.get("annotations")) for x in load_dataset()["images"])
    if annotated < 1:
        _training = {"running": False, "message": "training failed", "error": "Annotate at least 1 image before training."}
        return json.dumps(_training, indent=2)
    run_training(epochs, batch_size, learning_rate)
    return json.dumps(_training, indent=2)


def training_status():
    return json.dumps(_training, indent=2)


@spaces.GPU(duration=60)
def count_image(image):
    if image is None:
        return None, "Upload an image first.", {}
    if not model_ready():
        return None, "Model is not trained yet. Go to Training.", {}
    try:
        proc, detector = load_model()
        image = image.convert("RGB") if isinstance(image, Image.Image) else Image.fromarray(image).convert("RGB")
        device = next(detector.parameters()).device
        inputs = proc(images=image, return_tensors="pt")
        inputs = {k: v.to(device) if torch.is_tensor(v) else v for k, v in inputs.items()}
        with torch.inference_mode():
            outputs = detector(**inputs)
        target_sizes = torch.tensor([[image.height, image.width]], device=device)
        result = proc.post_process_object_detection(
            outputs, threshold=CONFIDENCE_THRESHOLD, target_sizes=target_sizes
        )[0]

        detections = []
        counts = Counter()
        for score, label, box in zip(result["scores"], result["labels"], result["boxes"]):
            s = float(score.item())
            cls = detector.config.id2label[int(label.item())]
            coords = [round(float(v), 2) for v in box.tolist()]
            detections.append({"class": cls, "confidence": round(s, 4), "box": coords})
            counts[cls] += 1

        out = image.copy()
        draw = ImageDraw.Draw(out)
        for d in detections:
            x1, y1, x2, y2 = d["box"]
            draw.rectangle([x1, y1, x2, y2], outline="red", width=4)
            label = f"{d['class']} {d['confidence']:.2f}"
            draw.rectangle([x1, max(0, y1-22), x1+max(120, len(label)*8), y1], fill="red")
            draw.text((x1+3, max(0, y1-20)), label, fill="white")

        response = {
            "total": len(detections),
            "counts": dict(sorted(counts.items())),
            "detections": detections,
        }
        return out, json.dumps(response, indent=2), response["counts"]
    except Exception as e:
        return None, f"Counting failed: {e}", {}


# ----- Gradio UI -----
CSS = """
.gradio-container { max-width: 1250px !important; }
h1 { margin-bottom: 0.2rem !important; }
.anno-wrap{width:100%}.anno-toolbar{display:flex;gap:14px;flex-wrap:wrap;padding:10px 12px;margin-bottom:8px;border-radius:10px;background:#20242a}.anno-toolbar span{opacity:.85}.anno-canvas-wrap{width:100%;overflow:auto;border:1px solid #555;border-radius:10px;background:#111;padding:8px}.anno-canvas-wrap canvas{display:block;max-width:none;cursor:crosshair;touch-action:none;margin:auto}.anno-help{padding:8px 2px;opacity:.75}.anno-empty{padding:50px;text-align:center;border:1px dashed #777;border-radius:10px}
#annotation-image img { max-height: 650px !important; object-fit: contain !important; }
.status { padding: 10px 14px; border-radius: 10px; }
"""

with gr.Blocks(title="Ice Cream Dataset + Counter") as demo:
    gr.Markdown("# 🍦 Ice Cream Dataset + Counter\nUpload and annotate training images, train RT-DETR, then count ice creams in new images.")
    status = gr.Markdown(dataset_status(), elem_classes="status")

    with gr.Tab("1 · Dataset"):
        gr.Markdown("### Upload training images")
        files = gr.Files(file_count="multiple", file_types=["image"], type="filepath", label="Images")
        upload_btn = gr.Button("Save Images", variant="primary")
        upload_msg = gr.Markdown()
        # Dataset selector
        image_select = gr.Dropdown(choices=image_choices(), label="Training image", interactive=True)
        refresh_btn = gr.Button("Refresh Dataset")
        refresh_btn.click(lambda: (dataset_status(), gr.update(choices=image_choices())), None, [status, image_select])

        gr.Markdown("### Classes")
        class_text = gr.Textbox(value="\n".join(read_classes()), lines=8, label="One class per line")
        save_class_btn = gr.Button("Save Classes")
        class_msg = gr.Markdown()
        # Class dropdown is updated after the Annotate tab creates it.

    with gr.Tab("2 · Annotate"):
        gr.Markdown("### Annotate training images")
        gr.Markdown("Select an image above, choose a class, then **click the first corner and click the opposite corner** of each object. The real uploaded image is shown below. Click **Save Box** after each box.")
        with gr.Row():
            with gr.Column(scale=3):
                annotation_image = gr.Image(value=None, type="pil", interactive=False, label="Training image", height=650, elem_id="annotation-image")
                editor_info = gr.Markdown("Select an image from the Dataset tab.")
            with gr.Column(scale=1):
                ann_class = gr.Dropdown(choices=read_classes(), value=(read_classes()[0] if read_classes() else None), label="Class", interactive=True)
                x = gr.Number(label="X (left)", value=0, precision=0)
                y = gr.Number(label="Y (top)", value=0, precision=0)
                w = gr.Number(label="Width", value=0, precision=0)
                h = gr.Number(label="Height", value=0, precision=0)
                add_btn = gr.Button("💾 Save Box", variant="primary")
                gr.Markdown("**Box method:** click corner 1 → click corner 2 → Save Box.")
                delete_index = gr.Number(label="Annotation # to delete", value=1, precision=0)
                delete_btn = gr.Button("Delete Box")
                clear_btn = gr.Button("Clear All Boxes")
        annotations = gr.JSON(label="Saved annotations")
        ann_msg = gr.Markdown()
        click_state = gr.State([])

        def load_annotation_image(image_id):
            return annotation_preview_with_boxes(image_id), refresh_editor(image_id)[1], refresh_editor(image_id)[2], []

        image_select.change(load_annotation_image, image_select, [annotation_image, editor_info, annotations, click_state])
        annotation_image.select(handle_annotation_click, [image_select, ann_class, click_state], [x, y, w, h, click_state, ann_msg])
        add_btn.click(add_annotation, [image_select, ann_class, x, y, w, h], [annotation_image, ann_msg, annotations])
        delete_btn.click(remove_annotation, [image_select, delete_index], [annotation_image, ann_msg, annotations])
        clear_btn.click(clear_annotations, image_select, [annotation_image, ann_msg, annotations])

    with gr.Tab("3 · Training"):
        gr.Markdown("### Train RT-DETR")
        gr.Markdown("Training runs in the Space process. A GPU Space is strongly recommended for practical training speed.")
        with gr.Row():
            epochs = gr.Number(value=int(os.getenv("EPOCHS", "30")), label="Epochs", precision=0)
            batch = gr.Number(value=int(os.getenv("BATCH_SIZE", "2")), label="Batch size", precision=0)
            lr = gr.Number(value=float(os.getenv("LEARNING_RATE", "1e-5")), label="Learning rate")
        train_btn = gr.Button("🚀 Start Training", variant="primary")
        refresh_train = gr.Button("Refresh Training Status")
        train_out = gr.Code(value=training_status, language="json", label="Training status")
        train_btn.click(start_training, [epochs, batch, lr], train_out)
        refresh_train.click(training_status, None, train_out)

    with gr.Tab("4 · Count"):
        gr.Markdown("### Count ice creams")
        count_in = gr.Image(type="pil", sources=["upload", "clipboard"], label="Image to count")
        count_btn = gr.Button("🍦 Count", variant="primary")
        count_out = gr.Image(label="Detections")
        count_json = gr.Code(language="json", label="Detection details")
        count_table = gr.JSON(label="Counts by class")
        count_btn.click(count_image, count_in, [count_out, count_json, count_table])

    # Correct the upload event now that image_select exists.
    upload_btn.click(
        upload_training_images,
        files,
        [status, image_select, upload_msg],
        preprocess=False,
        queue=False,
    )
    save_class_btn.click(save_classes, class_text, [class_msg, ann_class, status])
    # The earlier placeholder event is harmlessly superseded by this real event.

    demo.load(lambda: (dataset_status(), gr.update(choices=image_choices()), gr.update(choices=read_classes(), value=(read_classes()[0] if read_classes() else None))),
              None, [status, image_select, ann_class])

if __name__ == "__main__":
    demo.queue().launch(
        server_name="0.0.0.0",
        server_port=int(os.getenv("PORT", "7860")),
        css=CSS,
    )