package keeper_test

import (
	"errors"
	"fmt"
	"math/rand"
	"strings"
	"testing"
	"time"

	"github.com/stretchr/testify/suite"

	sdkmath "cosmossdk.io/math"
	sdk "github.com/cosmos/cosmos-sdk/types"
	"github.com/cosmos/cosmos-sdk/types/simulation"

	abci "github.com/cometbft/cometbft/abci/types"
	tmproto "github.com/cometbft/cometbft/proto/tendermint/types"
	tmtime "github.com/cometbft/cometbft/types/time"

	"github.com/0glabs/0g-chain/app"
	auctiontypes "github.com/0glabs/0g-chain/x/auction/types"
	"github.com/0glabs/0g-chain/x/cdp/keeper"
	"github.com/0glabs/0g-chain/x/cdp/types"
)

type SeizeTestSuite struct {
	suite.Suite

	keeper       keeper.Keeper
	addrs        []sdk.AccAddress
	app          app.TestApp
	cdps         types.CDPs
	ctx          sdk.Context
	liquidations liquidationTracker
}

type liquidationTracker struct {
	xrp  []uint64
	btc  []uint64
	debt int64
}

func (suite *SeizeTestSuite) SetupTest() {
	tApp := app.NewTestApp()
	ctx := tApp.NewContext(true, tmproto.Header{Height: 1, Time: tmtime.Now(), ChainID: app.TestChainId})
	tracker := liquidationTracker{}
	coins := cs(c("btc", 100000000), c("xrp", 10000000000))
	_, addrs := app.GeneratePrivKeyAddressPairs(100)

	authGS := app.NewFundedGenStateWithSameCoins(tApp.AppCodec(), coins, addrs)
	tApp.InitializeFromGenesisStates(
		authGS,
		NewPricefeedGenStateMulti(tApp.AppCodec()),
		NewCDPGenStateMulti(tApp.AppCodec()),
	)
	suite.ctx = ctx
	suite.app = tApp
	suite.keeper = tApp.GetCDPKeeper()
	suite.cdps = types.CDPs{}
	suite.addrs = addrs
	suite.liquidations = tracker
}

func (suite *SeizeTestSuite) createCdps() {
	tApp := app.NewTestApp()
	ctx := tApp.NewContext(true, tmproto.Header{Height: 1, Time: tmtime.Now()})
	cdps := make(types.CDPs, 100)
	_, addrs := app.GeneratePrivKeyAddressPairs(100)
	tracker := liquidationTracker{}
	coins := cs(c("btc", 100000000), c("xrp", 10000000000))

	authGS := app.NewFundedGenStateWithSameCoins(tApp.AppCodec(), coins, addrs)
	tApp.InitializeFromGenesisStates(
		authGS,
		NewPricefeedGenStateMulti(tApp.AppCodec()),
		NewCDPGenStateMulti(tApp.AppCodec()),
	)

	suite.ctx = ctx
	suite.app = tApp
	suite.keeper = tApp.GetCDPKeeper()
	randSource := rand.New(rand.NewSource(int64(777)))
	for j := 0; j < 100; j++ {
		collateral := "xrp"
		amount := 10000000000
		debt := simulation.RandIntBetween(randSource, 750000000, 1249000000)
		if j%2 == 0 {
			collateral = "btc"
			amount = 100000000
			debt = simulation.RandIntBetween(randSource, 2700000000, 5332000000)
			if debt >= 4000000000 {
				tracker.btc = append(tracker.btc, uint64(j+1))
				tracker.debt += int64(debt)
			}
		} else {
			if debt >= 1000000000 {
				tracker.xrp = append(tracker.xrp, uint64(j+1))
				tracker.debt += int64(debt)
			}
		}
		err := suite.keeper.AddCdp(suite.ctx, addrs[j], c(collateral, int64(amount)), c("usdx", int64(debt)), collateral+"-a")
		suite.NoError(err)
		c, f := suite.keeper.GetCDP(suite.ctx, collateral+"-a", uint64(j+1))
		suite.True(f)
		cdps[j] = c
	}

	suite.cdps = cdps
	suite.addrs = addrs
	suite.liquidations = tracker
}

func (suite *SeizeTestSuite) setPrice(price sdk.Dec, market string) {
	pfKeeper := suite.app.GetPriceFeedKeeper()

	_, err := pfKeeper.SetPrice(suite.ctx, sdk.AccAddress{}, market, price, suite.ctx.BlockTime().Add(time.Hour*3))
	suite.NoError(err)
	err = pfKeeper.SetCurrentPrices(suite.ctx, market)
	suite.NoError(err)
	pp, err := pfKeeper.GetCurrentPrice(suite.ctx, market)
	suite.NoError(err)
	suite.Equal(price, pp.Price)
}

func (suite *SeizeTestSuite) TestSeizeCollateral() {
	suite.createCdps()
	ak := suite.app.GetAccountKeeper()
	bk := suite.app.GetBankKeeper()

	cdp, found := suite.keeper.GetCDP(suite.ctx, "xrp-a", uint64(2))
	suite.True(found)

	p := cdp.Principal.Amount
	cl := cdp.Collateral.Amount

	tpb := suite.keeper.GetTotalPrincipal(suite.ctx, "xrp-a", "usdx")
	err := suite.keeper.SeizeCollateral(suite.ctx, cdp)
	suite.NoError(err)

	tpa := suite.keeper.GetTotalPrincipal(suite.ctx, "xrp-a", "usdx")
	suite.Equal(tpb.Sub(tpa), p)

	auctionKeeper := suite.app.GetAuctionKeeper()

	_, found = auctionKeeper.GetAuction(suite.ctx, auctiontypes.DefaultNextAuctionID)
	suite.True(found)

	auctionMacc := ak.GetModuleAccount(suite.ctx, auctiontypes.ModuleName)
	suite.Equal(cs(c("debt", p.Int64()), c("xrp", cl.Int64())), bk.GetAllBalances(suite.ctx, auctionMacc.GetAddress()))

	acc := ak.GetAccount(suite.ctx, suite.addrs[1])
	suite.Equal(p.Int64(), bk.GetBalance(suite.ctx, acc.GetAddress(), "usdx").Amount.Int64())
	err = suite.keeper.WithdrawCollateral(suite.ctx, suite.addrs[1], suite.addrs[1], c("xrp", 10), "xrp-a")
	suite.Require().True(errors.Is(err, types.ErrCdpNotFound))
}

func (suite *SeizeTestSuite) TestSeizeCollateralMultiDeposit() {
	suite.createCdps()
	ak := suite.app.GetAccountKeeper()
	bk := suite.app.GetBankKeeper()

	_, found := suite.keeper.GetCDP(suite.ctx, "xrp-a", uint64(2))
	suite.True(found)

	err := suite.keeper.DepositCollateral(suite.ctx, suite.addrs[1], suite.addrs[0], c("xrp", 6999000000), "xrp-a")
	suite.NoError(err)

	cdp, found := suite.keeper.GetCDP(suite.ctx, "xrp-a", uint64(2))
	suite.True(found)

	deposits := suite.keeper.GetDeposits(suite.ctx, cdp.ID)
	suite.Equal(2, len(deposits))

	p := cdp.Principal.Amount
	cl := cdp.Collateral.Amount
	tpb := suite.keeper.GetTotalPrincipal(suite.ctx, "xrp-a", "usdx")
	err = suite.keeper.SeizeCollateral(suite.ctx, cdp)
	suite.NoError(err)

	tpa := suite.keeper.GetTotalPrincipal(suite.ctx, "xrp-a", "usdx")
	suite.Equal(tpb.Sub(tpa), p)

	auctionMacc := ak.GetModuleAccount(suite.ctx, auctiontypes.ModuleName)
	suite.Equal(cs(c("debt", p.Int64()), c("xrp", cl.Int64())), bk.GetAllBalances(suite.ctx, auctionMacc.GetAddress()))

	acc := ak.GetAccount(suite.ctx, suite.addrs[1])
	suite.Equal(p.Int64(), bk.GetBalance(suite.ctx, acc.GetAddress(), "usdx").Amount.Int64())
	err = suite.keeper.WithdrawCollateral(suite.ctx, suite.addrs[1], suite.addrs[1], c("xrp", 10), "xrp-a")
	suite.Require().True(errors.Is(err, types.ErrCdpNotFound))
}

func (suite *SeizeTestSuite) TestLiquidateCdps() {
	suite.createCdps()
	ak := suite.app.GetAccountKeeper()
	bk := suite.app.GetBankKeeper()
	acc := ak.GetModuleAccount(suite.ctx, types.ModuleName)

	originalXrpCollateral := bk.GetBalance(suite.ctx, acc.GetAddress(), "xrp").Amount
	suite.setPrice(d("0.2"), "xrp:usd")
	p, found := suite.keeper.GetCollateral(suite.ctx, "xrp-a")
	suite.True(found)

	err := suite.keeper.LiquidateCdps(suite.ctx, "xrp:usd", "xrp-a", p.LiquidationRatio, p.CheckCollateralizationIndexCount)
	suite.NoError(err)

	acc = ak.GetModuleAccount(suite.ctx, types.ModuleName)
	finalXrpCollateral := bk.GetBalance(suite.ctx, acc.GetAddress(), "xrp").Amount
	seizedXrpCollateral := originalXrpCollateral.Sub(finalXrpCollateral)
	xrpLiquidations := int(seizedXrpCollateral.Quo(i(10000000000)).Int64())
	suite.Equal(10, xrpLiquidations)
}

func (suite *SeizeTestSuite) TestApplyLiquidationPenalty() {
	penalty := suite.keeper.ApplyLiquidationPenalty(suite.ctx, "xrp-a", i(1000))
	suite.Equal(i(50), penalty)
	penalty = suite.keeper.ApplyLiquidationPenalty(suite.ctx, "btc-a", i(1000))
	suite.Equal(i(25), penalty)
	penalty = suite.keeper.ApplyLiquidationPenalty(suite.ctx, "xrp-a", i(675760172))
	suite.Equal(i(33788009), penalty)
	suite.Panics(func() { suite.keeper.ApplyLiquidationPenalty(suite.ctx, "lol-a", i(1000)) })
}

func (suite *SeizeTestSuite) TestKeeperLiquidation() {
	type args struct {
		ctype               string
		blockTime           time.Time
		initialPrice        sdk.Dec
		finalPrice          sdk.Dec
		finalTwapPrice      sdk.Dec
		collateral          sdk.Coin
		principal           sdk.Coin
		expectedKeeperCoins sdk.Coins              // additional coins (if any) the borrower address should have after successfully liquidating position
		expectedAuctions    []auctiontypes.Auction // the auctions we should expect to find have been started
	}

	type errArgs struct {
		expectLiquidate bool
		contains        string
	}

	type test struct {
		name    string
		args    args
		errArgs errArgs
	}

	// Set up auction constants
	layout := "2006-01-02T15:04:05.000Z"
	endTimeStr := "9000-01-01T00:00:00.000Z"
	endTime, _ := time.Parse(layout, endTimeStr)
	addr, _ := sdk.AccAddressFromBech32("kava1ze7y9qwdddejmy7jlw4cymqqlt2wh05yhwmrv2")

	testCases := []test{
		{
			"valid liquidation",
			args{
				ctype:               "btc-a",
				blockTime:           time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
				initialPrice:        d("20000.00"),
				finalPrice:          d("19000.0"),
				finalTwapPrice:      d("19000.0"),
				collateral:          c("btc", 10000000),
				principal:           c("usdx", 1333330000),
				expectedKeeperCoins: cs(c("btc", 100100000), c("xrp", 10000000000)),
				expectedAuctions: []auctiontypes.Auction{
					&auctiontypes.CollateralAuction{
						BaseAuction: auctiontypes.BaseAuction{
							ID:              1,
							Initiator:       "liquidator",
							Lot:             c("btc", 9900000),
							Bidder:          nil,
							Bid:             c("usdx", 0),
							HasReceivedBids: false,
							EndTime:         endTime,
							MaxEndTime:      endTime,
						},
						CorrespondingDebt: c("debt", 1333330000),
						MaxBid:            c("usdx", 1366663250),
						LotReturns: auctiontypes.WeightedAddresses{
							Addresses: []sdk.AccAddress{addr},
							Weights:   []sdkmath.Int{sdkmath.NewInt(9900000)},
						},
					},
				},
			},
			errArgs{
				true,
				"",
			},
		},
		{
			"valid liquidation - twap market liquidateable but not spot",
			args{
				ctype:        "btc-a",
				blockTime:    time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
				initialPrice: d("20000.00"),
				// spot price does not liquidates
				finalPrice: d("21000.0"),
				// twap / liquidation price does liquidate
				finalTwapPrice:      d("19000.0"),
				collateral:          c("btc", 10000000),
				principal:           c("usdx", 1333330000),
				expectedKeeperCoins: cs(c("btc", 100100000), c("xrp", 10000000000)),
				expectedAuctions: []auctiontypes.Auction{
					&auctiontypes.CollateralAuction{
						BaseAuction: auctiontypes.BaseAuction{
							ID:              1,
							Initiator:       "liquidator",
							Lot:             c("btc", 9900000),
							Bidder:          nil,
							Bid:             c("usdx", 0),
							HasReceivedBids: false,
							EndTime:         endTime,
							MaxEndTime:      endTime,
						},
						CorrespondingDebt: c("debt", 1333330000),
						MaxBid:            c("usdx", 1366663250),
						LotReturns: auctiontypes.WeightedAddresses{
							Addresses: []sdk.AccAddress{addr},
							Weights:   []sdkmath.Int{sdkmath.NewInt(9900000)},
						},
					},
				},
			},
			errArgs{
				true,
				"",
			},
		},
		{
			"invalid - not below collateralization ratio",
			args{
				ctype:               "btc-a",
				blockTime:           time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
				initialPrice:        d("20000.00"),
				finalPrice:          d("21000.0"),
				finalTwapPrice:      d("21000.0"),
				collateral:          c("btc", 10000000),
				principal:           c("usdx", 1333330000),
				expectedKeeperCoins: cs(),
				expectedAuctions:    []auctiontypes.Auction{},
			},
			errArgs{
				false,
				"collateral ratio not below liquidation ratio",
			},
		},
		{
			"invalid - spot market liquidateable but not twap",
			args{
				ctype:        "btc-a",
				blockTime:    time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
				initialPrice: d("20000.00"),
				// spot price liquidates
				finalPrice: d("19000.0"),
				// twap / liquidation price does not liquidate
				finalTwapPrice:      d("21000.0"),
				collateral:          c("btc", 10000000),
				principal:           c("usdx", 1333330000),
				expectedKeeperCoins: cs(),
				expectedAuctions:    []auctiontypes.Auction{},
			},
			errArgs{
				false,
				"collateral ratio not below liquidation ratio",
			},
		},
		{
			"invalid - collateralization ratio equal to liquidation ratio",
			args{
				ctype:               "xrp-a",
				blockTime:           time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
				initialPrice:        d("1.00"), // we are allowed to create a cdp with an exact ratio
				finalPrice:          d("1.00"),
				finalTwapPrice:      d("1.00"), // and it should not be able to be liquidated
				collateral:          c("xrp", 100000000),
				principal:           c("usdx", 50000000),
				expectedKeeperCoins: cs(),
				expectedAuctions:    []auctiontypes.Auction{},
			},
			errArgs{
				false,
				"collateral ratio not below liquidation ratio",
			},
		},
	}

	for _, tc := range testCases {
		suite.Run(tc.name, func() {
			suite.SetupTest()

			spotMarket := fmt.Sprintf("%s:usd", tc.args.collateral.Denom)
			liquidationMarket := fmt.Sprintf("%s:30", spotMarket)

			// setup pricefeed
			pk := suite.app.GetPriceFeedKeeper()
			_, err := pk.SetPrice(suite.ctx, sdk.AccAddress{}, spotMarket, tc.args.initialPrice, suite.ctx.BlockTime().Add(time.Hour*24))
			suite.Require().NoError(err)
			err = pk.SetCurrentPrices(suite.ctx, spotMarket)
			suite.Require().NoError(err)

			// setup cdp state
			suite.keeper.SetPreviousAccrualTime(suite.ctx, tc.args.ctype, suite.ctx.BlockTime())
			suite.keeper.SetInterestFactor(suite.ctx, tc.args.ctype, sdk.OneDec())
			err = suite.keeper.AddCdp(suite.ctx, suite.addrs[0], tc.args.collateral, tc.args.principal, tc.args.ctype)
			suite.Require().NoError(err)

			// update pricefeed
			// spot market
			_, err = pk.SetPrice(suite.ctx, sdk.AccAddress{}, spotMarket, tc.args.finalPrice, suite.ctx.BlockTime().Add(time.Hour*24))
			suite.Require().NoError(err)
			// liquidate market
			_, err = pk.SetPrice(suite.ctx, sdk.AccAddress{}, liquidationMarket, tc.args.finalTwapPrice, suite.ctx.BlockTime().Add(time.Hour*24))
			suite.Require().NoError(err)

			err = pk.SetCurrentPrices(suite.ctx, spotMarket)
			suite.Require().NoError(err)
			err = pk.SetCurrentPrices(suite.ctx, liquidationMarket)
			suite.Require().NoError(err)

			_, found := suite.keeper.GetCdpByOwnerAndCollateralType(suite.ctx, suite.addrs[0], tc.args.ctype)
			suite.Require().True(found)

			err = suite.keeper.AttemptKeeperLiquidation(suite.ctx, suite.addrs[1], suite.addrs[0], tc.args.ctype)

			if tc.errArgs.expectLiquidate {
				suite.Require().NoError(err)

				_, found = suite.keeper.GetCdpByOwnerAndCollateralType(suite.ctx, suite.addrs[0], tc.args.ctype)
				suite.Require().False(found)

				ak := suite.app.GetAuctionKeeper()
				auctions := ak.GetAllAuctions(suite.ctx)
				suite.Require().Equal(tc.args.expectedAuctions, auctions)

				ack := suite.app.GetAccountKeeper()
				bk := suite.app.GetBankKeeper()
				keeper := ack.GetAccount(suite.ctx, suite.addrs[1])
				suite.Require().Equal(tc.args.expectedKeeperCoins, bk.GetAllBalances(suite.ctx, keeper.GetAddress()))
			} else {
				suite.Require().Error(err)
				suite.Require().True(strings.Contains(err.Error(), tc.errArgs.contains))
			}
		})
	}
}

func (suite *SeizeTestSuite) TestBeginBlockerLiquidation() {
	type args struct {
		ctype            string
		blockTime        time.Time
		initialPrice     sdk.Dec
		finalPrice       sdk.Dec
		collaterals      sdk.Coins
		principals       sdk.Coins
		expectedAuctions []auctiontypes.Auction // the auctions we should expect to find have been started
	}
	type errArgs struct {
		expectLiquidate bool
		contains        string
	}
	type test struct {
		name    string
		args    args
		errArgs errArgs
	}
	// Set up auction constants
	layout := "2006-01-02T15:04:05.000Z"
	endTimeStr := "9000-01-01T00:00:00.000Z"
	endTime, _ := time.Parse(layout, endTimeStr)
	addr, _ := sdk.AccAddressFromBech32("kava1ze7y9qwdddejmy7jlw4cymqqlt2wh05yhwmrv2")

	testCases := []test{
		{
			"1 liquidation",
			args{
				"btc-a",
				time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
				d("20000.00"),
				d("10000.00"),
				sdk.Coins{c("btc", 10000000), c("btc", 10000000)},
				sdk.Coins{c("usdx", 1000000000), c("usdx", 500000000)},
				[]auctiontypes.Auction{
					&auctiontypes.CollateralAuction{
						BaseAuction: auctiontypes.BaseAuction{
							ID:              1,
							Initiator:       "liquidator",
							Lot:             c("btc", 10000000),
							Bidder:          nil,
							Bid:             c("usdx", 0),
							HasReceivedBids: false,
							EndTime:         endTime,
							MaxEndTime:      endTime,
						},
						CorrespondingDebt: c("debt", 1000000000),
						MaxBid:            c("usdx", 1025000000),
						LotReturns: auctiontypes.WeightedAddresses{
							Addresses: []sdk.AccAddress{addr},
							Weights:   []sdkmath.Int{sdkmath.NewInt(10000000)},
						},
					},
				},
			},
			errArgs{
				true,
				"",
			},
		},
		{
			"no liquidation",
			args{
				"btc-a",
				time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
				d("20000.00"),
				d("10000.00"),
				sdk.Coins{c("btc", 10000000), c("btc", 10000000)},
				sdk.Coins{c("usdx", 500000000), c("usdx", 500000000)},
				[]auctiontypes.Auction{},
			},
			errArgs{
				false,
				"collateral ratio not below liquidation ratio",
			},
		},
	}

	for _, tc := range testCases {
		suite.Run(tc.name, func() {
			suite.SetupTest()
			// setup pricefeed
			pk := suite.app.GetPriceFeedKeeper()
			_, err := pk.SetPrice(suite.ctx, sdk.AccAddress{}, "btc:usd", tc.args.initialPrice, suite.ctx.BlockTime().Add(time.Hour*24))
			suite.Require().NoError(err)
			err = pk.SetCurrentPrices(suite.ctx, "btc:usd")
			suite.Require().NoError(err)

			// setup cdp state
			suite.keeper.SetPreviousAccrualTime(suite.ctx, tc.args.ctype, suite.ctx.BlockTime())
			suite.keeper.SetInterestFactor(suite.ctx, tc.args.ctype, sdk.OneDec())

			for idx, col := range tc.args.collaterals {
				err := suite.keeper.AddCdp(suite.ctx, suite.addrs[idx], col, tc.args.principals[idx], tc.args.ctype)
				suite.Require().NoError(err)
			}

			// update pricefeed
			_, err = pk.SetPrice(suite.ctx, sdk.AccAddress{}, "btc:usd", tc.args.finalPrice, suite.ctx.BlockTime().Add(time.Hour*24))
			suite.Require().NoError(err)
			err = pk.SetCurrentPrices(suite.ctx, "btc:usd")
			suite.Require().NoError(err)

			_ = suite.app.BeginBlocker(suite.ctx, abci.RequestBeginBlock{Header: suite.ctx.BlockHeader()})
			ak := suite.app.GetAuctionKeeper()
			auctions := ak.GetAllAuctions(suite.ctx)
			if tc.errArgs.expectLiquidate {
				suite.Require().Equal(tc.args.expectedAuctions, auctions)
				for _, a := range auctions {
					ca := a.(*auctiontypes.CollateralAuction)
					_, found := suite.keeper.GetCdpByOwnerAndCollateralType(suite.ctx, ca.LotReturns.Addresses[0], tc.args.ctype)
					suite.Require().False(found)
				}
			} else {
				suite.Require().Equal(0, len(auctions))
				for idx := range tc.args.collaterals {
					_, found := suite.keeper.GetCdpByOwnerAndCollateralType(suite.ctx, suite.addrs[idx], tc.args.ctype)
					suite.Require().True(found)
				}
			}
		})
	}
}

func TestSeizeTestSuite(t *testing.T) {
	suite.Run(t, new(SeizeTestSuite))
}