package keeper

import (
	"fmt"

	sdk "github.com/cosmos/cosmos-sdk/types"
	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"

	"github.com/kava-labs/kava/x/earn/types"
)

// Withdraw removes the amount of supplied tokens from a vault and transfers it
// back to the account.
func (k *Keeper) Withdraw(
	ctx sdk.Context,
	from sdk.AccAddress,
	wantAmount sdk.Coin,
	withdrawStrategy types.StrategyType,
) (sdk.Coin, error) {
	// Get AllowedVault, if not found (not a valid vault), return error
	allowedVault, found := k.GetAllowedVault(ctx, wantAmount.Denom)
	if !found {
		return sdk.Coin{}, types.ErrInvalidVaultDenom
	}

	if wantAmount.IsZero() {
		return sdk.Coin{}, types.ErrInsufficientAmount
	}

	// Check if withdraw strategy is supported by vault
	if !allowedVault.IsStrategyAllowed(withdrawStrategy) {
		return sdk.Coin{}, types.ErrInvalidVaultStrategy
	}

	// Check if VaultRecord exists
	vaultRecord, found := k.GetVaultRecord(ctx, wantAmount.Denom)
	if !found {
		return sdk.Coin{}, types.ErrVaultRecordNotFound
	}

	// Get account share record for the vault
	vaultShareRecord, found := k.GetVaultShareRecord(ctx, from)
	if !found {
		return sdk.Coin{}, types.ErrVaultShareRecordNotFound
	}

	withdrawShares, err := k.ConvertToShares(ctx, wantAmount)
	if err != nil {
		return sdk.Coin{}, fmt.Errorf("failed to convert assets to shares: %w", err)
	}

	accCurrentShares := vaultShareRecord.Shares.AmountOf(wantAmount.Denom)
	// Check if account is not withdrawing more shares than they have
	if accCurrentShares.LT(withdrawShares.Amount) {
		return sdk.Coin{}, sdkerrors.Wrapf(
			types.ErrInsufficientValue,
			"account has less %s vault shares than withdraw shares, %s < %s",
			wantAmount.Denom,
			accCurrentShares,
			withdrawShares.Amount,
		)
	}

	// Convert shares to amount to get truncated true share value
	withdrawAmount, err := k.ConvertToAssets(ctx, withdrawShares)
	if err != nil {
		return sdk.Coin{}, fmt.Errorf("failed to convert shares to assets: %w", err)
	}

	accountValue, err := k.GetVaultAccountValue(ctx, wantAmount.Denom, from)
	if err != nil {
		return sdk.Coin{}, fmt.Errorf("failed to get account value: %w", err)
	}

	// Check if withdrawAmount > account value
	if withdrawAmount.Amount.GT(accountValue.Amount) {
		return sdk.Coin{}, sdkerrors.Wrapf(
			types.ErrInsufficientValue,
			"account has less %s vault value than withdraw amount, %s < %s",
			withdrawAmount.Denom,
			accountValue.Amount,
			withdrawAmount.Amount,
		)
	}

	// Get the strategy for the vault
	strategy, err := k.GetStrategy(allowedVault.Strategies[0])
	if err != nil {
		return sdk.Coin{}, err
	}

	// Not necessary to check if amount denom is allowed for the strategy, as
	// there would be no vault record if it weren't allowed.

	// Withdraw the withdrawAmount from the strategy
	if err := strategy.Withdraw(ctx, withdrawAmount); err != nil {
		return sdk.Coin{}, fmt.Errorf("failed to withdraw from strategy: %w", err)
	}

	// Send coins back to account, must withdraw from strategy first or the
	// module account may not have any funds to send.
	if err := k.bankKeeper.SendCoinsFromModuleToAccount(
		ctx,
		types.ModuleName,
		from,
		sdk.NewCoins(withdrawAmount),
	); err != nil {
		return sdk.Coin{}, err
	}

	// Check if new account balance of shares results in account share value
	// of < 1 of a sdk.Coin. This share value is not able to be withdrawn and
	// should just be removed.
	isDust, err := k.ShareIsDust(
		ctx,
		vaultShareRecord.Shares.GetShare(withdrawAmount.Denom).Sub(withdrawShares),
	)
	if err != nil {
		return sdk.Coin{}, err
	}

	if isDust {
		// Modify withdrawShares to subtract entire share balance for denom
		// This does not modify the actual withdraw coin amount as the
		// difference is < 1coin.
		withdrawShares = vaultShareRecord.Shares.GetShare(withdrawAmount.Denom)
	}

	// Call hook before record is modified
	k.BeforeVaultDepositModified(ctx, wantAmount.Denom, from, vaultRecord.TotalShares.Amount)

	// Decrement VaultRecord and VaultShareRecord supplies - must delete same
	// amounts
	vaultShareRecord.Shares = vaultShareRecord.Shares.Sub(withdrawShares)
	vaultRecord.TotalShares = vaultRecord.TotalShares.Sub(withdrawShares)

	// Update VaultRecord and VaultShareRecord, deletes if zero supply
	k.UpdateVaultRecord(ctx, vaultRecord)
	k.UpdateVaultShareRecord(ctx, vaultShareRecord)

	ctx.EventManager().EmitEvent(
		sdk.NewEvent(
			types.EventTypeVaultWithdraw,
			sdk.NewAttribute(types.AttributeKeyVaultDenom, withdrawAmount.Denom),
			sdk.NewAttribute(types.AttributeKeyOwner, from.String()),
			sdk.NewAttribute(types.AttributeKeyShares, withdrawShares.Amount.String()),
			sdk.NewAttribute(sdk.AttributeKeyAmount, withdrawAmount.Amount.String()),
		),
	)

	return withdrawAmount, nil
}

// WithdrawFromModuleAccount removes the amount of supplied tokens from a vault and transfers it
// back to the module account. The module account must be unblocked from receiving transfers.
func (k *Keeper) WithdrawFromModuleAccount(
	ctx sdk.Context,
	from string,
	wantAmount sdk.Coin,
	withdrawStrategy types.StrategyType,
) (sdk.Coin, error) {
	// Ensure the module account exists to prevent SendCoins from creating a new non-module account.
	acc := k.accountKeeper.GetModuleAccount(ctx, from)
	if acc == nil {
		return sdk.Coin{}, fmt.Errorf("module account not found: %s", from)
	}
	return k.Withdraw(ctx, acc.GetAddress(), wantAmount, withdrawStrategy)
}