package main

import (
	"fmt"
	"log"
	"os/exec"

	"github.com/charmbracelet/bubbles/progress"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/huh"
	"github.com/charmbracelet/lipgloss"
	"github.com/spf13/cobra"
	"github.com/spf13/viper"
)

var (
	currentPkgNameStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("211"))
	doneStyle           = lipgloss.NewStyle().Margin(1, 2)
	checkMark           = lipgloss.NewStyle().Foreground(lipgloss.Color("42")).SetString("✓")
	unavailablePackages []string
)

type installedItemMsg string

type installedPkgMsg string

func run(cmd *cobra.Command, args []string) {
	os, err := getLinuxDistribution()
	if err != nil {
		log.Fatal(err)
	}

	sudoPassword, err := getSudoPassword()
	if err != nil {
		log.Fatal(err)
	}

	var cfg Config
	if err := viper.Unmarshal(&cfg); err != nil {
		log.Fatalf("Fehler beim Lesen der Konfiguration: %v", err)
	}

	form := huh.NewForm(
		huh.NewGroup(
			huh.NewConfirm().
				Title("Möchten Sie eine headless Installation durchführen?").
				Value(&cfg.Headless),
		),
	).WithTheme(huh.ThemeCatppuccin())

	if err := form.Run(); err != nil {
		log.Fatalf("Fehler bei der Benutzerabfrage: %v", err)
	}

	var packages []string
	packages = append(packages, cfg.Packages.Headless...)
	if !cfg.Headless {
		packages = append(packages, cfg.Packages.NonHeadless...)
	}

	unavailablePackages = []string{}

	m := newModel(packages, sudoPassword, os)
	p := tea.NewProgram(m)
	if _, err := p.Run(); err != nil {
		log.Fatal(err)
	}

	printUnavailablePackages()

	var installSpecial bool
	form = huh.NewForm(
		huh.NewGroup(
			huh.NewConfirm().
				Title("Möchten Sie die speziellen Pakete (Go, Rust, Pipx) installieren?").
				Value(&installSpecial),
		),
	).WithTheme(huh.ThemeCatppuccin())

	err = form.Run()
	if err != nil {
		log.Fatal(err)
	}

	if installSpecial {
		if err := installBuildEssentials(os, sudoPassword); err != nil {
			log.Printf("Warnung: %v", err)
		}
		sm := newSpecialSoftwareModel(sudoPassword)
		p = tea.NewProgram(sm)
		if _, err := p.Run(); err != nil {
			log.Fatal(err)
		}
	}

	if len(cfg.SpecialPackages.Go) > 0 || len(cfg.SpecialPackages.Cargo) > 0 || len(cfg.SpecialPackages.Pipx) > 0 {
		var allSpecialPkgs []struct {
			typ     string
			name    string
			command string
		}

		for _, pkg := range cfg.SpecialPackages.Go {
			allSpecialPkgs = append(allSpecialPkgs, struct {
				typ     string
				name    string
				command string
			}{"go", pkg, "go install " + pkg + "@latest"})
		}

		for _, pkg := range cfg.SpecialPackages.Cargo {
			allSpecialPkgs = append(allSpecialPkgs, struct {
				typ     string
				name    string
				command string
			}{"cargo", pkg, "cargo install " + pkg})
		}

		for _, pkg := range cfg.SpecialPackages.Pipx {
			allSpecialPkgs = append(allSpecialPkgs, struct {
				typ     string
				name    string
				command string
			}{"pipx", pkg, "pipx install " + pkg})
		}

		if len(allSpecialPkgs) > 0 {
			fmt.Println("\nInstalliere spezielle Pakete...")
			p := progress.New(
				progress.WithDefaultGradient(),
				progress.WithWidth(40),
			)

			for i, pkg := range allSpecialPkgs {
				p.SetPercent(float64(i) / float64(len(allSpecialPkgs)))
				fmt.Printf("Installiere %s Paket: %s\n", pkg.typ, pkg.name)

				cmd := exec.Command("sh", "-c", pkg.command)
				if err := cmd.Run(); err != nil {
					log.Printf("Fehler bei der Installation von %s: %v", pkg.name, err)
					continue
				}
			}
		}
	}
	if cfg.Flatpak.Enable {
		fmt.Println("\nKonfiguriere Flatpak...")
		if err := installFlatpak(os, sudoPassword); err != nil {
			log.Printf("Warnung bei Flatpak-Installation: %v", err)
		}

		if err := addFlatpakRemotes(cfg.Flatpak.Remotes); err != nil {
			log.Printf("Warnung bei Flatpak-Remotes: %v", err)
		}

		if err := installFlatpakPackages(cfg.Flatpak.Packages); err != nil {
			log.Printf("Warnung bei Flatpak-Paketen: %v", err)
		}
	}
	if cfg.Dotfiles.Enable {
		fmt.Println("\nKonfiguriere Dotfiles...")
		if err := setupDotfiles(cfg.Dotfiles); err != nil {
			log.Printf("Warnung bei Dotfiles-Setup: %v", err)
		}
	}
}