kettlebell-tracker/internal/ui/history.go

package ui

import (
	"fmt"
	"log"
	"strconv"

	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/dialog"
	"fyne.io/fyne/v2/theme"
	"fyne.io/fyne/v2/widget"
	"git.patanix.de/git/kettlebell-app/internal/data"
	"git.patanix.de/git/kettlebell-app/internal/ui/utils"
)

func MakeHistoryScreen(db *data.DatabaseService, parent fyne.Window) fyne.CanvasObject {
	var history []data.TrainingSession

	placeholder := widget.NewLabel("Noch keine Trainingsdaten vorhanden.")

	var showDetailDialog func(session data.TrainingSession, id int)
	var refreshData func()

	list := widget.NewList(
		func() int { return len(history) },
		func() fyne.CanvasObject {
			return container.NewGridWithColumns(4,
				widget.NewLabel(""),
				widget.NewLabel(""),
				widget.NewLabel(""),
				widget.NewLabel(""),
			)
		},
		func(i widget.ListItemID, o fyne.CanvasObject) {
			session := history[i]
			row := o.(*fyne.Container)
			row.Objects[0].(*widget.Label).SetText(session.Date.Format("02.01.2006 15:04"))
			row.Objects[1].(*widget.Label).SetText(fmt.Sprintf("%d", session.Sets))
			row.Objects[2].(*widget.Label).SetText(utils.FormatDuration(session.Duration))
			row.Objects[3].(*widget.Label).SetText(fmt.Sprintf("%d", session.RepsPerSet))
		},
	)

	list.OnSelected = func(id widget.ListItemID) {
		session := history[id]
		showDetailDialog(session, id)
		list.Unselect(id)
	}

	showDetailDialog = func(session data.TrainingSession, id int) {
		details := container.NewVBox(
			widget.NewLabel(fmt.Sprintf("Datum: %s", session.Date.Format("02.01.2006 15:04"))),
			widget.NewLabel(fmt.Sprintf("Programm: %s", session.Program)),
			widget.NewLabel(fmt.Sprintf("Block-Tag: %d", session.BlockDay)),
			widget.NewLabel(fmt.Sprintf("Sätze: %d", session.Sets)),
			widget.NewLabel(fmt.Sprintf("Dauer: %s", utils.FormatDuration(session.Duration))),
			widget.NewLabel(fmt.Sprintf("Reps/Satz: %d", session.RepsPerSet)),
			widget.NewLabel(fmt.Sprintf("Gewicht links: %.1f kg", session.WeightLeft)),
			widget.NewLabel(fmt.Sprintf("Gewicht rechts: %.1f kg", session.WeightRight)),
		)

		deleteBtn := widget.NewButtonWithIcon("Löschen", theme.DeleteIcon(), func() {
			dialog.ShowConfirm("Eintrag löschen", "Möchtest du diesen Eintrag wirklich löschen?", func(ok bool) {
				if ok {
					err := db.DeleteTraining(session.ID)
					if err != nil {
						dialog.ShowError(err, parent)
						return
					}
					refreshData()
				}
			}, parent)
		})

		editBtn := widget.NewButtonWithIcon("Bearbeiten", theme.DocumentCreateIcon(), func() {
			setsEntry := widget.NewEntry()
			setsEntry.SetText(fmt.Sprintf("%d", session.Sets))

			durationEntry := widget.NewEntry()
			durationEntry.SetText(fmt.Sprintf("%d", session.Duration)) // Dauer in Sekunden

			repsEntry := widget.NewEntry()
			repsEntry.SetText(fmt.Sprintf("%d", session.RepsPerSet))

			weightLeftEntry := widget.NewEntry()
			weightLeftEntry.SetText(fmt.Sprintf("%.1f", session.WeightLeft))

			weightRightEntry := widget.NewEntry()
			weightRightEntry.SetText(fmt.Sprintf("%.1f", session.WeightRight))

			form := &widget.Form{
				Items: []*widget.FormItem{
					{Text: "Sätze", Widget: setsEntry},
					{Text: "Dauer (Sekunden)", Widget: durationEntry},
					{Text: "Reps/Satz", Widget: repsEntry},
					{Text: "Gewicht links (kg)", Widget: weightLeftEntry},
					{Text: "Gewicht rechts (kg)", Widget: weightRightEntry},
				},
				OnSubmit: func() {
					var (
						sets, reps, duration    int
						weightLeft, weightRight float64
						err                     error
					)
					if sets, err = strconv.Atoi(setsEntry.Text); err != nil {
						dialog.ShowError(fmt.Errorf("Ungültige Sätze-Zahl"), parent)
						return
					}
					if duration, err = strconv.Atoi(durationEntry.Text); err != nil {
						dialog.ShowError(fmt.Errorf("Ungültige Dauer"), parent)
						return
					}
					if reps, err = strconv.Atoi(repsEntry.Text); err != nil {
						dialog.ShowError(fmt.Errorf("Ungültige Wiederholungszahl"), parent)
						return
					}
					if weightLeft, err = strconv.ParseFloat(weightLeftEntry.Text, 64); err != nil {
						dialog.ShowError(fmt.Errorf("Ungültiges Gewicht links"), parent)
						return
					}
					if weightRight, err = strconv.ParseFloat(weightRightEntry.Text, 64); err != nil {
						dialog.ShowError(fmt.Errorf("Ungültiges Gewicht rechts"), parent)
						return
					}

					session.Sets = int64(sets)
					session.Duration = int64(duration)
					session.RepsPerSet = int64(reps)
					session.WeightLeft = weightLeft
					session.WeightRight = weightRight

					if err := db.UpdateTraining(&session); err != nil {
						dialog.ShowError(err, parent)
						return
					}
					dialog.ShowInformation("Erfolg", "Trainingseintrag aktualisiert.", parent)
					refreshData()
				},
			}

			dialog.ShowForm("Training bearbeiten", "Speichern", "Abbrechen", form.Items, func(ok bool) {
			}, parent)
		})

		btns := container.NewHBox(editBtn, deleteBtn)

		dialog.ShowCustom("Training Details", "Schließen", container.NewVBox(details, btns), parent)
	}

	refreshData = func() {
		var err error
		history, err = db.GetHistory()
		if err != nil {
			log.Printf("Fehler beim Laden der Historie: %v", err)
			dialog.ShowError(err, parent)
			return
		}
		if len(history) == 0 {
			placeholder.Show()
			list.Hide()
		} else {
			placeholder.Hide()
			list.Show()
		}
		list.Refresh()
	}

	header := container.NewGridWithColumns(4,
		widget.NewLabelWithStyle("Datum", fyne.TextAlignCenter, fyne.TextStyle{Bold: true}),
		widget.NewLabelWithStyle("Sätze", fyne.TextAlignCenter, fyne.TextStyle{Bold: true}),
		widget.NewLabelWithStyle("Dauer", fyne.TextAlignCenter, fyne.TextStyle{Bold: true}),
		widget.NewLabelWithStyle("Reps/Satz", fyne.TextAlignCenter, fyne.TextStyle{Bold: true}),
	)

	toolbar := widget.NewToolbar(widget.NewToolbarAction(theme.ViewRefreshIcon(), refreshData))
	content := container.NewVBox(header, container.NewStack(list, container.NewCenter(placeholder)))
	layout := container.NewBorder(toolbar, nil, nil, nil, content)

	if layout.Visible() {
		refreshData()
	}
	return layout
}