package makecmd

import (
	"fmt"
	"path/filepath"
	"time"

	"github.com/spf13/cobra"
	"yizhisec.com/hsv2/forge/internal/controller/maker"
	"yizhisec.com/hsv2/forge/internal/opt"
	"yizhisec.com/hsv2/forge/pkg/model"
)

func App() *cobra.Command {
	_cmd := &cobra.Command{
		Use:   "app",
		Short: "Make Apps(user, client, gateway, mie, nginx, etc...)",
	}

	_cmd.AddCommand(
		appUser(),
		appClient(),
		appGateway(),
		appMie(),
		appOEM(),
		appFront(),
		appNginx(),
		appHelper(),
	)

	return _cmd
}

func Apps() *cobra.Command {
	var (
		_pkg     bool
		_replica int
		_vendor  string
		_version string
	)

	_cmd := &cobra.Command{
		Use:   "apps",
		Short: "Make Apps(user, client, gateway, mie, nginx, etc...)",
		PreRunE: func(cmd *cobra.Command, args []string) error {
			if model.GetVendor(_vendor) == nil {
				return fmt.Errorf("invalid vendor: %s", _vendor)
			}

			return nil
		},

		RunE: func(cmd *cobra.Command, args []string) error {
			var (
				err error
				mk  = maker.NewMaker(opt.Cfg.Make.Dir)
			)

			if err = mk.AppUser(cmd.Context(), _version, _replica); err != nil {
				return err
			}

			if err = mk.AppClient(cmd.Context(), _version, _replica); err != nil {
				return err
			}

			if err = mk.AppGateway(cmd.Context(), _version, _replica); err != nil {
				return err
			}

			if err = mk.AppMie(cmd.Context(), _version, _replica); err != nil {
				return err
			}

			if err = mk.AppFront(cmd.Context(), _version, _vendor, _replica); err != nil {
				return err
			}

			if err = mk.AppNginx(cmd.Context(), _version, _vendor, _replica, false); err != nil {
				return err
			}

			if err = mk.AppOEM(cmd.Context(), _version, _vendor, _replica); err != nil {
				return err
			}

			if err = mk.AppHelper(cmd.Context(), _version, _vendor, _replica); err != nil {
				return err
			}

			if _pkg {
				var (
					dir  = filepath.Join(opt.Cfg.Make.Dir, "app")
					_cmd = "7za a -pRrPt7Uo9WM1dkXOJmHps56T8BZY2qA4g -mhe=on apps.pkg *"
				)

				if err = mk.RunCommand(cmd.Context(), dir, _cmd); err != nil {
					return err
				}
			}

			return nil
		},
	}

	_cmd.Flags().BoolVar(&_pkg, "pkg", false, "Make upgrade pkg")
	_cmd.Flags().IntVar(&_replica, "replica-count", 2, "Replica count")
	_cmd.Flags().StringVar(&_vendor, "vendor", "standard", "Vendor name")
	_cmd.Flags().StringVar(&_version, "version", fmt.Sprintf("v2.2.0-%d", time.Now().Unix()), "Apps version, default: v2.2.0-<timestamp>")

	return _cmd
}

func appUser() *cobra.Command {
	var (
		replica  int
		_version string
	)

	_cmd := &cobra.Command{
		Use:   "user",
		Short: "Make User App",
		RunE: func(cmd *cobra.Command, args []string) error {
			mk := maker.NewMaker(opt.Cfg.Make.Dir)
			return mk.AppUser(cmd.Context(), _version, replica)
		},
	}

	_cmd.Flags().IntVar(&replica, "replica-count", 2, "Replica count")
	_cmd.Flags().StringVar(&_version, "version", fmt.Sprintf("v2.2.0-%d", time.Now().Unix()), "App user version, default: v2.2.0-<timestamp>")

	return _cmd
}

func appClient() *cobra.Command {
	var (
		replica  int
		_version string
	)

	_cmd := &cobra.Command{
		Use:   "client",
		Short: "Make Client App",
		RunE: func(cmd *cobra.Command, args []string) error {
			mk := maker.NewMaker(opt.Cfg.Make.Dir)
			return mk.AppClient(cmd.Context(), _version, replica)
		},
	}

	_cmd.Flags().IntVar(&replica, "replica-count", 2, "Replica count")
	_cmd.Flags().StringVar(&_version, "version", fmt.Sprintf("v2.2.0-%d", time.Now().Unix()), "App client version, default: v2.2.0-<timestamp>")

	return _cmd
}

func appGateway() *cobra.Command {
	var (
		replica  int
		_version string
	)

	_cmd := &cobra.Command{
		Use:   "gateway",
		Short: "Make Gateway App",
		RunE: func(cmd *cobra.Command, args []string) error {
			mk := maker.NewMaker(opt.Cfg.Make.Dir)
			return mk.AppGateway(cmd.Context(), _version, replica)
		},
	}

	_cmd.Flags().IntVar(&replica, "replica-count", 2, "Replica count")
	_cmd.Flags().StringVar(&_version, "version", fmt.Sprintf("v2.2.0-%d", time.Now().Unix()), "App gateway version, default: v2.2.0-<timestamp>")

	return _cmd
}

func appMie() *cobra.Command {
	var (
		replica  int
		_version string
	)

	_cmd := &cobra.Command{
		Use:   "mie",
		Short: "Make Mie App",
		RunE: func(cmd *cobra.Command, args []string) error {
			mk := maker.NewMaker(opt.Cfg.Make.Dir)
			return mk.AppMie(cmd.Context(), _version, replica)
		},
	}

	_cmd.Flags().IntVar(&replica, "replica-count", 2, "Replica count")
	_cmd.Flags().StringVar(&_version, "version", fmt.Sprintf("v2.2.0-%d", time.Now().Unix()), "App mie version, default: v2.2.0-<timestamp>")

	return _cmd
}

func appOEM() *cobra.Command {
	var (
		replica  int
		vendor   string
		_version string
	)

	_cmd := &cobra.Command{
		Use:   "oem",
		Short: "Make OEM App",
		RunE: func(cmd *cobra.Command, args []string) error {
			mk := maker.NewMaker(opt.Cfg.Make.Dir)
			return mk.AppOEM(cmd.Context(), _version, vendor, replica)
		},
	}

	_cmd.Flags().IntVar(&replica, "replica-count", 2, "Replica count")
	_cmd.Flags().StringVar(&vendor, "vendor", "standard", "Vendor name")
	_cmd.Flags().StringVar(&_version, "version", fmt.Sprintf("v2.2.0-%d", time.Now().Unix()), "App oem version, default: v2.2.0-<timestamp>")

	return _cmd
}

func appFront() *cobra.Command {
	var (
		replica  int
		vendor   string
		_version string
	)

	_cmd := &cobra.Command{
		Use:   "front",
		Short: "Make Front App",
		RunE: func(cmd *cobra.Command, args []string) error {
			mk := maker.NewMaker(opt.Cfg.Make.Dir)
			return mk.AppFront(cmd.Context(), _version, vendor, replica)
		},
	}

	_cmd.Flags().IntVar(&replica, "replica-count", 2, "Replica count")
	_cmd.Flags().StringVar(&vendor, "vendor", "standard", "Vendor name")
	_cmd.Flags().StringVar(&_version, "version", fmt.Sprintf("v2.2.0-%d", time.Now().Unix()), "App front version, default: v2.2.0-<timestamp>")

	return _cmd
}

func appNginx() *cobra.Command {
	var (
		replica        int
		vendor         string
		_version       string
		_include_image bool
	)

	_cmd := &cobra.Command{
		Use:   "nginx",
		Short: "Make Nginx App",
		RunE: func(cmd *cobra.Command, args []string) error {
			mk := maker.NewMaker(opt.Cfg.Make.Dir)
			return mk.AppNginx(cmd.Context(), _version, vendor, replica, _include_image)
		},
	}

	_cmd.Flags().IntVar(&replica, "replica-count", 2, "Replica count")
	_cmd.Flags().StringVar(&vendor, "vendor", "standard", "Vendor name")
	_cmd.Flags().StringVar(&_version, "version", fmt.Sprintf("v2.2.0-%d", time.Now().Unix()), "App nginx version, default: v2.2.0-<timestamp>")
	_cmd.Flags().BoolVar(&_include_image, "include-image", false, "Include image")

	return _cmd
}

func appHelper() *cobra.Command {
	var (
		_replica int
		_vendor  string
		_version string
	)

	_cmd := &cobra.Command{
		Use:   "helper",
		Short: "Make Helper App",
		RunE: func(cmd *cobra.Command, args []string) error {
			mk := maker.NewMaker(opt.Cfg.Make.Dir)
			return mk.AppHelper(cmd.Context(), _version, _vendor, _replica)
		},
	}

	_cmd.Flags().IntVar(&_replica, "replica-count", 2, "Replica count")
	_cmd.Flags().StringVar(&_vendor, "vendor", "standard", "Vendor name")
	_cmd.Flags().StringVar(&_version, "version", fmt.Sprintf("v2.2.0-%d", time.Now().Unix()), "App helper version, default: v2.2.0-<timestamp>")

	return _cmd
}