// SPDX-FileCopyrightText: Amolith <amolith@secluded.site>
//
// SPDX-License-Identifier: AGPL-3.0-or-later

package init

import (
	"errors"
	"fmt"

	"github.com/charmbracelet/huh"

	"git.secluded.site/lune/internal/config"
)

func manageHabits(cfg *config.Config) error {
	nav := manageHabitsAsStep(cfg)
	if nav == navQuit {
		return errQuit
	}

	return nil
}

// manageHabitsAsStep runs habits management as a wizard step with Back/Next navigation.
func manageHabitsAsStep(cfg *config.Config) wizardNav {
	for {
		options := buildHabitStepOptions(cfg.Habits)

		choice, err := runListSelect(
			"Habits",
			"Track habits from the command line.",
			options,
		)
		if err != nil {
			return navQuit
		}

		switch choice {
		case choiceBack:
			return navBack
		case choiceNext:
			return navNext
		case choiceAdd:
			if err := addHabit(cfg); errors.Is(err, errQuit) {
				return navQuit
			}
		default:
			idx, ok := parseEditIndex(choice)
			if !ok {
				continue
			}

			if err := manageHabitActions(cfg, idx); errors.Is(err, errQuit) {
				return navQuit
			}
		}
	}
}

func buildHabitStepOptions(habits []config.Habit) []huh.Option[string] {
	options := []huh.Option[string]{
		huh.NewOption("Add new habit", choiceAdd),
	}

	for idx, habit := range habits {
		label := fmt.Sprintf("%s (%s)", habit.Name, habit.Key)
		options = append(options, huh.NewOption(label, fmt.Sprintf("edit:%d", idx)))
	}

	options = append(options,
		huh.NewOption("← Back", choiceBack),
		huh.NewOption("Next →", choiceNext),
	)

	return options
}

func addHabit(cfg *config.Config) error {
	habit, err := editHabit(nil, cfg)
	if err != nil {
		if errors.Is(err, errBack) {
			return nil
		}

		return err
	}

	cfg.Habits = append(cfg.Habits, *habit)

	return nil
}

func manageHabitActions(cfg *config.Config, idx int) error {
	if idx < 0 || idx >= len(cfg.Habits) {
		return fmt.Errorf("%w: habit %d", errIndexOutRange, idx)
	}

	habit := &cfg.Habits[idx]

	action, err := runActionSelect(fmt.Sprintf("Habit: %s (%s)", habit.Name, habit.Key), false)
	if err != nil {
		return err
	}

	switch action {
	case itemActionEdit:
		updated, err := editHabit(habit, cfg)
		if err != nil {
			if errors.Is(err, errBack) {
				return nil
			}

			return err
		}

		if updated != nil {
			cfg.Habits[idx] = *updated
		}
	case itemActionDelete:
		return deleteHabit(cfg, idx)
	case itemActionNone, itemActionGoals:
		// User cancelled or went back; goals not applicable here
	}

	return nil
}

func editHabit(existing *config.Habit, cfg *config.Config) (*config.Habit, error) {
	habit := config.Habit{}
	if existing != nil {
		habit = *existing
	}

	err := runItemForm(&habit.Name, &habit.Key, &habit.ID, itemFormConfig{
		itemType:         "habit",
		namePlaceholder:  "Study Gaelic",
		keyPlaceholder:   "gaelic",
		keyValidator:     validateHabitKey(cfg, existing),
		supportsDeepLink: false,
	})
	if err != nil {
		return nil, err
	}

	return &habit, nil
}

func validateHabitKey(cfg *config.Config, existing *config.Habit) func(string) error {
	return func(input string) error {
		if err := validateKeyFormat(input); err != nil {
			return err
		}

		for idx := range cfg.Habits {
			if existing != nil && &cfg.Habits[idx] == existing {
				continue
			}

			if cfg.Habits[idx].Key == input {
				return errKeyDuplicate
			}
		}

		return nil
	}
}

func deleteHabit(cfg *config.Config, idx int) error {
	if idx < 0 || idx >= len(cfg.Habits) {
		return fmt.Errorf("%w: habit %d", errIndexOutRange, idx)
	}

	habit := cfg.Habits[idx]

	var confirm bool

	err := huh.NewConfirm().
		Title(fmt.Sprintf("Delete habit '%s'?", habit.Name)).
		Description("This cannot be undone.").
		Affirmative("Delete").
		Negative("Cancel").
		Value(&confirm).
		Run()
	if err != nil {
		if errors.Is(err, huh.ErrUserAborted) {
			return errQuit
		}

		return err
	}

	if confirm {
		cfg.Habits = append(cfg.Habits[:idx], cfg.Habits[idx+1:]...)
	}

	return nil
}