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

package main

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

	"certmanager/internal/config"
	"certmanager/internal/database"
	"certmanager/internal/descriptor"
	"certmanager/pkg/logger"

	"gopkg.in/yaml.v3"
)

func main() {
	var err error
	util := NewUtil()
	err = util.Exec()
	if err != nil {
		fmt.Printf("Exec error: %s\n", err)
	}
}

type Util struct {
	conf *config.Config
	db   *database.Database
	log  *logger.Logger

	filename         string
	deleteAllRecords bool
}

func NewUtil() *Util {
	var util Util
	util.log = logger.NewLogger("logic")
	return &util
}

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

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

	help := func() {
		fmt.Println("")
		fmt.Printf("Usage: %s [option]\n", exeName)
		fmt.Printf("\n")
		flag.PrintDefaults()
		fmt.Printf("\n")
	}

	flag.Usage = help

	flag.StringVar(&util.filename, "file", util.filename, "dump file name")
	flag.BoolVar(&util.deleteAllRecords, "deleteAllRecords", util.deleteAllRecords, "delete all existing zones before restoring")

	flag.Parse()
	return err
}

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

	const timeout = 30 * time.Second
	ctx, _ := context.WithTimeout(context.Background(), timeout)

	err = util.RestoreRecords(ctx)

	type ErrorDescr struct {
		Error   bool   `json:"error,omitempty"`
		Message string `json:"errorMessage,omitempty" yaml:"errorMessage,omitempty"`
	}

	errDescr := ErrorDescr{}
	if err != nil {
		errDescr.Error = true
		errDescr.Message = fmt.Sprintf("%v", err)
	}

	errBytes, _ := yaml.Marshal(errDescr)
	fmt.Printf("%s\n", string(errBytes))

	return err
}

func (util *Util) RestoreRecords(ctx context.Context) 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
	}

	db, err := database.NewDatabase(util.conf.DataDir)
	if err != nil {
		return err
	}
	util.db = db

	err = util.db.InitDatabase(ctx)
	if err != nil {
		return err
	}

	file := os.Stdin
	if util.filename != "" {
		file, err = os.Open(util.filename)
		if err != nil {
			return err
		}
		defer file.Close()
	}

	buffer := bytes.NewBuffer(nil)
	_, err = io.Copy(buffer, file)
	if err != nil {
		return err
	}

	dump := descriptor.Dump{}

	err = yaml.Unmarshal(buffer.Bytes(), &dump)
	if err != nil {
		return err
	}

	if util.deleteAllRecords {
		err = util.db.CleanDatabase(ctx)
		if err != nil {
			return err
		}
	}

	for _, issuer := range dump.Issuers {
		util.log.Infof("Insert issuer %s", issuer.Name)
		err = util.db.InsertIssuer(ctx, &issuer)
		if err != nil {
			util.log.Errorf("Insert issuer error: %v", err)
		}
	}
	for _, service := range dump.Services {
		util.log.Infof("Insert service %s", service.Name)
		err = util.db.InsertService(ctx, &service)
		if err != nil {
			util.log.Errorf("Insert service error: %v", err)
		}
	}
	for _, account := range dump.Accounts {
		util.log.Infof("Insert account %s", account.Username)
		err = util.db.InsertAccount(ctx, &account)
		if err != nil {
			util.log.Errorf("Insert account error: %v", err)
		}
	}
	for _, grant := range dump.Grants {
		util.log.Infof("Insert grant %s for account %d", grant.Operation, grant.AccountID)
		err = util.db.InsertGrant(ctx, &grant)
		if err != nil {
			util.log.Errorf("Insert account error: %v", err)
		}
	}

	return err
}