package command

import (
	"errors"
	"flag"
	"fmt"
	"os"

	"codeberg.org/hyperreal/go-torrent-helper/almalinux"
	"codeberg.org/hyperreal/go-torrent-helper/debian"
	"codeberg.org/hyperreal/go-torrent-helper/fedora"
	"codeberg.org/hyperreal/go-torrent-helper/nixos"
	"codeberg.org/hyperreal/go-torrent-helper/parrot"
	"codeberg.org/hyperreal/go-torrent-helper/qubes"
	"codeberg.org/hyperreal/go-torrent-helper/rocky"
	"github.com/hekmon/transmissionrpc"
)

type Distro interface {
	AddNewTorrents(client *transmissionrpc.Client) error
	RemoveOldTorrents(client *transmissionrpc.Client) error
}

func NewAddCmd() *AddCmd {
	addCmd := &AddCmd{
		fs: flag.NewFlagSet("add", flag.ExitOnError),
	}

	addCmd.fs.StringVar(&addCmd.distro, "distro", "", "Distro to add torrents for")
	addCmd.fs.StringVar(&addCmd.relver, "relver", "", "Release version to add")

	return addCmd
}

func NewRemoveCmd() *RemoveCmd {
	removeCmd := &RemoveCmd{
		fs: flag.NewFlagSet("remove", flag.ExitOnError),
	}

	removeCmd.fs.StringVar(&removeCmd.distro, "distro", "", "Distro to remove torrents for")
	removeCmd.fs.StringVar(&removeCmd.relver, "relver", "", "Release version to remove")

	return removeCmd
}

type AddCmd struct {
	fs *flag.FlagSet

	distro string
	relver string
}

type RemoveCmd struct {
	fs *flag.FlagSet

	distro string
	relver string
}

func (a *AddCmd) Name() string {
	return a.fs.Name()
}

func (r *RemoveCmd) Name() string {
	return r.fs.Name()
}

func (a *AddCmd) Init(args []string) error {
	return a.fs.Parse(args)
}

func (r *RemoveCmd) Init(args []string) error {
	return r.fs.Parse(args)
}

func (a *AddCmd) Run(d Distro) error {
	client, err := transmissionrpc.New(os.Getenv("TRANSMISSION_RPC_URL"), "", "", nil)
	if err != nil {
		return err
	}

	if err := d.AddNewTorrents(client); err != nil {
		return err
	}

	return nil
}

func (r *RemoveCmd) Run(d Distro) error {
	client, err := transmissionrpc.New(os.Getenv("TRANSMISSION_RPC_URL"), "", "", nil)
	if err != nil {
		return err
	}

	if err := d.RemoveOldTorrents(client); err != nil {
		return err
	}

	return nil
}

type Runner interface {
	Init([]string) error
	Run(d Distro) error
	Name() string
}

func Root(args []string) error {
	if len(args) < 1 {
		return errors.New("You must pass a sub-command")
	}

	cmds := []Runner{
		NewAddCmd(),
		NewRemoveCmd(),
	}

	subcmd := os.Args[1]

	for _, cmd := range cmds {
		if cmd.Name() == subcmd {
			cmd.Init(os.Args[2:])

			distro := os.Args[3]
			relver := os.Args[5]

			switch distro {
			case "almalinux":
				a := &almalinux.AlmaLinux{NameSubstr: "AlmaLinux", Relver: relver}
				return cmd.Run(a)

			case "debian":
				d := &debian.Debian{NameSubstr: "debian", Relver: relver}
				return cmd.Run(d)

			case "fedora":
				f := &fedora.Fedora{NameSubstr: "Fedora", Relver: relver}
				return cmd.Run(f)

			case "nixos":
				n := &nixos.Nixos{NameSubstr: "nixos"}
				return cmd.Run(n)

			case "parrot":
				p := &parrot.Parrot{NameSubstr: "Parrot", Relver: relver}
				return cmd.Run(p)

			case "qubes":
				q := &qubes.Qubes{NameSubstr: "Qubes", Relver: relver}
				return cmd.Run(q)

			case "rocky":
				r := &rocky.Rocky{NameSubstr: "Rocky", Relver: relver}
				return cmd.Run(r)

			default:
				return fmt.Errorf("Unknown distro: %s", distro)
			}
		}
	}

	return fmt.Errorf("Unknown subcommand: %s", subcmd)
}