package keeper_test

import (
	"testing"
	"time"

	"github.com/stretchr/testify/suite"

	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
	sdk "github.com/cosmos/cosmos-sdk/types"
	tmprototypes "github.com/tendermint/tendermint/proto/tendermint/types"

	"github.com/cosmos/cosmos-sdk/x/staking"
	stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
	"github.com/kava-labs/kava/app"
	liquidtypes "github.com/kava-labs/kava/x/liquid/types"
	"github.com/kava-labs/kava/x/savings/keeper"
	"github.com/kava-labs/kava/x/savings/types"
)

var dep = types.NewDeposit

const (
	bkava1 = "bkava-kavavaloper15gqc744d05xacn4n6w2furuads9fu4pqn6zxlu"
	bkava2 = "bkava-kavavaloper15qdefkmwswysgg4qxgqpqr35k3m49pkx8yhpte"
)

type grpcQueryTestSuite struct {
	suite.Suite

	tApp        app.TestApp
	ctx         sdk.Context
	keeper      keeper.Keeper
	queryServer types.QueryServer
	addrs       []sdk.AccAddress
}

func (suite *grpcQueryTestSuite) SetupTest() {
	suite.tApp = app.NewTestApp()
	_, addrs := app.GeneratePrivKeyAddressPairs(2)

	suite.addrs = addrs

	suite.ctx = suite.tApp.NewContext(true, tmprototypes.Header{}).
		WithBlockTime(time.Now().UTC())
	suite.keeper = suite.tApp.GetSavingsKeeper()
	suite.queryServer = keeper.NewQueryServerImpl(suite.keeper)

	err := suite.tApp.FundModuleAccount(
		suite.ctx,
		types.ModuleAccountName,
		cs(
			c("usdx", 10000000000),
			c("busd", 10000000000),
		),
	)
	suite.Require().NoError(err)

	savingsGenesis := types.GenesisState{
		Params: types.NewParams([]string{"bnb", "busd", bkava1, bkava2}),
	}
	savingsGenState := app.GenesisState{types.ModuleName: suite.tApp.AppCodec().MustMarshalJSON(&savingsGenesis)}

	suite.tApp.InitializeFromGenesisStates(
		savingsGenState,
		app.NewFundedGenStateWithSameCoins(
			suite.tApp.AppCodec(),
			cs(
				c("bnb", 10000000000),
				c("busd", 20000000000),
			),
			addrs,
		),
	)
}

func (suite *grpcQueryTestSuite) TestGrpcQueryParams() {
	res, err := suite.queryServer.Params(sdk.WrapSDKContext(suite.ctx), &types.QueryParamsRequest{})
	suite.Require().NoError(err)

	var expected types.GenesisState
	savingsGenesis := types.GenesisState{
		Params: types.NewParams([]string{"bnb", "busd", bkava1, bkava2}),
	}
	savingsGenState := app.GenesisState{types.ModuleName: suite.tApp.AppCodec().MustMarshalJSON(&savingsGenesis)}
	suite.tApp.AppCodec().MustUnmarshalJSON(savingsGenState[types.ModuleName], &expected)

	suite.Equal(expected.Params, res.Params, "params should equal test genesis state")
}

func (suite *grpcQueryTestSuite) TestGrpcQueryDeposits() {
	suite.addDeposits([]types.Deposit{
		dep(suite.addrs[0], cs(c("bnb", 100000000))),
		dep(suite.addrs[1], cs(c("bnb", 20000000))),
		dep(suite.addrs[0], cs(c("busd", 20000000))),
		dep(suite.addrs[0], cs(c("busd", 8000000))),
	})

	tests := []struct {
		giveName          string
		giveRequest       *types.QueryDepositsRequest
		wantDepositCounts int
		shouldError       bool
		errorSubstr       string
	}{
		{
			"empty query",
			&types.QueryDepositsRequest{},
			2,
			false,
			"",
		},
		{
			"owner",
			&types.QueryDepositsRequest{
				Owner: suite.addrs[0].String(),
			},
			// Excludes the second address
			1,
			false,
			"",
		},
		{
			"invalid owner",
			&types.QueryDepositsRequest{
				Owner: "invalid address",
			},
			// No deposits
			0,
			true,
			"decoding bech32 failed",
		},
		{
			"owner and denom",
			&types.QueryDepositsRequest{
				Owner: suite.addrs[0].String(),
				Denom: "bnb",
			},
			// Only the first one
			1,
			false,
			"",
		},
		{
			"owner and invalid denom empty response",
			&types.QueryDepositsRequest{
				Owner: suite.addrs[0].String(),
				Denom: "invalid denom",
			},
			0,
			false,
			"",
		},
		{
			"denom",
			&types.QueryDepositsRequest{
				Denom: "bnb",
			},
			2,
			false,
			"",
		},
	}

	for _, tt := range tests {
		suite.Run(tt.giveName, func() {
			res, err := suite.queryServer.Deposits(sdk.WrapSDKContext(suite.ctx), tt.giveRequest)

			if tt.shouldError {
				suite.Error(err)
				suite.Contains(err.Error(), tt.errorSubstr)
			} else {
				suite.NoError(err)
				suite.Equal(tt.wantDepositCounts, len(res.Deposits))
			}
		})
	}
}

func (suite *grpcQueryTestSuite) TestGrpcQueryTotalSupply() {
	testCases := []struct {
		name           string
		deposits       types.Deposits
		expectedSupply sdk.Coins
	}{
		{
			name:           "returns zeros when there's no supply",
			deposits:       []types.Deposit{},
			expectedSupply: sdk.NewCoins(),
		},
		{
			name: "returns supply of one denom deposited from multiple accounts",
			deposits: []types.Deposit{
				dep(suite.addrs[0], sdk.NewCoins(c("busd", 1e6))),
				dep(suite.addrs[1], sdk.NewCoins(c("busd", 1e6))),
			},
			expectedSupply: sdk.NewCoins(c("busd", 2e6)),
		},
		{
			name: "returns supply of multiple denoms deposited from single account",
			deposits: []types.Deposit{
				dep(suite.addrs[0], sdk.NewCoins(c("busd", 1e6), c("bnb", 1e6))),
			},
			expectedSupply: sdk.NewCoins(c("busd", 1e6), c("bnb", 1e6)),
		},
		{
			name: "returns supply of multiple denoms deposited from multiple accounts",
			deposits: []types.Deposit{
				dep(suite.addrs[0], sdk.NewCoins(c("busd", 1e6), c("bnb", 1e6))),
				dep(suite.addrs[1], sdk.NewCoins(c("busd", 1e6), c("bnb", 1e6))),
			},
			expectedSupply: sdk.NewCoins(c("busd", 2e6), c("bnb", 2e6)),
		},
	}

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

			res, err := suite.queryServer.TotalSupply(
				sdk.WrapSDKContext(suite.ctx),
				&types.QueryTotalSupplyRequest{},
			)
			suite.Require().NoError(err)
			suite.Require().Equal(tc.expectedSupply, res.Result)
		})
	}

	suite.Run("aggregates bkava denoms, accounting for slashing", func() {
		suite.SetupTest()

		address1, derivatives1, _ := suite.createAccountWithDerivatives(bkava1, sdk.NewInt(1e9))
		address2, derivatives2, _ := suite.createAccountWithDerivatives(bkava2, sdk.NewInt(1e9))

		// bond validators
		staking.EndBlocker(suite.ctx, suite.tApp.GetStakingKeeper())
		// slash val2 - its shares are now 80% as valuable!
		err := suite.slashValidator(sdk.ValAddress(address2), sdk.MustNewDecFromStr("0.2"))
		suite.Require().NoError(err)

		suite.addDeposits(
			types.Deposits{
				dep(address1, cs(derivatives1)),
				dep(address2, cs(derivatives2)),
			},
		)

		expectedSupply := sdk.NewCoins(
			sdk.NewCoin(
				"bkava",
				sdk.NewIntFromUint64(1e9). // derivative 1
								Add(sdk.NewInt(1e9).MulRaw(80).QuoRaw(100))), // derivative 2: original value * 80%
		)

		res, err := suite.queryServer.TotalSupply(
			sdk.WrapSDKContext(suite.ctx),
			&types.QueryTotalSupplyRequest{},
		)
		suite.Require().NoError(err)
		suite.Require().Equal(expectedSupply, res.Result)
	})
}

func (suite *grpcQueryTestSuite) addDeposits(deposits types.Deposits) {
	for _, dep := range deposits {
		suite.NotPanics(func() {
			err := suite.keeper.Deposit(suite.ctx, dep.Depositor, dep.Amount)
			suite.Require().NoError(err)
		})
	}
}

// createUnbondedValidator creates an unbonded validator with the given amount of self-delegation.
func (suite *grpcQueryTestSuite) createUnbondedValidator(address sdk.ValAddress, selfDelegation sdk.Coin, minSelfDelegation sdk.Int) error {
	msg, err := stakingtypes.NewMsgCreateValidator(
		address,
		ed25519.GenPrivKey().PubKey(),
		selfDelegation,
		stakingtypes.Description{},
		stakingtypes.NewCommissionRates(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()),
		minSelfDelegation,
	)
	if err != nil {
		return err
	}

	msgServer := stakingkeeper.NewMsgServerImpl(suite.tApp.GetStakingKeeper())
	_, err = msgServer.CreateValidator(sdk.WrapSDKContext(suite.ctx), msg)
	return err
}

// createAccountWithDerivatives creates an account with the given amount and denom of derivative token.
// Internally, it creates a validator account and mints derivatives from the validator's self delegation.
func (suite *grpcQueryTestSuite) createAccountWithDerivatives(denom string, amount sdk.Int) (sdk.AccAddress, sdk.Coin, sdk.Coins) {
	bondDenom := suite.tApp.GetStakingKeeper().BondDenom(suite.ctx)
	valAddress, err := liquidtypes.ParseLiquidStakingTokenDenom(denom)
	suite.Require().NoError(err)
	address := sdk.AccAddress(valAddress)

	remainingSelfDelegation := sdk.NewInt(1e6)
	selfDelegation := sdk.NewCoin(
		bondDenom,
		amount.Add(remainingSelfDelegation),
	)

	// create & fund account
	// ak := suite.tApp.GetAccountKeeper()
	// acc := ak.NewAccountWithAddress(suite.ctx, address)
	// ak.SetAccount(suite.ctx, acc)
	err = suite.tApp.FundAccount(suite.ctx, address, sdk.NewCoins(selfDelegation))
	suite.Require().NoError(err)

	err = suite.createUnbondedValidator(valAddress, selfDelegation, remainingSelfDelegation)
	suite.Require().NoError(err)

	toConvert := sdk.NewCoin(bondDenom, amount)
	derivatives, err := suite.tApp.GetLiquidKeeper().MintDerivative(suite.ctx,
		address,
		valAddress,
		toConvert,
	)
	suite.Require().NoError(err)

	fullBalance := suite.tApp.GetBankKeeper().GetAllBalances(suite.ctx, address)

	return address, derivatives, fullBalance
}

// slashValidator slashes the validator with the given address by the given percentage.
func (suite *grpcQueryTestSuite) slashValidator(address sdk.ValAddress, slashFraction sdk.Dec) error {
	stakingKeeper := suite.tApp.GetStakingKeeper()

	validator, found := stakingKeeper.GetValidator(suite.ctx, address)
	suite.Require().True(found)
	consAddr, err := validator.GetConsAddr()
	suite.Require().NoError(err)

	// Assume infraction was at current height. Note unbonding delegations and redelegations are only slashed if created after
	// the infraction height so none will be slashed.
	infractionHeight := suite.ctx.BlockHeight()

	power := stakingKeeper.TokensToConsensusPower(suite.ctx, validator.GetTokens())

	stakingKeeper.Slash(suite.ctx, consAddr, infractionHeight, power, slashFraction)
	return nil
}

func TestGrpcQueryTestSuite(t *testing.T) {
	suite.Run(t, new(grpcQueryTestSuite))
}