package keeper

import (
	sdk "github.com/cosmos/cosmos-sdk/types"
	"github.com/kava-labs/kava/x/cdp/types"
)

const (
	// factor for setting the initial value of gov tokens to sell at debt auctions -- assuming stable token is ~1 usd, this starts the auction with a price of $0.01 KAVA
	dump = 100
)

type partialDeposit struct {
	Depositor sdk.AccAddress
	Amount    sdk.Coins
	DebtShare sdk.Int
}

func newPartialDeposit(depositor sdk.AccAddress, amount sdk.Coins, ds sdk.Int) partialDeposit {
	return partialDeposit{
		Depositor: depositor,
		Amount:    amount,
		DebtShare: ds,
	}
}

type partialDeposits []partialDeposit

func (pd partialDeposits) SumCollateral() (sum sdk.Int) {
	sum = sdk.ZeroInt()
	for _, d := range pd {
		sum = sum.Add(d.Amount[0].Amount)
	}
	return
}

func (pd partialDeposits) SumDebt() (sum sdk.Int) {
	sum = sdk.ZeroInt()
	for _, d := range pd {
		sum = sum.Add(d.DebtShare)
	}
	return
}

// AuctionCollateral creates auctions from the input deposits which attempt to raise the corresponding amount of debt
func (k Keeper) AuctionCollateral(ctx sdk.Context, deposits types.Deposits, debt sdk.Int, bidDenom string) error {
	auctionSize := k.getAuctionSize(ctx, deposits[0].Amount[0].Denom)
	partialAuctionDeposits := partialDeposits{}
	totalCollateral := deposits.SumCollateral()
	for totalCollateral.GT(sdk.ZeroInt()) {
		for i, dep := range deposits {
			if dep.Amount.IsZero() {
				continue
			}
			collateralAmount := dep.Amount[0].Amount
			collateralDenom := dep.Amount[0].Denom
			// create auctions from individual deposits that are larger than the auction size
			debtChange, collateralChange, err := k.CreateAuctionsFromDeposit(ctx, dep, debt, totalCollateral, auctionSize, bidDenom)
			if err != nil {
				return err
			}
			debt = debt.Sub(debtChange)
			totalCollateral = totalCollateral.Sub(collateralChange)
			dep.Amount = sdk.NewCoins(sdk.NewCoin(collateralDenom, collateralAmount.Sub(collateralChange)))
			collateralAmount = collateralAmount.Sub(collateralChange)
			// if there is leftover collateral that is less than a lot
			if !dep.Amount.IsZero() {
				// figure out how much debt this deposit accounts for
				// (depositCollateral / totalCollateral) * totalDebtFromCDP
				debtCoveredByDeposit := (collateralAmount.Quo(totalCollateral)).Mul(debt)
				// if adding this deposit to the other partial deposits is less than a lot
				if (partialAuctionDeposits.SumCollateral().Add(collateralAmount)).LT(auctionSize) {
					// append the deposit to the partial deposits and zero out the deposit
					pd := newPartialDeposit(dep.Depositor, dep.Amount, debtCoveredByDeposit)
					partialAuctionDeposits = append(partialAuctionDeposits, pd)
					dep.Amount = sdk.NewCoins(sdk.NewCoin(collateralDenom, sdk.ZeroInt()))
				} else {
					// if the sum of partial deposits now makes a lot
					partialCollateral := sdk.NewCoins(sdk.NewCoin(collateralDenom, auctionSize.Sub(partialAuctionDeposits.SumCollateral())))
					partialAmount := partialCollateral[0].Amount
					partialDebt := (partialAmount.Quo(collateralAmount)).Mul(debtCoveredByDeposit)

					// create a partial deposit from the deposit
					partialDep := newPartialDeposit(dep.Depositor, partialCollateral, partialDebt)
					// append it to the partial deposits
					partialAuctionDeposits = append(partialAuctionDeposits, partialDep)
					// create an auction from the partial deposits
					debtChange, collateralChange, err := k.CreateAuctionFromPartialDeposits(ctx, partialAuctionDeposits, debt, totalCollateral, auctionSize, bidDenom)
					if err != nil {
						return err
					}
					debt = debt.Sub(debtChange)
					totalCollateral = totalCollateral.Sub(collateralChange)
					// reset partial deposits and update the deposit amount
					partialAuctionDeposits = partialDeposits{}
					dep.Amount = sdk.NewCoins(sdk.NewCoin(collateralDenom, collateralAmount.Sub(partialAmount)))
				}
			}
			deposits[i] = dep
			totalCollateral = deposits.SumCollateral()
		}
	}
	if partialAuctionDeposits.SumCollateral().GT(sdk.ZeroInt()) {
		_, _, err := k.CreateAuctionFromPartialDeposits(ctx, partialAuctionDeposits, debt, totalCollateral, partialAuctionDeposits.SumCollateral(), bidDenom)
		if err != nil {
			return err
		}
	}
	return nil
}

// CreateAuctionsFromDeposit creates auctions from the input deposit until there is less than auctionSize left on the deposit
func (k Keeper) CreateAuctionsFromDeposit(ctx sdk.Context, dep types.Deposit, debt sdk.Int, totalCollateral sdk.Int, auctionSize sdk.Int, principalDenom string) (debtChange sdk.Int, collateralChange sdk.Int, err error) {
	debtChange = sdk.ZeroInt()
	collateralChange = sdk.ZeroInt()
	depositAmount := dep.Amount[0].Amount
	depositDenom := dep.Amount[0].Denom
	for depositAmount.GTE(auctionSize) {
		// figure out how much debt is covered by one lots worth of collateral
		depositDebtAmount := (sdk.NewDecFromInt(auctionSize).Quo(sdk.NewDecFromInt(totalCollateral))).Mul(sdk.NewDecFromInt(debt)).RoundInt()
		penalty := k.ApplyLiquidationPenalty(ctx, depositDenom, depositDebtAmount)
		// start an auction for one lot, attempting to raise depositDebtAmount plus the liquidation penalty
		_, err := k.auctionKeeper.StartCollateralAuction(
			ctx, types.LiquidatorMacc, sdk.NewCoin(depositDenom, auctionSize), sdk.NewCoin(principalDenom, depositDebtAmount.Add(penalty)), []sdk.AccAddress{dep.Depositor},
			[]sdk.Int{auctionSize}, sdk.NewCoin(k.GetDebtDenom(ctx), depositDebtAmount))
		if err != nil {
			return sdk.ZeroInt(), sdk.ZeroInt(), err
		}
		depositAmount = depositAmount.Sub(auctionSize)
		totalCollateral = totalCollateral.Sub(auctionSize)
		debt = debt.Sub(depositDebtAmount)
		// subtract one lot's worth of debt from the total debt covered by this deposit
		debtChange = debtChange.Add(depositDebtAmount)
		collateralChange = collateralChange.Add(auctionSize)

	}
	return debtChange, collateralChange, nil
}

// CreateAuctionFromPartialDeposits creates an auction from the input partial deposits
func (k Keeper) CreateAuctionFromPartialDeposits(ctx sdk.Context, partialDeps partialDeposits, debt sdk.Int, collateral sdk.Int, auctionSize sdk.Int, bidDenom string) (debtChange, collateralChange sdk.Int, err error) {

	returnAddrs := []sdk.AccAddress{}
	returnWeights := []sdk.Int{}
	depositDenom := partialDeps[0].Amount[0].Denom
	for _, pd := range partialDeps {
		returnAddrs = append(returnAddrs, pd.Depositor)
		returnWeights = append(returnWeights, pd.DebtShare)
	}
	penalty := k.ApplyLiquidationPenalty(ctx, depositDenom, partialDeps.SumDebt())
	_, err = k.auctionKeeper.StartCollateralAuction(ctx, types.LiquidatorMacc, sdk.NewCoin(partialDeps[0].Amount[0].Denom, auctionSize), sdk.NewCoin(bidDenom, partialDeps.SumDebt().Add(penalty)), returnAddrs, returnWeights, sdk.NewCoin(k.GetDebtDenom(ctx), partialDeps.SumDebt()))
	if err != nil {
		return sdk.ZeroInt(), sdk.ZeroInt(), err
	}
	debtChange = partialDeps.SumDebt()
	collateralChange = partialDeps.SumCollateral()
	return debtChange, collateralChange, nil
}

// NetSurplusAndDebt burns surplus and debt coins equal to the minimum of surplus and debt balances held by the liquidator module account
// for example, if there is 1000 debt and 100 surplus, 100 surplus and 100 debt are burned, netting to 900 debt
func (k Keeper) NetSurplusAndDebt(ctx sdk.Context) error {
	totalSurplus := k.GetTotalSurplus(ctx, types.LiquidatorMacc)
	debt := k.GetTotalDebt(ctx, types.LiquidatorMacc)
	netAmount := sdk.MinInt(totalSurplus, debt)
	if netAmount.IsZero() {
		return nil
	}
	err := k.supplyKeeper.BurnCoins(ctx, types.LiquidatorMacc, sdk.NewCoins(sdk.NewCoin(k.GetDebtDenom(ctx), netAmount)))
	if err != nil {
		return err
	}
	for netAmount.GT(sdk.ZeroInt()) {
		for _, dp := range k.GetParams(ctx).DebtParams {
			balance := k.supplyKeeper.GetModuleAccount(ctx, types.LiquidatorMacc).GetCoins().AmountOf(dp.Denom)
			if balance.LT(netAmount) {
				err = k.supplyKeeper.BurnCoins(ctx, types.LiquidatorMacc, sdk.NewCoins(sdk.NewCoin(dp.Denom, balance)))
				if err != nil {
					return err
				}
				netAmount = netAmount.Sub(balance)
			} else {
				err = k.supplyKeeper.BurnCoins(ctx, types.LiquidatorMacc, sdk.NewCoins(sdk.NewCoin(dp.Denom, netAmount)))
				if err != nil {
					return err
				}
				netAmount = sdk.ZeroInt()
			}
		}
	}
	return nil
}

// GetTotalSurplus returns the total amount of surplus tokens held by the liquidator module account
func (k Keeper) GetTotalSurplus(ctx sdk.Context, accountName string) sdk.Int {
	acc := k.supplyKeeper.GetModuleAccount(ctx, accountName)
	totalSurplus := sdk.ZeroInt()
	for _, dp := range k.GetParams(ctx).DebtParams {
		surplus := acc.GetCoins().AmountOf(dp.Denom)
		totalSurplus = totalSurplus.Add(surplus)
	}
	return totalSurplus
}

// GetTotalDebt returns the total amount of debt tokens held by the liquidator module account
func (k Keeper) GetTotalDebt(ctx sdk.Context, accountName string) sdk.Int {
	acc := k.supplyKeeper.GetModuleAccount(ctx, accountName)
	debt := acc.GetCoins().AmountOf(k.GetDebtDenom(ctx))
	return debt
}

// RunSurplusAndDebtAuctions nets the surplus and debt balances and then creates surplus or debt auctions if the remaining balance is above the auction threshold parameter
func (k Keeper) RunSurplusAndDebtAuctions(ctx sdk.Context) error {
	k.NetSurplusAndDebt(ctx)
	remainingDebt := k.GetTotalDebt(ctx, types.LiquidatorMacc)
	params := k.GetParams(ctx)
	if remainingDebt.GTE(params.DebtAuctionThreshold) {
		_, err := k.auctionKeeper.StartDebtAuction(ctx, types.LiquidatorMacc, sdk.NewCoin("usdx", remainingDebt), sdk.NewCoin(k.GetGovDenom(ctx), remainingDebt.Mul(sdk.NewInt(dump))), sdk.NewCoin(k.GetDebtDenom(ctx), remainingDebt))
		if err != nil {
			return err
		}
	}

	for _, dp := range params.DebtParams {
		surplus := k.supplyKeeper.GetModuleAccount(ctx, types.LiquidatorMacc).GetCoins().AmountOf(dp.Denom)
		if surplus.GTE(params.SurplusAuctionThreshold) {
			surplusLot := sdk.NewCoin(dp.Denom, surplus)
			_, err := k.auctionKeeper.StartSurplusAuction(ctx, types.LiquidatorMacc, surplusLot, k.GetGovDenom(ctx))
			if err != nil {
				return err
			}
		}
	}
	return nil
}