/*
 * Copyright 2024 Oleg Borodin  <borodin@unix7.org>
 */

package main

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"os"
	"os/user"
	"path/filepath"
	"time"

	"mbase/pkg/client"
	"mbase/pkg/mbctl"

	"sigs.k8s.io/yaml"
)

const (
	defaultHostname        = "localhost"
	rcFilename             = ".certmanager.yaml"
	defaultPort     uint32 = client.DefaultPort

	getHelloCmd = "getHello"
	helpCmd     = "help"

	createAccountCmd = "createAccount"
	updateAccountCmd = "updateAccount"
	deleteAccountCmd = "deleteAccount"
	listAccountsCmd  = "listAccounts"

	setGrantCmd    = "setGrant"
	deleteGrantCmd = "deleteGrant"

	getDumpCmd     = "getDump"
	restoreDumpCmd = "restoreDump"
)

func main() {
	var err error
	util := NewUtil()
	err = util.Exec()
	if err != nil {
		os.Exit(1)
	}
	os.Exit(0)
}

type Util struct {
	subCmd     string
	cmdTimeout int64
	access     client.Access
	cont       *mbctl.ControlClient

	caFilenamesList               string
	certFilename                  string
	keyFilename                   string
	issuerOrganizationName        string
	issuerOrganizationalUnitName  string
	issuerCommonName              string
	issuerID                      int64
	issuerName                    string
	signerID                      int64
	signerName                    string
	serviceOrganizationName       string
	serviceOrganizationalUnitName string
	serviceCommonName             string
	hostnameList                  string
	ipAdressesList                string
	serviceID                     int64
	serviceName                   string
	encodingKey                   string

	accountID        int64
	username         string
	password         string
	disable          bool
	newUsername      string
	newPassword      string
	operation        string
	filename         string
	deleteAllRecords bool
}

func NewUtil() *Util {
	var util Util
	util.cmdTimeout = 120
	util.access = client.Access{
		Hostname: defaultHostname,
		Port:     defaultPort,
		Username: "certmanager",
		Password: "certmanager",
	}
	return &util
}

func (util *Util) GetOpt() error {
	var err error

	homeDir := os.Getenv("HOME")
	if homeDir == "" {
		currUsr, err := user.Current()
		if err == nil {
			homeDir = currUsr.HomeDir
		}
	}
	if homeDir != "" {
		confPath := filepath.Join(homeDir, rcFilename)
		confData, err := os.ReadFile(confPath)
		if err == nil && len(confData) > 0 {
			yaml.Unmarshal(confData, &util.access)
		}
	}
	exeName := filepath.Base(os.Args[0])

	servicePort := int64(defaultPort)
	flag.Int64Var(&util.cmdTimeout, "timeout", util.cmdTimeout, "command execution timeout")
	flag.StringVar(&util.access.Hostname, "host", util.access.Hostname, "service hostname")
	flag.Int64Var(&servicePort, "port", servicePort, "service port")
	flag.StringVar(&util.access.Username, "user", util.access.Username, "access login")
	flag.StringVar(&util.access.Password, "pass", util.access.Password, "access password")

	util.access.Port = uint32(servicePort)

	help := func() {
		fmt.Println("")
		fmt.Printf("Usage: %s [option] command [command option]\n", exeName)
		fmt.Printf("\n")
		fmt.Printf("Command list: help, %s\n", getHelloCmd)
		fmt.Printf("              %s, %s, %s, %s,\n",
			createAccountCmd,
			deleteAccountCmd,
			listAccountsCmd,
			updateAccountCmd)
		fmt.Printf("              %s, %s\n",
			setGrantCmd,
			deleteGrantCmd)
		fmt.Printf("              %s, %s\n",
			getDumpCmd,
			restoreDumpCmd)

		fmt.Printf("\n")
		fmt.Printf("Global options:\n")
		flag.PrintDefaults()
		fmt.Printf("\n")
	}
	flag.Usage = help
	flag.Parse()

	args := flag.Args()

	var subCmd string
	var subArgs []string
	if len(args) > 0 {
		subCmd = args[0]
		subArgs = args[1:]
	}

	switch subCmd {
	case helpCmd:
		help()
		return errors.New("Unknown command")
	case getHelloCmd:
		flagSet := flag.NewFlagSet(getHelloCmd, flag.ExitOnError)

		flagSet.Usage = func() {
			fmt.Printf("\n")
			fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
			fmt.Printf("\n")
			fmt.Printf("The command options: none\n")
			flagSet.PrintDefaults()
			fmt.Printf("\n")
		}
		flagSet.Parse(subArgs)
		util.subCmd = subCmd

		flagSet.Parse(subArgs)

	case createAccountCmd:
		flagSet := flag.NewFlagSet(createAccountCmd, flag.ExitOnError)

		flagSet.StringVar(&util.username, "username", util.username, "user name")
		flagSet.StringVar(&util.password, "password", util.password, "user password")

		flagSet.Usage = func() {
			fmt.Printf("\n")
			fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
			fmt.Printf("\n")
			fmt.Printf("The command options: none\n")
			flagSet.PrintDefaults()
			fmt.Printf("\n")
		}
		flagSet.Parse(subArgs)
		util.subCmd = subCmd

	case deleteAccountCmd:
		flagSet := flag.NewFlagSet(deleteAccountCmd, flag.ExitOnError)

		flagSet.StringVar(&util.username, "username", util.username, "user name")
		flagSet.Int64Var(&util.accountID, "accountId", util.accountID, "account ID")

		flagSet.Usage = func() {
			fmt.Printf("\n")
			fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
			fmt.Printf("\n")
			fmt.Printf("The command options: none\n")
			flagSet.PrintDefaults()
			fmt.Printf("\n")
		}
		flagSet.Parse(subArgs)
		util.subCmd = subCmd

	case listAccountsCmd:
		flagSet := flag.NewFlagSet(listAccountsCmd, flag.ExitOnError)

		flagSet.Usage = func() {
			fmt.Printf("\n")
			fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
			fmt.Printf("\n")
			fmt.Printf("The command options: none\n")
			flagSet.PrintDefaults()
			fmt.Printf("\n")
		}
		flagSet.Parse(subArgs)
		util.subCmd = subCmd

	case updateAccountCmd:
		flagSet := flag.NewFlagSet(updateAccountCmd, flag.ExitOnError)

		flagSet.StringVar(&util.username, "username", util.username, "user name")
		flagSet.Int64Var(&util.accountID, "accountId", util.accountID, "account ID")

		flagSet.StringVar(&util.newUsername, "newUsername", util.newUsername, "new user name")
		flagSet.StringVar(&util.newPassword, "newPassword", util.newPassword, "new user password")
		flagSet.BoolVar(&util.disable, "disable", util.disable, "disable account")

		flagSet.Usage = func() {
			fmt.Printf("\n")
			fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
			fmt.Printf("\n")
			fmt.Printf("The command options: none\n")
			flagSet.PrintDefaults()
			fmt.Printf("\n")
		}
		flagSet.Parse(subArgs)
		util.subCmd = subCmd

	case setGrantCmd:
		flagSet := flag.NewFlagSet(setGrantCmd, flag.ExitOnError)

		flagSet.StringVar(&util.username, "username", util.username, "user name")
		flagSet.Int64Var(&util.accountID, "accountId", util.accountID, "account ID")
		flagSet.StringVar(&util.operation, "operation", util.operation, "grant type")

		flagSet.Usage = func() {
			fmt.Printf("\n")
			fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
			fmt.Printf("\n")
			fmt.Printf("The command options: none\n")
			flagSet.PrintDefaults()
			fmt.Printf("\n")
		}
		flagSet.Parse(subArgs)
		util.subCmd = subCmd

	case deleteGrantCmd:
		flagSet := flag.NewFlagSet(deleteGrantCmd, flag.ExitOnError)

		flagSet.StringVar(&util.username, "username", util.username, "user name")
		flagSet.Int64Var(&util.accountID, "accountId", util.accountID, "account ID")
		flagSet.StringVar(&util.operation, "operation", util.operation, "grant type")

		flagSet.Usage = func() {
			fmt.Printf("\n")
			fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
			fmt.Printf("\n")
			fmt.Printf("The command options: none\n")
			flagSet.PrintDefaults()
			fmt.Printf("\n")
		}
		flagSet.Parse(subArgs)
		util.subCmd = subCmd

	case getDumpCmd:
		flagSet := flag.NewFlagSet(getDumpCmd, flag.ExitOnError)
		flagSet.StringVar(&util.filename, "file", util.filename, "dump file name")

		flagSet.Usage = func() {
			fmt.Printf("\n")
			fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
			fmt.Printf("\n")
			fmt.Printf("The command options: none\n")
			flagSet.PrintDefaults()
			fmt.Printf("\n")
		}
		flagSet.Parse(subArgs)
		util.subCmd = subCmd

	case restoreDumpCmd:
		flagSet := flag.NewFlagSet(restoreDumpCmd, flag.ExitOnError)
		flagSet.StringVar(&util.filename, "file", util.filename, "dump file name")

		flagSet.Usage = func() {
			fmt.Printf("\n")
			fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
			fmt.Printf("\n")
			fmt.Printf("The command options: none\n")
			flagSet.PrintDefaults()
			fmt.Printf("\n")
		}
		flagSet.Parse(subArgs)
		util.subCmd = subCmd

	default:
		help()
		return errors.New("Unknown command")
	}
	return err
}

type Response struct {
	Error   bool   `json:"error"             yaml:"error"`
	Message string `json:"message,omitempty" yaml:"message,omitempty"`
	Result  any    `json:"result,omitempty"  yaml:"result,omitempty"`
}

func (util *Util) Exec() error {
	var err error
	err = util.GetOpt()
	if err != nil {
		return err
	}

	var timeout = time.Duration(util.cmdTimeout) * time.Second
	ctx, close := context.WithTimeout(context.Background(), timeout)
	defer close()

	var res any
	switch util.subCmd {
	case getHelloCmd:
		res, err = util.GetHello(ctx)

	case createAccountCmd:
		res, err = util.CreateAccount(ctx)
	case updateAccountCmd:
		res, err = util.UpdateAccount(ctx)
	case listAccountsCmd:
		res, err = util.ListAccounts(ctx)
	case deleteAccountCmd:
		res, err = util.DeleteAccount(ctx)

	case setGrantCmd:
		res, err = util.SetGrant(ctx)
	case deleteGrantCmd:
		res, err = util.DeleteGrant(ctx)

	case getDumpCmd:
		res, err = util.GetDump(ctx)
	case restoreDumpCmd:
		res, err = util.RestoreDump(ctx)

	default:
		err = errors.New("Unknown cli command")
	}

	var resp Response
	if err != nil {
		resp.Error = true
		resp.Message = fmt.Sprintf("%v", err)
	} else {
		resp.Result = res
	}
	respBytes, _ := yaml.Marshal(resp)
	fmt.Println(string(respBytes))

	return err
}

func (util *Util) GetHello(ctx context.Context) (*mbctl.GetHelloResult, error) {
	var err error
	res := &mbctl.GetHelloResult{}
	grpcConn, cont, err := client.NewClient(&util.access)
	if err != nil {
		return res, err
	}
	defer grpcConn.Close()

	params := &mbctl.GetHelloParams{}
	res, err = cont.GetHello(ctx, params)
	if err != nil {
		return res, err
	}
	return res, err
}