package main

import (
	"flag"
	"fmt"
	"os"
	"strings"

	"go.jolheiser.com/eget/disk"
	"go.jolheiser.com/eget/forge"
	"go.jolheiser.com/eget/meta"
)

var Version = "develop"

func main() {
	base := "github.com/"
	if b, ok := os.LookupEnv("EGET_BASE"); ok {
		base = strings.TrimSuffix(b, "/") + "/"
	}

	fs := flag.NewFlagSet("eget", flag.ExitOnError)
	fs.Usage = func() {
		fmt.Fprintln(fs.Output(), "eget <package>")
		fs.PrintDefaults()
	}
	versionFlag := fs.Bool("version", false, "Show version and exit")
	fs.BoolVar(versionFlag, "v", *versionFlag, "--version")
	updateFlag := fs.Bool("update", false, "Update package")
	fs.BoolVar(updateFlag, "u", *updateFlag, "--update")
	deleteFlag := flag.Bool("delete", false, "Delete package")
	fs.BoolVar(deleteFlag, "d", *deleteFlag, "--delete")
	syncFlag := fs.Bool("sync", false, "Sync packages")
	overrideFlag := fs.String("override", "", "Override asset to look for: $OS, $ARCH, and $VERSION are available as templates")
	fs.StringVar(overrideFlag, "o", *overrideFlag, "--override")
	if err := fs.Parse(os.Args[1:]); err != nil {
		fs.Usage()
		return
	}

	if *versionFlag {
		fmt.Printf("eget %s\n", Version)
		return
	}

	if *syncFlag {
		if err := sync(); err != nil {
			panic(err)
		}
		return
	}

	if fs.NArg() < 1 {
		fs.Usage()
		return
	}

	var f forge.Forger
	var err error
	m, err := meta.Read()
	if err != nil {
		panic(err)
	}
	uri := fs.Arg(0)

	if strings.Index(uri, "/") == -1 {
		if !(*updateFlag || *deleteFlag) {
			fmt.Printf("%q was not a URI and --update/--delete was not passed\n", uri)
			return
		}

		pkg, ok := m.Packages[uri]
		if !ok {
			fmt.Printf("%q was not a URI and didn't match an installed package\n", uri)
			return
		}
		uri = pkg.Repo
	}

	if strings.Count(uri, "/") == 1 {
		uri = base + uri
	}

	f, err = forge.NewGitea(uri)
	if strings.HasPrefix(uri, "github") {
		f, err = forge.NewGitHub(uri)
	}
	if err != nil {
		panic(err)
	}

	name := uriName(uri)
	if *deleteFlag {
		if err := os.RemoveAll(disk.Path(name)); err != nil {
			panic(err)
		}
		if err := meta.Remove(name); err != nil {
			panic(err)
		}
		fmt.Printf("removed %q\n", name)
		return
	}

	asset, err := forge.LatestRelease(f, *overrideFlag)
	if err != nil {
		panic(err)
	}

	if *updateFlag {
		if strings.EqualFold(asset.Version, m.Packages[name].Version) {
			fmt.Printf("%q is up-to-date\n", name)
			return
		}
		if err := os.RemoveAll(disk.Path(name)); err != nil {
			panic(err)
		}
	}

	if err := disk.Install(name, asset); err != nil {
		panic(err)
	}

	if err := meta.Upsert(name, uri, asset.Version, asset.Name); err != nil {
		panic(err)
	}

	verb := "installed"
	if *updateFlag {
		verb = "updated"
	}
	fmt.Printf("%s %q\n", verb, uri)
}

func uriName(uri string) string {
	parts := strings.FieldsFunc(uri, func(r rune) bool { return r == '/' })
	return parts[len(parts)-1]
}

func sync() error {
	m, err := meta.Read()
	if err != nil {
		return err
	}

	var f forge.Forger
	for name, pkg := range m.Packages {
		fmt.Printf("syncing %q\n", name)
		if err := os.RemoveAll(disk.Path(name)); err != nil {
			return err
		}
		f, err = forge.NewGitea(pkg.Repo)
		if strings.HasPrefix(pkg.Repo, "github") {
			f, err = forge.NewGitHub(pkg.Repo)
		}
		if err != nil {
			return err
		}

		asset, err := forge.TagRelease(f, pkg.Version, pkg.Asset)
		if err != nil {
			return err
		}

		if err := disk.Install(name, asset); err != nil {
			return err
		}
	}

	return nil
}