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

package main

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

	"mbase/app/config"
	"mbase/app/maindb"
	"mbase/app/descr"
	"mbase/app/logic"

	"sigs.k8s.io/yaml"
)

const (
	rcFilename = ".certmanager.yaml"

	helpCmd = "help"

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

	setGrantCmd    = "setGrant"
	deleteGrantCmd = "deleteGrant"

	initDatabaseCmd = "initDatabase"
	seedAccountCmd  = "seedAccount"
)

func main() {
	var err error
	util := NewUtil()
	err = util.Build()
	if err != nil {
		fmt.Printf("Build error: %v\n", err)
		os.Exit(1)
	}
	err = util.Exec()
	if err != nil {
		fmt.Printf("Exec error: %v\n", err)
		os.Exit(1)
	}
	os.Exit(0)
}

type Util struct {
	subCmd     string
	cmdTimeout int64

	conf  *config.Config
	lg    *logic.Logic
	db    *maindb.Database
	state descr.Server
	sfile string

	accessUsername string
	accessPassword string
	accountID      int64
	username       string
	password       string
	disable        bool
	newUsername    string
	newPassword    string
	operation      string
	quiet          bool
}

func NewUtil() *Util {
	var util Util
	util.cmdTimeout = 120
	return &util
}

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

	exeName := filepath.Base(os.Args[0])

	flag.Int64Var(&util.cmdTimeout, "timeout", util.cmdTimeout, "command execution timeout")
	flag.StringVar(&util.accessUsername, "user", util.accessUsername, "access login")
	flag.StringVar(&util.accessPassword, "pass", util.accessPassword, "access password")
	flag.BoolVar(&util.quiet, "quiet", util.quiet, "don't print result")

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

		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:]
	}

	util.subCmd = subCmd

	switch subCmd {
	case helpCmd:
		help()
		return errors.New("Unknown command")

	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 initDatabaseCmd:
		flagSet := flag.NewFlagSet(initDatabaseCmd, 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 seedAccountCmd:
		flagSet := flag.NewFlagSet(seedAccountCmd, 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

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

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

	util.conf = config.NewConfig()
	err = util.conf.ReadFile()
	if err != nil {
		return err
	}
	err = util.conf.ReadEnv()
	if err != nil {
		return err
	}

	util.sfile = filepath.Join(util.conf.DataDir, "certmanager.yaml")

	db, err := maindb.NewDatabase(util.conf.DataDir)
	if err != nil {
		return err
	}
	err = db.OpenDatabase()
	if err != nil {
		return err
	}
	util.db = db
	logicConfig := &logic.LogicConfig{
		Database: util.db,
	}
	util.lg, err = logic.NewLogic(logicConfig)
	if err != nil {
		return err
	}
	return err
}

type Response struct {
	Command string   `json:"command"             yaml:"command"`
	Args    []string `json:"args"                yaml:"args"`
	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 initDatabaseCmd:
		res, err = util.InitDatabase(ctx)
	case seedAccountCmd:
		res, err = util.SeedAccount(ctx)
	default:
		authOk, operID, localErr := util.lg.ValidateAcount(ctx, util.accessUsername, util.accessPassword)
		if err != nil {
			err = localErr
			goto exit
		}
		if !authOk {
			err = fmt.Errorf("Incorrect username or password")
			goto exit
		}
		switch util.subCmd {
		case createAccountCmd:
			res, err = util.CreateAccount(ctx, operID)
		case updateAccountCmd:
			res, err = util.UpdateAccount(ctx, operID)
		case listAccountsCmd:
			res, err = util.ListAccounts(ctx, operID)
		case deleteAccountCmd:
			res, err = util.DeleteAccount(ctx, operID)
		case setGrantCmd:
			res, err = util.SetGrant(ctx, operID)
		case deleteGrantCmd:
			res, err = util.DeleteGrant(ctx, operID)
		default:
			err = errors.New("Unknown cli command")
		}
	}

exit:
	var resp Response
	resp.Command = util.subCmd
	resp.Args = os.Args
	if err != nil {
		resp.Error = true
		resp.Message = fmt.Sprintf("%v", err)
	} else {
		resp.Result = res
	}

	if !resp.Error && !util.quiet {
		respBytes, _ := yaml.Marshal(resp)
		fmt.Println(string(respBytes))
	}
	return err
}

type InitDatabaseRes struct{}

func (util *Util) InitDatabase(ctx context.Context) (InitDatabaseRes, error) {
	res := InitDatabaseRes{}
	// Initialize database

	// Load state
	err := util.LoadState()
	if err != nil {
		return res, err
	}
	if !util.state.DatabaseInitialized {
		if util.db == nil {
			err = fmt.Errorf("Nil db object")
			return res, err
		}
		err := util.db.InitDatabase()
		if err != nil {
			return res, err
		}
		util.state.DatabaseInitialized = true
		err = util.SaveState()
		if err != nil {
			return res, err
		}

	}
	return res, err
}

type SeedAccountRes struct{}

func (util *Util) SeedAccount(ctx context.Context) (SeedAccountRes, error) {
	// Seed accounts
	res := SeedAccountRes{}
	_, err := util.lg.SeedAccount(ctx)
	if err != nil {
		return res, err
	}
	return res, err
}

func (util *Util) LoadState() error {
	var err error
	_, err = os.Stat(util.sfile)
	if os.IsNotExist(err) {
		err = nil
		return err
	}
	file, err := os.Open(util.sfile)
	if err != nil {
		return err
	}
	defer file.Close()
	stateBytes, err := ioutil.ReadAll(file)
	if err != nil {
		return err
	}
	err = yaml.Unmarshal(stateBytes, &util.state)
	if err != nil {
		return err
	}
	return err
}

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

	file, err := os.OpenFile(util.sfile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0640)
	if err != nil {
		return err
	}
	defer file.Close()
	util.state.UpdatedAt = time.Now().Format(time.RFC3339)
	if util.state.CreatedAt == "" {
		util.state.CreatedAt = util.state.UpdatedAt
	}
	stateBytes, err := yaml.Marshal(util.state)
	if err != nil {
		return err
	}
	_, err = file.Write(stateBytes)
	if err != nil {
		return err
	}
	return err
}