package operator

import (
	"context"
	"fmt"

	"mstore/app/descr"
	"mstore/pkg/auxpwd"
	"mstore/pkg/auxtool"
	"mstore/pkg/auxuuid"
)

func (oper *Operator) ValidateAcount(ctx context.Context, username, password string) (bool, string, error) {
	var err error
	var accountID string
	valid := false

	//oper.WaitRestoring()

	accountExists, accountDescr, err := oper.mdb.GetAccountByUsername(ctx, username)
	if !accountExists {
		err := fmt.Errorf("Account not exists")
		return valid, accountID, err
	}
	if !auxpwd.PasswordMatch([]byte(password), accountDescr.Passhash) {
		err := fmt.Errorf("Login data mismatch")
		return valid, accountID, err
	}
	valid = true
	accountID = accountDescr.ID
	return valid, accountID, err
}

type CreateAccountParams struct {
	Username string
	Password string
}
type CreateAccountResult struct {
	AccountID string `json:"accountId"`
}

func (oper *Operator) CreateAccount(ctx context.Context, params *CreateAccountParams) (*CreateAccountResult, error) {
	var err error
	res := &CreateAccountResult{}

	if params.Username == "" {
		err := fmt.Errorf("Empty username parameters")
		return res, err
	}

	if params.Password == "" {
		err := fmt.Errorf("Empty password parameter")
		return res, err
	}

	accountExists, _, err := oper.mdb.GetAccountByUsername(ctx, params.Username)
	if err != nil {
		return res, err
	}
	if accountExists {
		err := fmt.Errorf("Account with thist name already exists")
		return res, err
	}
	now := auxtool.TimeNow()
	passhash := auxpwd.MakeSHA256Hash([]byte(params.Password))
	accountDescr := &descr.Account{
		ID:        auxuuid.NewUUID(),
		Username:  params.Username,
		Passhash:  passhash,
		Disabled:  false,
		CreatedAt: now,
		UpdatedAt: now,
	}
	err = oper.mdb.InsertAccount(ctx, accountDescr)
	if err != nil {
		return res, err
	}
	res.AccountID = accountDescr.ID
	return res, err
}

type UpdateAccountParams struct {
	Username    string
	AccountID   string
	NewUsername string
	NewPassword string
	Disabled    bool
}
type UpdateAccountResult struct{}

func (oper *Operator) UpdateAccount(ctx context.Context, params *UpdateAccountParams) (*UpdateAccountResult, error) {
	var err error
	res := &UpdateAccountResult{}

	var accountDescr *descr.Account
	var accountExists bool
	switch {
	case params.AccountID != "":
		accountExists, accountDescr, err = oper.mdb.GetAccountByID(ctx, params.AccountID)
		if err != nil {
			return res, err
		}
	case params.Username != "":
		accountExists, accountDescr, err = oper.mdb.GetAccountByUsername(ctx, params.Username)
		if err != nil {
			return res, err
		}
	}
	if !accountExists {
		err := fmt.Errorf("Account with this is or name dont exists")
		return res, err
	}
	now := auxtool.TimeNow()
	if params.NewUsername != "" {
		accountDescr.UpdatedAt = now
		accountDescr.Username = params.NewUsername
	}
	if params.NewPassword != "" {
		accountDescr.UpdatedAt = now
		passhash := auxpwd.MakeSHA256Hash([]byte(params.NewPassword))
		accountDescr.Passhash = passhash
	}
	if params.Disabled != accountDescr.Disabled {
		accountDescr.UpdatedAt = now
		accountDescr.Disabled = params.Disabled
	}

	err = oper.mdb.UpdateAccountByID(ctx, accountDescr.ID, accountDescr)
	if err != nil {
		return res, err
	}
	return res, err
}

type DeleteAccountParams struct {
	Username  string
	AccountID string
}
type DeleteAccountResult struct{}

func (oper *Operator) DeleteAccount(ctx context.Context, params *DeleteAccountParams) (*DeleteAccountResult, error) {
	var err error
	res := &DeleteAccountResult{}

	var accountDescr *descr.Account
	var accountExists bool
	switch {
	case params.AccountID != "":
		accountExists, accountDescr, err = oper.mdb.GetAccountByID(ctx, params.AccountID)
		if err != nil {
			return res, err
		}
	case params.Username != "":
		accountExists, accountDescr, err = oper.mdb.GetAccountByUsername(ctx, params.Username)
		if err != nil {
			return res, err
		}
	}
	if !accountExists {
		err := fmt.Errorf("Account with this is or name dont exists")
		return res, err
	}

	err = oper.mdb.DeleteAllGrantsForAccountID(ctx, accountDescr.ID)
	if err != nil {
		return res, err
	}
	err = oper.mdb.DeleteAccountByID(ctx, accountDescr.ID)
	if err != nil {
		return res, err
	}
	return res, err
}

type ListAccountsParams struct{}
type ListAccountsResult struct {
	Accounts []descr.AccountShortDescr `json:"accounts"`
}

func (oper *Operator) ListAccounts(ctx context.Context, params *ListAccountsParams) (*ListAccountsResult, error) {
	var err error
	res := &ListAccountsResult{
		Accounts: make([]descr.AccountShortDescr, 0),
	}

	accountDescrs, err := oper.mdb.ReducedListAccounts(ctx)
	if err != nil {
		return res, err
	}
	for _, accountDescr := range accountDescrs {
		accountShortDescr := descr.AccountShortDescr{
			Username:  accountDescr.Username,
			Disabled:  accountDescr.Disabled,
			CreatedAt: accountDescr.CreatedAt,
			UpdatedAt: accountDescr.UpdatedAt,
			Grants:    make([]descr.GrantShortDescr, 0),
		}
		grantDescrs, err := oper.mdb.ListGrantsByAccountID(ctx, accountDescr.ID)
		if err != nil {
			return res, err
		}
		for _, grantDescrs := range grantDescrs {
			grantShortDescrs := descr.GrantShortDescr{
				Operation: grantDescrs.Operation,
				CreatedAt: grantDescrs.CreatedAt,
			}
			accountShortDescr.Grants = append(accountShortDescr.Grants, grantShortDescrs)
		}
		res.Accounts = append(res.Accounts, accountShortDescr)
	}
	return res, err
}

type GetAccountParams struct {
	Username  string
	AccountID string
}
type GetAccountResult struct {
	AccountDescr *descr.AccountShortDescr
}

func (oper *Operator) GetAccount(ctx context.Context, params *GetAccountParams) (*GetAccountResult, error) {
	var err error
	res := &GetAccountResult{}

	var accountDescr *descr.Account
	var accountExists bool
	switch {
	case params.AccountID != "":
		accountExists, accountDescr, err = oper.mdb.GetAccountByID(ctx, params.Username)
		if err != nil {
			return res, err
		}
	case params.Username != "":
		accountExists, accountDescr, err = oper.mdb.GetAccountByUsername(ctx, params.Username)
		if err != nil {
			return res, err
		}
	}
	if !accountExists {
		err := fmt.Errorf("Account with this is or name dont exists")
		return res, err
	}
	accountShortDescr := &descr.AccountShortDescr{
		Username:  accountDescr.Username,
		Disabled:  accountDescr.Disabled,
		CreatedAt: accountDescr.CreatedAt,
		UpdatedAt: accountDescr.UpdatedAt,
		Grants:    make([]descr.GrantShortDescr, 0),
	}
	grantDescrs, err := oper.mdb.ListGrantsByAccountID(ctx, accountDescr.ID)
	if err != nil {
		return res, err
	}
	for _, grantDescrs := range grantDescrs {
		grantShortDescrs := descr.GrantShortDescr{
			Operation: grantDescrs.Operation,
			CreatedAt: grantDescrs.CreatedAt,
		}
		accountShortDescr.Grants = append(accountShortDescr.Grants, grantShortDescrs)
	}

	res.AccountDescr = accountShortDescr
	return res, err
}