// backend\training.go

package main

import (
	"crypto/sha1"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"math"
	"math/rand"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"sort"
	"strconv"
	"strings"
	"sync"
	"syscall"
	"time"
)

type TrainingLabels struct {
	SexPositions []string `json:"sexPositions"`
	BodyParts    []string `json:"bodyParts"`
	Objects      []string `json:"objects"`
	Clothing     []string `json:"clothing"`
}

type TrainingBox struct {
	Label string  `json:"label"`
	Score float64 `json:"score,omitempty"`
	X     float64 `json:"x"`
	Y     float64 `json:"y"`
	W     float64 `json:"w"`
	H     float64 `json:"h"`
}

type TrainingScoredLabel struct {
	Label string  `json:"label"`
	Score float64 `json:"score"`
}

type TrainingPrediction struct {
	ModelAvailable bool   `json:"modelAvailable"`
	Source         string `json:"source,omitempty"`

	PeopleCount      int                   `json:"peopleCount"`
	MaleCount        int                   `json:"maleCount"`
	FemaleCount      int                   `json:"femaleCount"`
	UnknownCount     int                   `json:"unknownCount"`
	SexPosition      string                `json:"sexPosition"`
	SexPositionScore float64               `json:"sexPositionScore"`
	BodyPartsPresent []TrainingScoredLabel `json:"bodyPartsPresent"`
	ObjectsPresent   []TrainingScoredLabel `json:"objectsPresent"`
	ClothingPresent  []TrainingScoredLabel `json:"clothingPresent"`
	Boxes            []TrainingBox         `json:"boxes"`
}

type TrainingCorrection struct {
	PeopleCount      int           `json:"peopleCount"`
	MaleCount        int           `json:"maleCount"`
	FemaleCount      int           `json:"femaleCount"`
	UnknownCount     int           `json:"unknownCount"`
	SexPosition      string        `json:"sexPosition"`
	BodyPartsPresent []string      `json:"bodyPartsPresent"`
	ObjectsPresent   []string      `json:"objectsPresent"`
	ClothingPresent  []string      `json:"clothingPresent"`
	Boxes            []TrainingBox `json:"boxes"`
}

type TrainingSample struct {
	SampleID        string             `json:"sampleId"`
	FrameURL        string             `json:"frameUrl"`
	SourceFile      string             `json:"sourceFile"`
	SourcePath      string             `json:"sourcePath,omitempty"`
	SourceSizeBytes int64              `json:"sourceSizeBytes,omitempty"`
	Second          float64            `json:"second"`
	CreatedAt       string             `json:"createdAt"`
	Prediction      TrainingPrediction `json:"prediction"`
}

type TrainingFeedbackRequest struct {
	SampleID   string              `json:"sampleId"`
	Accepted   bool                `json:"accepted"`
	Correction *TrainingCorrection `json:"correction,omitempty"`
	Notes      string              `json:"notes,omitempty"`
}

type TrainingAnnotation struct {
	SampleID        string              `json:"sampleId"`
	FrameURL        string              `json:"frameUrl"`
	SourceFile      string              `json:"sourceFile"`
	SourcePath      string              `json:"sourcePath,omitempty"`
	SourceSizeBytes int64               `json:"sourceSizeBytes,omitempty"`
	Second          float64             `json:"second"`
	CreatedAt       string              `json:"createdAt"`
	AnsweredAt      string              `json:"answeredAt"`
	Prediction      TrainingPrediction  `json:"prediction"`
	Accepted        bool                `json:"accepted"`
	Correction      *TrainingCorrection `json:"correction,omitempty"`
	Notes           string              `json:"notes,omitempty"`
}

type TrainingDetectorPrediction struct {
	Available bool          `json:"available"`
	Source    string        `json:"source,omitempty"`
	Boxes     []TrainingBox `json:"boxes"`
}

type TrainingJobStatus struct {
	Running    bool   `json:"running"`
	Progress   int    `json:"progress"`
	Step       string `json:"step"`
	Message    string `json:"message,omitempty"`
	Error      string `json:"error,omitempty"`
	StartedAt  string `json:"startedAt,omitempty"`
	FinishedAt string `json:"finishedAt,omitempty"`
}

const minTrainingFeedbackCount = 5

const minDetectorTrainCount = 20
const minDetectorValCount = 3

var trainingJob = struct {
	mu     sync.Mutex
	status TrainingJobStatus
}{}

func trainingSetJobStatus(update func(*TrainingJobStatus)) {
	trainingJob.mu.Lock()
	defer trainingJob.mu.Unlock()
	update(&trainingJob.status)
}

func trainingGetJobStatus() TrainingJobStatus {
	trainingJob.mu.Lock()
	defer trainingJob.mu.Unlock()
	return trainingJob.status
}

func trainingRunCommand(python string, script string, args ...string) (string, error) {
	cmdArgs := append([]string{script}, args...)
	cmd := exec.Command(python, cmdArgs...)

	cmd.SysProcAttr = &syscall.SysProcAttr{
		HideWindow:    true,
		CreationFlags: 0x08000000,
	}

	out, err := cmd.CombinedOutput()
	return strings.TrimSpace(string(out)), err
}

func trainingLabelsHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		trainingWriteError(w, http.StatusMethodNotAllowed, "method not allowed")
		return
	}

	trainingWriteJSON(w, http.StatusOK, defaultTrainingLabelsFromJSON())
}

func trainingNextHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		trainingWriteError(w, http.StatusMethodNotAllowed, "method not allowed")
		return
	}

	forceNew := r.URL.Query().Get("force") == "1" ||
		strings.EqualFold(r.URL.Query().Get("force"), "true")

	root, err := trainingRootDir()
	if err != nil {
		trainingWriteError(w, http.StatusInternalServerError, err.Error())
		return
	}

	if !forceNew {
		if sample, ok, err := trainingLatestOpenSample(root); err != nil {
			trainingWriteError(w, http.StatusInternalServerError, err.Error())
			return
		} else if ok {
			trainingWriteJSON(w, http.StatusOK, sample)
			return
		}
	}

	sample, err := trainingCreateNextSample()
	if err != nil {
		trainingWriteError(w, http.StatusInternalServerError, err.Error())
		return
	}

	trainingWriteJSON(w, http.StatusOK, sample)
}

func trainingLatestOpenSample(root string) (*TrainingSample, bool, error) {
	answered, err := trainingAnsweredSampleIDs(root)
	if err != nil {
		return nil, false, err
	}

	samplesDir := filepath.Join(root, "samples")

	entries, err := os.ReadDir(samplesDir)
	if err != nil {
		if os.IsNotExist(err) {
			return nil, false, nil
		}
		return nil, false, err
	}

	type sampleFile struct {
		id      string
		path    string
		modTime time.Time
	}

	files := []sampleFile{}

	for _, entry := range entries {
		if entry.IsDir() {
			continue
		}

		name := entry.Name()
		if strings.ToLower(filepath.Ext(name)) != ".json" {
			continue
		}

		id := strings.TrimSuffix(name, filepath.Ext(name))
		if id == "" || answered[id] {
			continue
		}

		info, err := entry.Info()
		if err != nil {
			continue
		}

		files = append(files, sampleFile{
			id:      id,
			path:    filepath.Join(samplesDir, name),
			modTime: info.ModTime(),
		})
	}

	sort.Slice(files, func(i, j int) bool {
		return files[i].modTime.After(files[j].modTime)
	})

	for _, file := range files {
		sample, err := trainingReadSample(root, file.id)
		if err != nil {
			continue
		}

		framePath := filepath.Join(root, "frames", sample.SampleID+".jpg")
		if !fileExistsNonEmpty(framePath) {
			continue
		}

		// Wichtig: Prediction aktualisieren, damit alte "model_missing"-Samples
		// nach einem Training nicht stale bleiben.
		sample.Prediction = trainingPredictFrame(framePath)
		_ = trainingWriteSample(root, sample)

		return sample, true, nil
	}

	return nil, false, nil
}

func trainingAnsweredSampleIDs(root string) (map[string]bool, error) {
	out := map[string]bool{}

	path := filepath.Join(root, "feedback.jsonl")

	b, err := os.ReadFile(path)
	if err != nil {
		if os.IsNotExist(err) {
			return out, nil
		}
		return nil, err
	}

	for _, line := range strings.Split(string(b), "\n") {
		line = strings.TrimSpace(line)
		if line == "" {
			continue
		}

		var row TrainingAnnotation
		if err := json.Unmarshal([]byte(line), &row); err != nil {
			continue
		}

		id := strings.TrimSpace(row.SampleID)
		if id != "" {
			out[id] = true
		}
	}

	return out, nil
}

func trainingFrameHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		trainingWriteError(w, http.StatusMethodNotAllowed, "method not allowed")
		return
	}

	id := strings.TrimSpace(r.URL.Query().Get("id"))
	if id == "" || strings.Contains(id, "/") || strings.Contains(id, "\\") {
		trainingWriteError(w, http.StatusBadRequest, "invalid frame id")
		return
	}

	root, err := trainingRootDir()
	if err != nil {
		trainingWriteError(w, http.StatusInternalServerError, err.Error())
		return
	}

	path := filepath.Join(root, "frames", id+".jpg")

	if _, err := os.Stat(path); err != nil {
		trainingWriteError(w, http.StatusNotFound, "frame not found")
		return
	}

	w.Header().Set("Cache-Control", "no-store")
	http.ServeFile(w, r, path)
}

func trainingFeedbackHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		trainingWriteError(w, http.StatusMethodNotAllowed, "method not allowed")
		return
	}

	var req TrainingFeedbackRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		trainingWriteError(w, http.StatusBadRequest, "invalid json")
		return
	}

	req.SampleID = strings.TrimSpace(req.SampleID)
	if req.SampleID == "" {
		trainingWriteError(w, http.StatusBadRequest, "sampleId missing")
		return
	}

	root, err := trainingRootDir()
	if err != nil {
		trainingWriteError(w, http.StatusInternalServerError, err.Error())
		return
	}

	sample, err := trainingReadSample(root, req.SampleID)
	if err != nil {
		trainingWriteError(w, http.StatusNotFound, "sample not found")
		return
	}

	annotation := TrainingAnnotation{
		SampleID:        sample.SampleID,
		FrameURL:        sample.FrameURL,
		SourceFile:      sample.SourceFile,
		SourcePath:      sample.SourcePath,
		SourceSizeBytes: sample.SourceSizeBytes,
		Second:          sample.Second,
		CreatedAt:       sample.CreatedAt,
		AnsweredAt:      time.Now().UTC().Format(time.RFC3339),
		Prediction:      sample.Prediction,
		Accepted:        req.Accepted,
		Correction:      req.Correction,
		Notes:           strings.TrimSpace(req.Notes),
	}

	if !annotation.Accepted && annotation.Correction == nil {
		trainingWriteError(w, http.StatusBadRequest, "correction missing")
		return
	}

	if err := trainingAppendAnnotation(root, annotation); err != nil {
		trainingWriteError(w, http.StatusInternalServerError, err.Error())
		return
	}

	if req.Correction != nil && len(req.Correction.Boxes) > 0 {
		if err := trainingWriteDetectorSample(root, sample, req.Correction.Boxes); err != nil {
			fmt.Println("⚠️ detector sample write failed:", err)
		}
	}

	trainingWriteJSON(w, http.StatusOK, map[string]any{
		"ok": true,
	})
}

func trainingHasDetectorTrainingData(imagesDir string, labelsDir string) bool {
	imageExts := map[string]bool{
		".jpg":  true,
		".jpeg": true,
		".png":  true,
		".webp": true,
	}

	entries, err := os.ReadDir(imagesDir)
	if err != nil {
		return false
	}

	count := 0

	for _, e := range entries {
		if e.IsDir() {
			continue
		}

		ext := strings.ToLower(filepath.Ext(e.Name()))
		if !imageExts[ext] {
			continue
		}

		id := strings.TrimSuffix(e.Name(), filepath.Ext(e.Name()))
		labelPath := filepath.Join(labelsDir, id+".txt")

		if fileExistsNonEmpty(labelPath) {
			count++
		}
	}

	return count >= 5
}

func trainingTrainHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		trainingWriteError(w, http.StatusMethodNotAllowed, "method not allowed")
		return
	}

	current := trainingGetJobStatus()
	if current.Running {
		trainingWriteJSON(w, http.StatusOK, map[string]any{
			"ok":       true,
			"message":  "Training läuft bereits.",
			"training": current,
		})
		return
	}

	root, err := trainingRootDir()
	if err != nil {
		trainingWriteError(w, http.StatusInternalServerError, err.Error())
		return
	}

	if err := trainingEnsureDetectorDirs(root); err != nil {
		trainingWriteError(w, http.StatusInternalServerError, err.Error())
		return
	}

	// Falls bisher alles zufällig in train gelandet ist, erzeugen wir mindestens
	// ein Validation-Sample durch Kopieren. Bei mehr Daten solltest du später
	// einen echten 80/20 Split verwenden.
	if err := trainingEnsureDetectorValidationSample(root); err != nil {
		fmt.Println("⚠️ detector val sample ensure failed:", err)
	}

	feedbackPath := filepath.Join(root, "feedback.jsonl")
	feedbackCount, _ := trainingCountAnnotations(feedbackPath)

	detectorTrainImages := filepath.Join(root, "detector", "dataset", "images", "train")
	detectorTrainLabels := filepath.Join(root, "detector", "dataset", "labels", "train")
	detectorValImages := filepath.Join(root, "detector", "dataset", "images", "val")
	detectorValLabels := filepath.Join(root, "detector", "dataset", "labels", "val")
	detectorDatasetYAML := filepath.Join(root, "detector", "dataset", "dataset.yaml")

	trainCount := trainingCountDetectorSamples(detectorTrainImages, detectorTrainLabels)
	valCount := trainingCountDetectorSamples(detectorValImages, detectorValLabels)

	if !fileExistsNonEmpty(detectorDatasetYAML) {
		trainingWriteError(
			w,
			http.StatusBadRequest,
			"YOLO dataset.yaml fehlt oder ist leer. Bitte Detector-Ordner/Dataset prüfen.",
		)
		return
	}

	if trainCount < minDetectorTrainCount || valCount < minDetectorValCount {
		trainingWriteError(
			w,
			http.StatusBadRequest,
			fmt.Sprintf(
				"Zu wenige YOLO-Box-Labels. Benötigt: mindestens %d Train und %d Val. Aktuell: Train=%d, Val=%d. Feedback gesamt: %d.",
				minDetectorTrainCount,
				minDetectorValCount,
				trainCount,
				valCount,
				feedbackCount,
			),
		)
		return
	}

	trainingSetJobStatus(func(s *TrainingJobStatus) {
		*s = TrainingJobStatus{
			Running:   true,
			Progress:  5,
			Step:      "YOLO-Detector-Training wird vorbereitet…",
			StartedAt: time.Now().UTC().Format(time.RFC3339),
		}
	})

	go trainingRunJob(root, feedbackCount)

	trainingWriteJSON(w, http.StatusAccepted, map[string]any{
		"ok":       true,
		"message":  "YOLO-Detector-Training gestartet.",
		"training": trainingGetJobStatus(),
		"detector": map[string]any{
			"trainCount":      trainCount,
			"valCount":        valCount,
			"requiredTrain":   minDetectorTrainCount,
			"requiredVal":     minDetectorValCount,
			"datasetYAML":     detectorDatasetYAML,
			"usesSceneKNN":    false,
			"usesResNet18KNN": false,
			"source":          "yolo_detector",
		},
	})
}

func trainingRunJob(root string, count int) {
	python := trainingPythonExe()

	trainingSetJobStatus(func(s *TrainingJobStatus) {
		s.Progress = 20
		s.Step = "Detector-Daten werden geprüft…"
	})

	detectorOutput := ""
	detectorStatus := "skipped"

	detectorDatasetYAML := filepath.Join(root, "detector", "dataset", "dataset.yaml")
	detectorTrainImages := filepath.Join(root, "detector", "dataset", "images", "train")
	detectorTrainLabels := filepath.Join(root, "detector", "dataset", "labels", "train")
	detectorValImages := filepath.Join(root, "detector", "dataset", "images", "val")
	detectorValLabels := filepath.Join(root, "detector", "dataset", "labels", "val")

	if err := trainingEnsureDetectorValidationSample(root); err != nil {
		fmt.Println("⚠️ detector val sample ensure failed:", err)
	}

	trainCount := trainingCountDetectorSamples(detectorTrainImages, detectorTrainLabels)
	valCount := trainingCountDetectorSamples(detectorValImages, detectorValLabels)

	fmt.Printf("🔎 detector data: train=%d val=%d yaml=%v\n", trainCount, valCount, fileExistsNonEmpty(detectorDatasetYAML))

	if fileExistsNonEmpty(detectorDatasetYAML) &&
		trainCount >= minDetectorTrainCount &&
		valCount >= minDetectorValCount {
		trainingSetJobStatus(func(s *TrainingJobStatus) {
			s.Progress = 35
			s.Step = "YOLO-Detector wird trainiert…"
		})

		detectorScript := trainingScriptPath("train_detector_model.py")
		detectorOut, detectorErr := trainingRunCommand(
			python,
			detectorScript,
			"--root", root,
			"--base", "yolo11n.pt",
			"--epochs", "60",
			"--imgsz", "640",
		)

		detectorOutput = detectorOut

		if detectorErr != nil {
			detectorStatus = "failed"
			fmt.Println("⚠️ detector training failed:", detectorErr, detectorOutput)
		} else {
			detectorStatus = "trained"
		}
	} else {
		detectorStatus = "skipped_no_detector_data"
		detectorOutput = fmt.Sprintf(
			"Detector übersprungen: zu wenige YOLO-Box-Labels. Train=%d, Val=%d. Benötigt: mindestens %d Train und %d Val.",
			trainCount,
			valCount,
			minDetectorTrainCount,
			minDetectorValCount,
		)

		fmt.Println("⚠️", detectorOutput)
	}

	message := "Training abgeschlossen."
	if detectorStatus == "trained" {
		message = "Training abgeschlossen. YOLO-Detector wurde trainiert."
	}
	if detectorStatus == "failed" {
		message = "YOLO-Detector-Training ist fehlgeschlagen."
	}
	if detectorStatus == "skipped_no_detector_data" {
		message = detectorOutput
	}

	trainingSetJobStatus(func(s *TrainingJobStatus) {
		s.Running = false
		s.Progress = 100
		s.Step = "Training abgeschlossen."
		s.Message = message
		s.Error = ""
		s.FinishedAt = time.Now().UTC().Format(time.RFC3339)
	})
}

func trainingStatusHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		trainingWriteError(w, http.StatusMethodNotAllowed, "method not allowed")
		return
	}

	root, err := trainingRootDir()
	if err != nil {
		trainingWriteError(w, http.StatusInternalServerError, err.Error())
		return
	}

	if err := trainingEnsureDetectorDirs(root); err != nil {
		trainingWriteError(w, http.StatusInternalServerError, err.Error())
		return
	}

	// Optional, aber praktisch: Status zeigt dann sofort valCount > 0,
	// falls mindestens genug train-Daten vorhanden sind.
	if err := trainingEnsureDetectorValidationSample(root); err != nil {
		fmt.Println("⚠️ detector val sample ensure failed:", err)
	}

	feedbackPath := filepath.Join(root, "feedback.jsonl")
	feedbackCount, _ := trainingCountAnnotations(feedbackPath)

	job := trainingGetJobStatus()

	detectorDatasetYAML := filepath.Join(root, "detector", "dataset", "dataset.yaml")
	detectorTrainImages := filepath.Join(root, "detector", "dataset", "images", "train")
	detectorTrainLabels := filepath.Join(root, "detector", "dataset", "labels", "train")
	detectorValImages := filepath.Join(root, "detector", "dataset", "images", "val")
	detectorValLabels := filepath.Join(root, "detector", "dataset", "labels", "val")
	detectorModelPath := filepath.Join(root, "detector", "model", "best.pt")

	trainCount := trainingCountDetectorSamples(detectorTrainImages, detectorTrainLabels)
	valCount := trainingCountDetectorSamples(detectorValImages, detectorValLabels)

	datasetReady := fileExistsNonEmpty(detectorDatasetYAML)
	detectorDataReady := datasetReady &&
		trainCount >= minDetectorTrainCount &&
		valCount >= minDetectorValCount

	trainingWriteJSON(w, http.StatusOK, map[string]any{
		"ok":            true,
		"feedbackCount": feedbackCount,
		"requiredCount": minTrainingFeedbackCount,

		// Für YOLO-only ist canTrain jetzt bewusst an Box-Labels gekoppelt,
		// nicht mehr nur an feedback.jsonl.
		"canTrain": detectorDataReady,

		"training": job,
		"detector": map[string]any{
			"source":          "yolo_detector",
			"usesSceneKNN":    false,
			"usesResNet18KNN": false,

			"trainCount":    trainCount,
			"valCount":      valCount,
			"requiredTrain": minDetectorTrainCount,
			"requiredVal":   minDetectorValCount,

			"datasetReady": datasetReady,
			"datasetYAML":  detectorDatasetYAML,

			"dataReady": detectorDataReady,

			"modelExists": fileExistsNonEmpty(detectorModelPath),
			"modelPath":   detectorModelPath,
		},
	})
}

func trainingDeleteAllHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodDelete && r.Method != http.MethodPost {
		trainingWriteError(w, http.StatusMethodNotAllowed, "method not allowed")
		return
	}

	root, err := trainingRootDir()
	if err != nil {
		trainingWriteError(w, http.StatusInternalServerError, err.Error())
		return
	}

	if err := os.RemoveAll(root); err != nil {
		trainingWriteError(w, http.StatusInternalServerError, fmt.Sprintf("Trainingsdaten konnten nicht gelöscht werden: %v", err))
		return
	}

	// Basisordner direkt wieder anlegen, damit die nächsten API-Aufrufe sauber funktionieren.
	if _, err := trainingRootDir(); err != nil {
		trainingWriteError(w, http.StatusInternalServerError, err.Error())
		return
	}

	trainingWriteJSON(w, http.StatusOK, map[string]any{
		"ok":      true,
		"message": "Alle Trainingsdaten wurden gelöscht.",
	})
}

func trainingCountDetectorSamples(imagesDir string, labelsDir string) int {
	imageExts := map[string]bool{
		".jpg":  true,
		".jpeg": true,
		".png":  true,
		".webp": true,
	}

	entries, err := os.ReadDir(imagesDir)
	if err != nil {
		return 0
	}

	count := 0

	for _, e := range entries {
		if e.IsDir() {
			continue
		}

		ext := strings.ToLower(filepath.Ext(e.Name()))
		if !imageExts[ext] {
			continue
		}

		id := strings.TrimSuffix(e.Name(), filepath.Ext(e.Name()))
		labelPath := filepath.Join(labelsDir, id+".txt")

		if fileExistsNonEmpty(labelPath) {
			count++
		}
	}

	return count
}

func trainingWriteDetectorDatasetYAML(root string) error {
	datasetDir := filepath.Join(root, "detector", "dataset")

	absDatasetDir, err := filepath.Abs(datasetDir)
	if err != nil {
		return err
	}

	namesYAML, err := trainingDetectorDatasetNamesYAML()
	if err != nil {
		return err
	}

	path := filepath.Join(datasetDir, "dataset.yaml")
	yoloPath := filepath.ToSlash(absDatasetDir)

	body := fmt.Sprintf(`path: %s
train: images/train
val: images/val

names:
%s`, yoloPath, namesYAML)

	return os.WriteFile(path, []byte(body), 0644)
}

func trainingEnsureDetectorDirs(root string) error {
	dirs := []string{
		filepath.Join(root, "detector"),
		filepath.Join(root, "detector", "dataset"),
		filepath.Join(root, "detector", "dataset", "images"),
		filepath.Join(root, "detector", "dataset", "images", "train"),
		filepath.Join(root, "detector", "dataset", "images", "val"),
		filepath.Join(root, "detector", "dataset", "labels"),
		filepath.Join(root, "detector", "dataset", "labels", "train"),
		filepath.Join(root, "detector", "dataset", "labels", "val"),
		filepath.Join(root, "detector", "runs"),
	}

	for _, dir := range dirs {
		if err := os.MkdirAll(dir, 0755); err != nil {
			return err
		}
	}

	if err := trainingWriteDetectorDatasetYAML(root); err != nil {
		return err
	}

	return nil
}

func trainingCreateNextSample() (*TrainingSample, error) {
	settings := getSettings()

	doneDir := strings.TrimSpace(settings.DoneDir)
	if doneDir == "" {
		return nil, errors.New("doneDir ist leer")
	}

	videoPath, err := trainingPickRandomVideo(doneDir)
	if err != nil {
		return nil, err
	}

	duration := trainingProbeDurationSeconds(videoPath)
	second := trainingRandomSecond(duration)

	root, err := trainingRootDir()
	if err != nil {
		return nil, err
	}

	if err := trainingEnsureDetectorDirs(root); err != nil {
		return nil, err
	}

	if err := os.MkdirAll(filepath.Join(root, "frames"), 0755); err != nil {
		return nil, err
	}
	if err := os.MkdirAll(filepath.Join(root, "samples"), 0755); err != nil {
		return nil, err
	}

	id := trainingMakeSampleID(videoPath, second)
	framePath := filepath.Join(root, "frames", id+".jpg")

	if err := trainingExtractFrame(videoPath, framePath, second); err != nil {
		// Fallback auf Sekunde 0, falls random second nicht funktioniert.
		second = 0
		id = trainingMakeSampleID(videoPath, second)
		framePath = filepath.Join(root, "frames", id+".jpg")

		if err2 := trainingExtractFrame(videoPath, framePath, second); err2 != nil {
			return nil, fmt.Errorf("frame extraction failed: %v / fallback: %w", err, err2)
		}
	}

	prediction := trainingPredictFrame(framePath)

	var sourceSizeBytes int64
	if st, err := os.Stat(videoPath); err == nil && st != nil && !st.IsDir() {
		sourceSizeBytes = st.Size()
	}

	sample := &TrainingSample{
		SampleID:        id,
		FrameURL:        "/api/training/frame?id=" + id,
		SourceFile:      filepath.Base(videoPath),
		SourcePath:      videoPath,
		SourceSizeBytes: sourceSizeBytes,
		Second:          second,
		CreatedAt:       time.Now().UTC().Format(time.RFC3339),
		Prediction:      prediction,
	}

	if err := trainingWriteSample(root, sample); err != nil {
		return nil, err
	}

	return sample, nil
}

func trainingPickRandomVideo(doneDir string) (string, error) {
	extOK := map[string]bool{
		".mp4":  true,
		".mkv":  true,
		".webm": true,
		".mov":  true,
		".avi":  true,
	}

	var files []string

	err := filepath.WalkDir(doneDir, func(path string, d os.DirEntry, err error) error {
		if err != nil {
			return nil
		}
		if d.IsDir() {
			name := strings.ToLower(d.Name())
			if name == ".trash" || name == "training" || name == "generated" {
				return filepath.SkipDir
			}
			return nil
		}

		ext := strings.ToLower(filepath.Ext(path))
		if extOK[ext] {
			files = append(files, path)
		}
		return nil
	})

	if err != nil {
		return "", err
	}

	if len(files) == 0 {
		return "", errors.New("keine Videos im doneDir gefunden")
	}

	return files[rand.Intn(len(files))], nil
}

func trainingExtractFrame(videoPath string, framePath string, second float64) error {
	settings := getSettings()

	ffmpeg := strings.TrimSpace(settings.FFmpegPath)
	if ffmpeg == "" {
		ffmpeg = "ffmpeg"
	}

	_ = os.Remove(framePath)

	ss := strconv.FormatFloat(math.Max(0, second), 'f', 3, 64)

	cmd := exec.Command(
		ffmpeg,
		"-hide_banner",
		"-loglevel", "error",
		"-ss", ss,
		"-i", videoPath,
		"-frames:v", "1",
		"-q:v", "2",
		"-y",
		framePath,
	)

	cmd.SysProcAttr = &syscall.SysProcAttr{
		HideWindow:    true,
		CreationFlags: 0x08000000,
	}

	out, err := cmd.CombinedOutput()
	if err != nil {
		return fmt.Errorf("%w: %s", err, strings.TrimSpace(string(out)))
	}

	if st, err := os.Stat(framePath); err != nil || st.Size() == 0 {
		return errors.New("ffmpeg erzeugte kein Frame")
	}

	return nil
}

func trainingPredictFrame(framePath string) TrainingPrediction {
	root, err := trainingRootDir()
	if err != nil {
		fmt.Println("⚠️ training predict root error:", err)
		return trainingEmptyPrediction("root_error")
	}

	det := trainingPredictDetector(root, framePath)

	pred := trainingPredictionFromDetector(det)

	fmt.Println("✅ training predict result")
	fmt.Println("  modelAvailable:", pred.ModelAvailable)
	fmt.Println("  source:", pred.Source)
	fmt.Println("  sexPosition:", pred.SexPosition)
	fmt.Println("  bodyParts:", len(pred.BodyPartsPresent))
	fmt.Println("  objects:", len(pred.ObjectsPresent))
	fmt.Println("  clothing:", len(pred.ClothingPresent))
	fmt.Println("  boxes:", len(pred.Boxes))

	return pred
}

func trainingPredictionFromDetector(det TrainingDetectorPrediction) TrainingPrediction {
	boxes := det.Boxes
	if boxes == nil {
		boxes = []TrainingBox{}
	}

	pred := TrainingPrediction{
		ModelAvailable:   det.Available,
		Source:           det.Source,
		PeopleCount:      0,
		MaleCount:        0,
		FemaleCount:      0,
		UnknownCount:     0,
		SexPosition:      "unknown",
		SexPositionScore: 0,
		BodyPartsPresent: []TrainingScoredLabel{},
		ObjectsPresent:   []TrainingScoredLabel{},
		ClothingPresent:  []TrainingScoredLabel{},
		Boxes:            boxes,
	}

	if pred.Source == "" {
		if det.Available {
			pred.Source = "yolo_detector"
		} else {
			pred.Source = "detector_missing"
		}
	}

	grouped, err := trainingGroupedLabels()
	if err != nil {
		fmt.Println("⚠️ detector label grouping failed:", err)
		return pred
	}

	pred.BodyPartsPresent = trainingScoredLabelsFromDetectorBoxes(boxes, grouped.BodyParts)
	pred.ObjectsPresent = trainingScoredLabelsFromDetectorBoxes(boxes, grouped.Objects)
	pred.ClothingPresent = trainingScoredLabelsFromDetectorBoxes(boxes, grouped.Clothing)

	return pred
}

func trainingPredictDetector(root string, framePath string) TrainingDetectorPrediction {
	python := trainingPythonExe()
	script := trainingScriptPath("predict_detector_model.py")

	modelPath := filepath.Join(root, "detector", "model", "best.pt")

	fmt.Println("🔎 detector predict")
	fmt.Println("  python:", python)
	fmt.Println("  root:", root)
	fmt.Println("  script:", script)
	fmt.Println("  image:", framePath)
	fmt.Println("  model:", modelPath)
	fmt.Println("  modelExists:", fileExistsNonEmpty(modelPath))

	if !fileExistsNonEmpty(modelPath) {
		return TrainingDetectorPrediction{
			Available: false,
			Source:    "detector_missing",
			Boxes:     []TrainingBox{},
		}
	}

	confValues := []string{"0.30", "0.10", "0.03", "0.01"}

	best := TrainingDetectorPrediction{
		Available: true,
		Source:    "yolo_detector",
		Boxes:     []TrainingBox{},
	}

	for _, conf := range confValues {
		cmd := exec.Command(
			python,
			script,
			"--root", root,
			"--image", framePath,
			"--conf", conf,
			"--imgsz", "640",
		)

		cmd.SysProcAttr = &syscall.SysProcAttr{
			HideWindow:    true,
			CreationFlags: 0x08000000,
		}

		var stdout strings.Builder
		var stderr strings.Builder

		cmd.Stdout = &stdout
		cmd.Stderr = &stderr

		err := cmd.Run()

		outText := strings.TrimSpace(stdout.String())
		errText := strings.TrimSpace(stderr.String())

		if errText != "" {
			fmt.Println("🔎 detector stderr:", errText)
		}

		if err != nil {
			fmt.Println("⚠️ detector predict failed")
			fmt.Println("  conf:", conf)
			fmt.Println("  error:", err)
			fmt.Println("  stdout:", outText)
			fmt.Println("  stderr:", errText)
			continue
		}

		if outText == "" {
			fmt.Println("⚠️ detector predict empty stdout")
			fmt.Println("  conf:", conf)
			fmt.Println("  stderr:", errText)
			continue
		}

		var det TrainingDetectorPrediction
		if err := json.Unmarshal([]byte(outText), &det); err != nil {
			fmt.Println("⚠️ detector predict json failed:", err)
			fmt.Println("  conf:", conf)
			fmt.Println("  stdout:", outText)
			fmt.Println("  stderr:", errText)
			continue
		}

		if det.Boxes == nil {
			det.Boxes = []TrainingBox{}
		}

		if det.Source == "" {
			det.Source = "yolo_detector"
		}

		fmt.Println("✅ detector predict result")
		fmt.Println("  conf:", conf)
		fmt.Println("  available:", det.Available)
		fmt.Println("  source:", det.Source)
		fmt.Println("  boxes:", len(det.Boxes))

		best = det

		if len(det.Boxes) > 0 {
			return det
		}
	}

	if best.Boxes == nil {
		best.Boxes = []TrainingBox{}
	}

	return best
}

func trainingScoredLabelsFromDetectorBoxes(
	boxes []TrainingBox,
	group []string,
) []TrainingScoredLabel {
	groupSet := map[string]bool{}

	for _, label := range group {
		clean := strings.TrimSpace(label)
		if clean != "" {
			groupSet[clean] = true
		}
	}

	best := map[string]float64{}

	for _, box := range boxes {
		label := strings.TrimSpace(box.Label)
		if label == "" || !groupSet[label] {
			continue
		}

		score := box.Score
		if score <= 0 {
			score = 1
		}

		if old, ok := best[label]; !ok || score > old {
			best[label] = score
		}
	}

	out := make([]TrainingScoredLabel, 0, len(best))

	for label, score := range best {
		out = append(out, TrainingScoredLabel{
			Label: label,
			Score: score,
		})
	}

	sort.Slice(out, func(i, j int) bool {
		if out[i].Score == out[j].Score {
			return out[i].Label < out[j].Label
		}

		return out[i].Score > out[j].Score
	})

	return out
}

func trainingApplyDetectorToPrediction(pred TrainingPrediction, det TrainingDetectorPrediction) TrainingPrediction {
	boxes := det.Boxes
	if boxes == nil {
		boxes = []TrainingBox{}
	}

	grouped, err := trainingGroupedLabels()
	if err != nil {
		fmt.Println("⚠️ detector label grouping failed:", err)

		pred.Boxes = boxes
		pred.BodyPartsPresent = []TrainingScoredLabel{}
		pred.ObjectsPresent = []TrainingScoredLabel{}
		pred.ClothingPresent = []TrainingScoredLabel{}
		return pred
	}

	// Wichtig:
	// Ab jetzt kommen diese drei Bereiche ausschließlich vom YOLO-Detector.
	// Kein Scene-KNN-Fallback, damit keine Labels ohne Box angezeigt werden.
	pred.BodyPartsPresent = trainingScoredLabelsFromDetectorBoxes(boxes, grouped.BodyParts)
	pred.ObjectsPresent = trainingScoredLabelsFromDetectorBoxes(boxes, grouped.Objects)
	pred.ClothingPresent = trainingScoredLabelsFromDetectorBoxes(boxes, grouped.Clothing)
	pred.Boxes = boxes

	if det.Available {
		if pred.Source == "" {
			pred.Source = "yolo_detector"
		} else {
			pred.Source = pred.Source + "+yolo_detector"
		}
		pred.ModelAvailable = true
	}

	return pred
}

func trainingWriteDetectorSample(root string, sample *TrainingSample, boxes []TrainingBox) error {
	if sample == nil {
		return errors.New("sample missing")
	}

	classMap, err := trainingDetectorClassMap()
	if err != nil {
		return err
	}

	srcFrame := filepath.Join(root, "frames", sample.SampleID+".jpg")
	if _, err := os.Stat(srcFrame); err != nil {
		return fmt.Errorf("frame missing: %w", err)
	}

	// Stabiler 80/20 Split: gleicher sampleID landet immer im gleichen Split.
	split := trainingStableSplit(sample.SampleID)

	imgDir := filepath.Join(root, "detector", "dataset", "images", split)
	lblDir := filepath.Join(root, "detector", "dataset", "labels", split)

	if err := os.MkdirAll(imgDir, 0755); err != nil {
		return err
	}
	if err := os.MkdirAll(lblDir, 0755); err != nil {
		return err
	}

	dstFrame := filepath.Join(imgDir, sample.SampleID+".jpg")
	if err := copyFile(srcFrame, dstFrame); err != nil {
		return err
	}

	var lines []string

	for _, box := range boxes {
		label := strings.TrimSpace(box.Label)
		if label == "" {
			continue
		}

		classID, ok := classMap[label]
		if !ok {
			continue
		}

		x := clamp01(box.X)
		y := clamp01(box.Y)
		w := clamp01(box.W)
		h := clamp01(box.H)

		if w <= 0 || h <= 0 {
			continue
		}

		// Frontend/Predictor nutzen x/y als linke obere Ecke.
		// YOLO erwartet x_center/y_center.
		xCenter := clamp01(x + w/2)
		yCenter := clamp01(y + h/2)

		lines = append(lines, fmt.Sprintf(
			"%d %.6f %.6f %.6f %.6f",
			classID,
			xCenter,
			yCenter,
			w,
			h,
		))
	}

	if len(lines) == 0 {
		return errors.New("no valid detector boxes")
	}

	labelPath := filepath.Join(lblDir, sample.SampleID+".txt")
	return os.WriteFile(labelPath, []byte(strings.Join(lines, "\n")+"\n"), 0644)
}

func trainingEnsureDetectorValidationSample(root string) error {
	trainImages := filepath.Join(root, "detector", "dataset", "images", "train")
	trainLabels := filepath.Join(root, "detector", "dataset", "labels", "train")
	valImages := filepath.Join(root, "detector", "dataset", "images", "val")
	valLabels := filepath.Join(root, "detector", "dataset", "labels", "val")

	currentVal := trainingCountDetectorSamples(valImages, valLabels)
	if currentVal >= minDetectorValCount {
		return nil
	}

	if trainingCountDetectorSamples(trainImages, trainLabels) < minDetectorTrainCount {
		return nil
	}

	entries, err := os.ReadDir(trainImages)
	if err != nil {
		return nil
	}

	if err := os.MkdirAll(valImages, 0755); err != nil {
		return err
	}
	if err := os.MkdirAll(valLabels, 0755); err != nil {
		return err
	}

	copied := 0
	needed := minDetectorValCount - currentVal

	for _, e := range entries {
		if copied >= needed {
			break
		}

		if e.IsDir() {
			continue
		}

		ext := strings.ToLower(filepath.Ext(e.Name()))
		if ext != ".jpg" && ext != ".jpeg" && ext != ".png" && ext != ".webp" {
			continue
		}

		id := strings.TrimSuffix(e.Name(), filepath.Ext(e.Name()))

		srcImage := filepath.Join(trainImages, e.Name())
		srcLabel := filepath.Join(trainLabels, id+".txt")

		if !fileExistsNonEmpty(srcImage) || !fileExistsNonEmpty(srcLabel) {
			continue
		}

		dstImage := filepath.Join(valImages, e.Name())
		dstLabel := filepath.Join(valLabels, id+".txt")

		if fileExistsNonEmpty(dstImage) && fileExistsNonEmpty(dstLabel) {
			continue
		}

		if err := copyFile(srcImage, dstImage); err != nil {
			return err
		}
		if err := copyFile(srcLabel, dstLabel); err != nil {
			return err
		}

		copied++
		fmt.Println("✅ detector val sample duplicated:", id)
	}

	return nil
}

func trainingStableSplit(sampleID string) string {
	sum := sha1.Sum([]byte(sampleID))
	if int(sum[0])%5 == 0 {
		return "val"
	}
	return "train"
}

func copyFile(src string, dst string) error {
	b, err := os.ReadFile(src)
	if err != nil {
		return err
	}
	return os.WriteFile(dst, b, 0644)
}

func trainingEmptyPrediction(source string) TrainingPrediction {
	return TrainingPrediction{
		ModelAvailable:   false,
		Source:           source,
		PeopleCount:      0,
		MaleCount:        0,
		FemaleCount:      0,
		UnknownCount:     0,
		SexPosition:      "unknown",
		SexPositionScore: 0,
		BodyPartsPresent: []TrainingScoredLabel{},
		ObjectsPresent:   []TrainingScoredLabel{},
		ClothingPresent:  []TrainingScoredLabel{},
		Boxes:            []TrainingBox{},
	}
}

func trainingPythonExe() string {
	v := strings.TrimSpace(os.Getenv("TRAINING_PYTHON"))
	if v != "" {
		return v
	}
	return "python"
}

func trainingProjectRoot() string {
	wd, err := os.Getwd()
	if err != nil {
		return "."
	}

	if _, err := os.Stat(filepath.Join(wd, "backend", "ml", "predict_detector_model.py")); err == nil {
		return wd
	}

	if _, err := os.Stat(filepath.Join(wd, "ml", "predict_detector_model.py")); err == nil {
		return filepath.Dir(wd)
	}

	parent := filepath.Dir(wd)
	if _, err := os.Stat(filepath.Join(parent, "backend", "ml", "predict_detector_model.py")); err == nil {
		return parent
	}

	return wd
}

func trainingScriptPath(name string) string {
	// 1) Eingebettete Scripts bevorzugen.
	if dir, err := trainingEmbeddedMLDir(); err == nil {
		p := filepath.Join(dir, name)
		if _, err := os.Stat(p); err == nil {
			return p
		}
	}

	// 2) App-/Backend-relativ wie record_paths.go.
	if backendRoot, err := trainingBackendRootDir(); err == nil {
		p := filepath.Join(backendRoot, "ml", name)
		if _, err := os.Stat(p); err == nil {
			return p
		}
	}

	// 3) Dev-Fallback.
	root := trainingProjectRoot()

	p := filepath.Join(root, "backend", "ml", name)
	if _, err := os.Stat(p); err == nil {
		return p
	}

	p = filepath.Join("ml", name)
	if _, err := os.Stat(p); err == nil {
		return p
	}

	return filepath.Join(root, "backend", "ml", name)
}

func isTempBuildDir(dir string) bool {
	low := strings.ToLower(filepath.Clean(dir))

	return strings.Contains(low, `\appdata\local\temp`) ||
		strings.Contains(low, `\temp\`) ||
		strings.Contains(low, `\tmp\`) ||
		strings.Contains(low, `\go-build`) ||
		strings.Contains(low, `/tmp/`) ||
		strings.Contains(low, `/go-build`)
}

func trainingBackendRootDir() (string, error) {
	if script, err := resolvePathRelativeToApp(filepath.Join("ml", "predict_detector_model.py")); err == nil {
		if st, statErr := os.Stat(script); statErr == nil && !st.IsDir() {
			return filepath.Dir(filepath.Dir(script)), nil
		}
	}

	if script, err := resolvePathRelativeToApp(filepath.Join("backend", "ml", "predict_detector_model.py")); err == nil {
		if st, statErr := os.Stat(script); statErr == nil && !st.IsDir() {
			return filepath.Dir(filepath.Dir(script)), nil
		}
	}

	if dir, err := exeDir(); err == nil && strings.TrimSpace(dir) != "" && !isTempBuildDir(dir) {
		return dir, nil
	}

	wd, err := os.Getwd()
	if err != nil {
		return "", err
	}

	if _, err := os.Stat(filepath.Join(wd, "ml", "predict_detector_model.py")); err == nil {
		return wd, nil
	}

	if _, err := os.Stat(filepath.Join(wd, "backend", "ml", "predict_detector_model.py")); err == nil {
		return filepath.Join(wd, "backend"), nil
	}

	projectRoot := trainingProjectRoot()
	return filepath.Join(projectRoot, "backend"), nil
}

func trainingRootDir() (string, error) {
	// Optionaler Override, falls du später explizit einen anderen Speicherort willst.
	// Relative Pfade werden wie in record_paths.go app-relativ aufgelöst.
	if override := strings.TrimSpace(os.Getenv("TRAINING_ROOT")); override != "" {
		root, err := resolvePathRelativeToApp(override)
		if err != nil {
			return "", err
		}

		root, err = filepath.Abs(root)
		if err != nil {
			return "", err
		}

		if err := os.MkdirAll(root, 0755); err != nil {
			return "", err
		}

		return root, nil
	}

	backendRoot, err := trainingBackendRootDir()
	if err != nil {
		return "", err
	}

	root, err := filepath.Abs(filepath.Join(backendRoot, "generated", "training"))
	if err != nil {
		return "", err
	}

	if err := os.MkdirAll(root, 0755); err != nil {
		return "", err
	}

	return root, nil
}

func trainingWriteSample(root string, sample *TrainingSample) error {
	path := filepath.Join(root, "samples", sample.SampleID+".json")
	b, err := json.MarshalIndent(sample, "", "  ")
	if err != nil {
		return err
	}
	return os.WriteFile(path, b, 0644)
}

func trainingReadSample(root string, sampleID string) (*TrainingSample, error) {
	if strings.Contains(sampleID, "/") || strings.Contains(sampleID, "\\") {
		return nil, errors.New("invalid sample id")
	}

	path := filepath.Join(root, "samples", sampleID+".json")

	b, err := os.ReadFile(path)
	if err != nil {
		return nil, err
	}

	var sample TrainingSample
	if err := json.Unmarshal(b, &sample); err != nil {
		return nil, err
	}

	return &sample, nil
}

func trainingAppendAnnotation(root string, annotation TrainingAnnotation) error {
	path := filepath.Join(root, "feedback.jsonl")

	f, err := os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
	if err != nil {
		return err
	}
	defer f.Close()

	b, err := json.Marshal(annotation)
	if err != nil {
		return err
	}

	if _, err := f.Write(append(b, '\n')); err != nil {
		return err
	}

	return nil
}

func trainingCountAnnotations(path string) (int, error) {
	b, err := os.ReadFile(path)
	if err != nil {
		return 0, err
	}

	text := strings.TrimSpace(string(b))
	if text == "" {
		return 0, nil
	}

	return len(strings.Split(text, "\n")), nil
}

func trainingProbeDurationSeconds(videoPath string) float64 {
	settings := getSettings()

	ffmpeg := strings.TrimSpace(settings.FFmpegPath)
	ffprobe := "ffprobe"

	if ffmpeg != "" {
		dir := filepath.Dir(ffmpeg)
		base := filepath.Base(ffmpeg)
		if strings.Contains(strings.ToLower(base), "ffmpeg") {
			ffprobeBase := strings.Replace(base, "ffmpeg", "ffprobe", 1)
			ffprobe = filepath.Join(dir, ffprobeBase)
		}
	}

	cmd := exec.Command(
		ffprobe,
		"-v", "error",
		"-show_entries", "format=duration",
		"-of", "default=noprint_wrappers=1:nokey=1",
		videoPath,
	)

	cmd.SysProcAttr = &syscall.SysProcAttr{
		HideWindow:    true,
		CreationFlags: 0x08000000,
	}

	out, err := cmd.Output()
	if err != nil {
		return 0
	}

	v, err := strconv.ParseFloat(strings.TrimSpace(string(out)), 64)
	if err != nil || math.IsNaN(v) || math.IsInf(v, 0) || v <= 0 {
		return 0
	}

	return v
}

func trainingRandomSecond(duration float64) float64 {
	if duration <= 2 {
		return 0
	}

	minSec := 1.0
	maxSec := math.Max(minSec, duration-1)

	return minSec + rand.Float64()*(maxSec-minSec)
}

func trainingMakeSampleID(videoPath string, second float64) string {
	h := sha1.New()
	_, _ = h.Write([]byte(videoPath))
	_, _ = h.Write([]byte("|"))
	_, _ = h.Write([]byte(strconv.FormatFloat(second, 'f', 3, 64)))
	_, _ = h.Write([]byte("|"))
	_, _ = h.Write([]byte(strconv.FormatInt(time.Now().UnixNano(), 10)))
	return hex.EncodeToString(h.Sum(nil))[:20]
}

func trainingWriteJSON(w http.ResponseWriter, status int, v any) {
	w.Header().Set("Content-Type", "application/json")
	w.Header().Set("Cache-Control", "no-store")
	w.WriteHeader(status)
	_ = json.NewEncoder(w).Encode(v)
}

func trainingWriteError(w http.ResponseWriter, status int, msg string) {
	trainingWriteJSON(w, status, map[string]any{
		"ok":    false,
		"error": msg,
	})
}