ginie/internal/install/install.go

package install

import (
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"strings"

	"gitea.home.musaberdem.de/musabe24/ginie/internal/repos"
)

type Installed struct {
	Name      string `json:"name"`
	Version   string `json:"version"`
	AssetName string `json:"asset"`
	AssetURL  string `json:"url"`
}

type releaseAsset struct {
	Name               string `json:"name"`
	BrowserDownloadURL string `json:"browser_download_url"`
}

func configPath() (string, error) {
	home, err := os.UserHomeDir()
	if err != nil {
		return "", err
	}

	dir := filepath.Join(home, ".config", "ginie")
	os.MkdirAll(dir, 0755)

	return filepath.Join(dir, "installed.json"), nil
}

func LoadInstalled() ([]Installed, error) {
	path, _ := configPath()
	data, err := os.ReadFile(path)

	if os.IsNotExist(err) {
		return []Installed{}, nil
	}
	if err != nil {
		return nil, err
	}

	var out []Installed
	err = json.Unmarshal(data, &out)
	return out, err
}

func SaveInstalled(list []Installed) error {
	path, _ := configPath()
	data, err := json.MarshalIndent(list, "", "  ")
	if err != nil {
		return err
	}
	return os.WriteFile(path, data, 0644)
}

func parseNameVersion(input string) (name string, version string) {
	parts := strings.Split(input, ":")
	if len(parts) == 1 {
		return parts[0], "" // keine Version
	}
	return parts[0], parts[1]
}

func Install(pkg string) error {
	name, version := parseNameVersion(pkg)

	// Repo suchen
	all, err := repos.LoadRepos()
	if err != nil {
		return err
	}

	var repo repos.Repo
	found := false
	for _, r := range all {
		if r.Name == name {
			repo = r
			found = true
			break
		}
	}
	if !found {
		return errors.New("Repo nicht gefunden. Nutze: ginie add <URL>")
	}

	// Release-API-URL
	api := ""
	if version == "" {
		api = fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/latest", repo.Owner, repo.Name)
	} else {
		api = fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/tags/%s", repo.Owner, repo.Name, version)
	}

	// API abfragen
	resp, err := http.Get(api)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return fmt.Errorf("GitHub API Fehler: %s", resp.Status)
	}

	var release struct {
		TagName string         `json:"tag_name"`
		Assets  []releaseAsset `json:"assets"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
		return err
	}

	if len(release.Assets) == 0 {
		return errors.New("Release hat keine Assets")
	}

	installedVersion := release.TagName
	if installedVersion == "" {
		installedVersion = version
	}

	var debAssets []releaseAsset
	for _, a := range release.Assets {
		if strings.HasSuffix(strings.ToLower(a.Name), ".deb") {
			debAssets = append(debAssets, a)
		}
	}

	if len(debAssets) == 0 {
		return errors.New("Release enthält keine .deb Assets")
	}

	// Asset-Auswahl
	fmt.Println("Verfügbare Assets:")
	for i, a := range debAssets {
		fmt.Printf("[%d] %s\n", i, a.Name)
	}

	fmt.Print("Wähle Asset-Nummer: ")
	var choice int
	fmt.Scan(&choice)

	if choice < 0 || choice >= len(debAssets) {
		return errors.New("Ungültige Auswahl")
	}

	asset := debAssets[choice]

	// Datei herunterladen
	fmt.Println("Lade herunter:", asset.Name)

	out, err := os.Create(asset.Name)
	if err != nil {
		return err
	}
	defer out.Close()

	dl, err := http.Get(asset.BrowserDownloadURL)
	if err != nil {
		return err
	}
	defer dl.Body.Close()

	_, err = io.Copy(out, dl.Body)
	if err != nil {
		return err
	}

	fmt.Println("Download abgeschlossen.")

	// Installation (unterstützt .deb)
	if strings.HasSuffix(asset.Name, ".deb") {
		fmt.Println("Installiere .deb Datei…")
		cmd := exec.Command("sudo", "dpkg", "-i", asset.Name)
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
		// Run the install command
		err := cmd.Run()
		if err != nil {
			fmt.Println("Package konnte nicht installiert werden.")
		}
		// Remove debian package file
		err = os.Remove(asset.Name)
		if err != nil {
			fmt.Println("Package konnte nicht gelöscht werden.")
		}
		if installedVersion == "" {
			installedVersion = "unknown"
		}
		if err := repos.SetInstalledVersion(repo.Name, installedVersion); err != nil {
			fmt.Println("Speichern der installierten Version nicht möglich.")
			return err
		}
		return nil
	}

	return errors.New("Asset-Typ wird noch nicht unterstützt")
}

func Update(pkg string) error {
	name := pkg

	all, err := repos.LoadRepos()
	if err != nil {
		return err
	}

	var repo repos.Repo
	found := false
	for _, r := range all {
		if r.Name == name {
			repo = r
			found = true
			break
		}
	}

	if !found {
		return errors.New("Repo nicht gefunden. Nutze: ginie add <URL>")
	}

	if repo.InstalledVersion == "" {
		return errors.New("Package noch nicht installiert. Nutze: ginie install " + name)
	}

	api := fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/latest", repo.Owner, repo.Name)

	resp, err := http.Get(api)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return fmt.Errorf("GitHub API Fehler: %s", resp.Status)
	}

	var release struct {
		TagName string `json:"tag_name"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
		return err
	}

	if release.TagName == "" {
		return errors.New("Keine Version im Release gefunden")
	}

	if release.TagName == repo.InstalledVersion {
		fmt.Printf("%s ist bereits auf Version %s\n", repo.Name, repo.InstalledVersion)
		return nil
	}

	fmt.Printf("Aktualisiere %s von %s auf %s\n", repo.Name, repo.InstalledVersion, release.TagName)

	return Install(fmt.Sprintf("%s:%s", repo.Name, release.TagName))
}

func UpdateAll() error {
	reposList, err := repos.LoadRepos()
	if err != nil {
		return err
	}

	var installed []repos.Repo
	for _, r := range reposList {
		if r.InstalledVersion != "" {
			installed = append(installed, r)
		}
	}

	if len(installed) == 0 {
		return errors.New("Keine installierten Pakete gefunden. Nutze: ginie install <name>")
	}

	var failed []string
	for _, r := range installed {
		fmt.Printf("Prüfe Updates für %s...\n", r.Name)
		if err := Update(r.Name); err != nil {
			failed = append(failed, fmt.Sprintf("%s: %v", r.Name, err))
		}
	}

	if len(failed) > 0 {
		return fmt.Errorf("Einige Updates fehlgeschlagen:\n%s", strings.Join(failed, "\n"))
	}

	return nil
}