package v0_14

import (
	"fmt"
	"sort"
	"time"

	"github.com/cosmos/cosmos-sdk/codec"
	sdk "github.com/cosmos/cosmos-sdk/types"
	"github.com/cosmos/cosmos-sdk/x/auth"
	authexported "github.com/cosmos/cosmos-sdk/x/auth/exported"
	"github.com/cosmos/cosmos-sdk/x/genutil"
	"github.com/cosmos/cosmos-sdk/x/supply"

	cryptoAmino "github.com/tendermint/tendermint/crypto/encoding/amino"
	tmtypes "github.com/tendermint/tendermint/types"

	"github.com/kava-labs/kava/app"
	"github.com/kava-labs/kava/x/bep3"
	v0_14cdp "github.com/kava-labs/kava/x/cdp"
	v0_11cdp "github.com/kava-labs/kava/x/cdp/legacy/v0_11"
	v0_14committee "github.com/kava-labs/kava/x/committee"
	v0_11committee "github.com/kava-labs/kava/x/committee/legacy/v0_11"
	v0_14hard "github.com/kava-labs/kava/x/hard"
	v0_11hard "github.com/kava-labs/kava/x/hard/legacy/v0_11"
	v0_14incentive "github.com/kava-labs/kava/x/incentive"
	v0_11incentive "github.com/kava-labs/kava/x/incentive/legacy/v0_11"
	"github.com/kava-labs/kava/x/kavadist"
	v0_11pricefeed "github.com/kava-labs/kava/x/pricefeed"
	v0_14pricefeed "github.com/kava-labs/kava/x/pricefeed"
	validatorvesting "github.com/kava-labs/kava/x/validator-vesting"
)

var (
	GenesisTime   = time.Date(2021, 3, 31, 15, 0, 0, 0, time.UTC)
	RewardEndTime = time.Date(2022, 3, 31, 14, 0, 0, 0, time.UTC)
	ClaimEndTime  = time.Date(2026, 3, 31, 14, 0, 0, 0, time.UTC)
)

// Migrate translates a genesis file from kava v0.11 (or v0.12) format to kava v0.13.x format.
func Migrate(genDoc tmtypes.GenesisDoc) tmtypes.GenesisDoc {
	// migrate app state
	var appStateMap genutil.AppMap
	cdc := codec.New()
	cryptoAmino.RegisterAmino(cdc)
	tmtypes.RegisterEvidences(cdc)

	if err := cdc.UnmarshalJSON(genDoc.AppState, &appStateMap); err != nil {
		panic(err)
	}
	newAppState := MigrateAppState(appStateMap)
	v0_14Codec := app.MakeCodec()
	marshaledNewAppState, err := v0_14Codec.MarshalJSON(newAppState)
	if err != nil {
		panic(err)
	}
	genDoc.AppState = marshaledNewAppState
	genDoc.GenesisTime = GenesisTime
	genDoc.ChainID = "kava-5.1"
	genDoc.ConsensusParams.Block.MaxGas = 20000000
	return genDoc
}

// MigrateAppState migrates application state from v0.11 (or v0.12) format to a kava v0.13.x format
func MigrateAppState(v0_11AppState genutil.AppMap) genutil.AppMap {
	v0_14AppState := v0_11AppState
	cdc := app.MakeCodec()
	var hardGenState v0_11hard.GenesisState
	if v0_11AppState[v0_14hard.ModuleName] == nil {
		cdc.MustUnmarshalJSON(v0_11AppState[v0_11hard.ModuleName], &hardGenState)
		delete(v0_11AppState, v0_11hard.ModuleName)
		v0_14AppState[v0_14hard.ModuleName] = cdc.MustMarshalJSON(
			Hard(hardGenState))
	}
	delete(v0_14AppState, v0_11hard.ModuleName)
	if v0_11AppState[v0_11cdp.ModuleName] != nil {
		var cdpGenState v0_11cdp.GenesisState
		cdc.MustUnmarshalJSON(v0_11AppState[v0_11cdp.ModuleName], &cdpGenState)
		delete(v0_11AppState, v0_11cdp.ModuleName)
		v0_14AppState[v0_14cdp.ModuleName] = cdc.MustMarshalJSON(
			CDP(cdpGenState))
	}
	if v0_11AppState[v0_11incentive.ModuleName] != nil {
		var incentiveGenState v0_11incentive.GenesisState
		cdc.MustUnmarshalJSON(v0_11AppState[v0_14incentive.ModuleName], &incentiveGenState)
		delete(v0_11AppState, v0_11incentive.ModuleName)
		v0_14AppState[v0_14incentive.ModuleName] = cdc.MustMarshalJSON(Incentive(hardGenState, incentiveGenState))
	}
	if v0_11AppState[v0_11pricefeed.ModuleName] != nil {
		var pricefeedGS v0_11pricefeed.GenesisState
		cdc.MustUnmarshalJSON(v0_11AppState[v0_14pricefeed.ModuleName], &pricefeedGS)
		delete(v0_11AppState, v0_11pricefeed.ModuleName)
		v0_14AppState[v0_14pricefeed.ModuleName] = cdc.MustMarshalJSON(Pricefeed(pricefeedGS))
	}
	if v0_11AppState[bep3.ModuleName] != nil {
		var bep3GS bep3.GenesisState
		cdc.MustUnmarshalJSON(v0_11AppState[bep3.ModuleName], &bep3GS)
		delete(v0_11AppState, bep3.ModuleName)
		v0_14AppState[bep3.ModuleName] = cdc.MustMarshalJSON(Bep3(bep3GS))
	}
	if v0_11AppState[v0_11committee.ModuleName] != nil {
		var committeeGS v0_11committee.GenesisState
		cdc := codec.New()
		sdk.RegisterCodec(cdc)
		v0_11committee.RegisterCodec(cdc)
		cdc.MustUnmarshalJSON(v0_11AppState[v0_11committee.ModuleName], &committeeGS)
		delete(v0_11AppState, v0_11committee.ModuleName)
		cdc = app.MakeCodec()
		v0_14AppState[v0_14committee.ModuleName] = cdc.MustMarshalJSON(Committee(committeeGS))
	}
	if v0_11AppState[auth.ModuleName] != nil {
		var authGS auth.GenesisState
		cdc.MustUnmarshalJSON(v0_11AppState[auth.ModuleName], &authGS)
		delete(v0_11AppState, auth.ModuleName)
		v0_14AppState[auth.ModuleName] = cdc.MustMarshalJSON(Auth(authGS))
	}
	return v0_14AppState

}

// CDP migrates from a v0.11 cdp genesis state to a v0.13 cdp genesis state
func CDP(oldGenState v0_11cdp.GenesisState) v0_14cdp.GenesisState {
	var newCDPs v0_14cdp.CDPs
	var newDeposits v0_14cdp.Deposits
	var newCollateralParams v0_14cdp.CollateralParams
	var newGenesisAccumulationTimes v0_14cdp.GenesisAccumulationTimes
	var previousAccumulationTime time.Time
	var totalPrincipals v0_14cdp.GenesisTotalPrincipals
	newStartingID := oldGenState.StartingCdpID

	totalPrincipalMap := make(map[string]sdk.Int)

	for _, cdp := range oldGenState.CDPs {
		newCDP := v0_14cdp.NewCDPWithFees(cdp.ID, cdp.Owner, cdp.Collateral, cdp.Type, cdp.Principal, cdp.AccumulatedFees, cdp.FeesUpdated, sdk.OneDec())
		if previousAccumulationTime.Before(cdp.FeesUpdated) {
			previousAccumulationTime = cdp.FeesUpdated
		}
		_, found := totalPrincipalMap[cdp.Type]
		if !found {
			totalPrincipalMap[cdp.Type] = sdk.ZeroInt()
		}
		totalPrincipalMap[cdp.Type] = totalPrincipalMap[cdp.Type].Add(newCDP.GetTotalPrincipal().Amount)

		newCDPs = append(newCDPs, newCDP)
	}

	for _, cp := range oldGenState.Params.CollateralParams {
		newCollateralParam := v0_14cdp.NewCollateralParam(cp.Denom, cp.Type, cp.LiquidationRatio, cp.DebtLimit, cp.StabilityFee, cp.AuctionSize, cp.LiquidationPenalty, cp.Prefix, cp.SpotMarketID, cp.LiquidationMarketID, sdk.MustNewDecFromStr("0.01"), sdk.NewInt(10), cp.ConversionFactor)
		newCollateralParams = append(newCollateralParams, newCollateralParam)
		newGenesisAccumulationTime := v0_14cdp.NewGenesisAccumulationTime(cp.Type, previousAccumulationTime, sdk.OneDec())
		newGenesisAccumulationTimes = append(newGenesisAccumulationTimes, newGenesisAccumulationTime)
	}

	for _, dep := range oldGenState.Deposits {
		newDep := v0_14cdp.NewDeposit(dep.CdpID, dep.Depositor, dep.Amount)
		newDeposits = append(newDeposits, newDep)
	}

	for ctype, tp := range totalPrincipalMap {
		totalPrincipal := v0_14cdp.NewGenesisTotalPrincipal(ctype, tp)
		totalPrincipals = append(totalPrincipals, totalPrincipal)
	}

	sort.Slice(totalPrincipals, func(i, j int) bool { return totalPrincipals[i].CollateralType < totalPrincipals[j].CollateralType })

	oldDebtParam := oldGenState.Params.DebtParam

	newDebtParam := v0_14cdp.NewDebtParam(oldDebtParam.Denom, oldDebtParam.ReferenceAsset, oldDebtParam.ConversionFactor, oldDebtParam.DebtFloor)

	newGlobalDebtLimit := oldGenState.Params.GlobalDebtLimit

	newParams := v0_14cdp.NewParams(newGlobalDebtLimit, newCollateralParams, newDebtParam, oldGenState.Params.SurplusAuctionThreshold, oldGenState.Params.SurplusAuctionLot, oldGenState.Params.DebtAuctionThreshold, oldGenState.Params.DebtAuctionLot, false)

	return v0_14cdp.NewGenesisState(
		newParams,
		newCDPs,
		newDeposits,
		newStartingID,
		oldGenState.DebtDenom,
		oldGenState.GovDenom,
		newGenesisAccumulationTimes,
		totalPrincipals,
	)
}

// Hard migrates from a v0.11 hard (harvest) genesis state to a v0.13 hard genesis state
func Hard(genesisState v0_11hard.GenesisState) v0_14hard.GenesisState {
	v13Deposits := v0_14hard.Deposits{}
	v13DepositorMap := make(map[string]v0_14hard.Deposit)
	v13GenesisAccumulationTimes := v0_14hard.GenesisAccumulationTimes{}
	v13TotalSupplied := sdk.NewCoins()

	for _, dep := range genesisState.Deposits {
		v13Deposit, ok := v13DepositorMap[dep.Depositor.String()]
		if !ok {
			v13Deposit := v0_14hard.NewDeposit(dep.Depositor, sdk.NewCoins(dep.Amount), v0_14hard.SupplyInterestFactors{v0_14hard.NewSupplyInterestFactor(dep.Amount.Denom, sdk.OneDec())})
			v13DepositorMap[dep.Depositor.String()] = v13Deposit
		} else {
			v13Deposit.Amount = v13Deposit.Amount.Add(dep.Amount)
			v13Deposit.Index = append(v13Deposit.Index, v0_14hard.NewSupplyInterestFactor(dep.Amount.Denom, sdk.OneDec()))
			v13DepositorMap[dep.Depositor.String()] = v13Deposit
		}
	}

	defaultInterestModel := v0_14hard.NewInterestRateModel(sdk.ZeroDec(), sdk.MustNewDecFromStr("0.05"), sdk.MustNewDecFromStr("0.8"), sdk.MustNewDecFromStr("1.0"))
	newParams := v0_14hard.NewParams(
		v0_14hard.MoneyMarkets{

			v0_14hard.NewMoneyMarket("btcb", v0_14hard.NewBorrowLimit(true, sdk.ZeroDec(), sdk.MustNewDecFromStr("0.5")), "btc:usd", sdk.NewInt(100000000),
				defaultInterestModel,
				sdk.MustNewDecFromStr("0.025"), sdk.MustNewDecFromStr("0.02"),
			),
			// bnb
			v0_14hard.NewMoneyMarket("bnb", v0_14hard.NewBorrowLimit(true, sdk.ZeroDec(), sdk.MustNewDecFromStr("0.5")), "bnb:usd", sdk.NewInt(100000000),
				defaultInterestModel,
				sdk.MustNewDecFromStr("0.025"), sdk.MustNewDecFromStr("0.02"),
			),
			// xrpb
			v0_14hard.NewMoneyMarket("xrpb", v0_14hard.NewBorrowLimit(true, sdk.ZeroDec(), sdk.MustNewDecFromStr("0.5")), "xrp:usd", sdk.NewInt(100000000),
				defaultInterestModel,
				sdk.MustNewDecFromStr("0.025"), sdk.MustNewDecFromStr("0.02"),
			),
			// busd
			v0_14hard.NewMoneyMarket("busd", v0_14hard.NewBorrowLimit(true, sdk.MustNewDecFromStr("100000000000000"), sdk.MustNewDecFromStr("0.5")), "busd:usd", sdk.NewInt(100000000),
				defaultInterestModel,
				sdk.MustNewDecFromStr("0.025"), sdk.MustNewDecFromStr("0.02"),
			),
			// usdx
			v0_14hard.NewMoneyMarket("usdx", v0_14hard.NewBorrowLimit(true, sdk.ZeroDec(), sdk.ZeroDec()), "usdx:usd", sdk.NewInt(1000000),
				defaultInterestModel,
				sdk.MustNewDecFromStr("0.025"), sdk.MustNewDecFromStr("0.02"),
			),
			// ukava
			v0_14hard.NewMoneyMarket("ukava", v0_14hard.NewBorrowLimit(true, sdk.ZeroDec(), sdk.MustNewDecFromStr("0.5")), "kava:usd", sdk.NewInt(1000000),
				defaultInterestModel,
				sdk.MustNewDecFromStr("0.025"), sdk.MustNewDecFromStr("0.02"),
			),
			// hard
			v0_14hard.NewMoneyMarket("hard", v0_14hard.NewBorrowLimit(true, sdk.ZeroDec(), sdk.MustNewDecFromStr("0.5")), "hard:usd", sdk.NewInt(1000000),
				defaultInterestModel,
				sdk.MustNewDecFromStr("0.025"), sdk.MustNewDecFromStr("0.02"),
			),
		},
		sdk.MustNewDecFromStr("10.0"),
	)

	for _, newDep := range v13DepositorMap {
		v13Deposits = append(v13Deposits, newDep)
		v13TotalSupplied = v13TotalSupplied.Add(newDep.Amount...)
	}
	sort.Slice(v13Deposits, func(i, j int) bool {
		return v13Deposits[i].Depositor.String() > v13Deposits[j].Depositor.String()
	})

	for _, mm := range newParams.MoneyMarkets {
		genAccumulationTime := v0_14hard.NewGenesisAccumulationTime(mm.Denom, GenesisTime, sdk.OneDec(), sdk.OneDec())
		v13GenesisAccumulationTimes = append(v13GenesisAccumulationTimes, genAccumulationTime)
	}

	return v0_14hard.NewGenesisState(newParams, v13GenesisAccumulationTimes, v13Deposits, v0_14hard.DefaultBorrows, v13TotalSupplied, v0_14hard.DefaultTotalBorrowed, v0_14hard.DefaultTotalReserves)
}

// Incentive migrates from a v0.11 incentive genesis state to a v0.13 incentive genesis state
func Incentive(hardGS v0_11hard.GenesisState, incentiveGS v0_11incentive.GenesisState) v0_14incentive.GenesisState {
	usdxMintingRewardPeriods := v0_14incentive.RewardPeriods{}
	usdxRewardsPerSecondMap := make(map[string]sdk.Coin)
	usdxRewardsPerSecondMap["bnb-a"] = sdk.NewCoin("ukava", sdk.NewInt(122354))
	usdxRewardsPerSecondMap["btcb-a"] = sdk.NewCoin("ukava", sdk.NewInt(110780))
	usdxRewardsPerSecondMap["busd-a"] = sdk.NewCoin("ukava", sdk.NewInt(30588))
	usdxRewardsPerSecondMap["hard-a"] = sdk.NewCoin("ukava", sdk.NewInt(23809))
	usdxRewardsPerSecondMap["ukava-a"] = sdk.NewCoin("ukava", sdk.NewInt(31746))
	usdxRewardsPerSecondMap["xrpb-a"] = sdk.NewCoin("ukava", sdk.NewInt(31746))
	usdxRewardsPerSecondMap["hbtc-a"] = sdk.NewCoin("ukava", sdk.NewInt(79365))

	for _, rp := range incentiveGS.RewardPeriods {
		rewardsPerSecond, ok := usdxRewardsPerSecondMap[rp.CollateralType]
		if !ok {
			panic(fmt.Sprintf("No rewards per second for collateral type: %s\n", rp.CollateralType))
		}
		newRP := v0_14incentive.NewRewardPeriod(true, rp.CollateralType, GenesisTime, RewardEndTime, rewardsPerSecond)
		usdxMintingRewardPeriods = append(usdxMintingRewardPeriods, newRP)
	}

	hardSupplyRewardPeriods := v0_14incentive.MultiRewardPeriods{}
	for _, rp := range hardGS.Params.LiquidityProviderSchedules {
		newRP := v0_14incentive.NewMultiRewardPeriod(true, rp.DepositDenom, rp.Start, rp.End, sdk.NewCoins(rp.RewardsPerSecond))
		hardSupplyRewardPeriods = append(hardSupplyRewardPeriods, newRP)
	}
	hardBorrowRewardPeriods := v0_14incentive.MultiRewardPeriods{}
	hardDelegatorRewardPeriods := v0_14incentive.RewardPeriods{}
	for _, rp := range hardGS.Params.DelegatorDistributionSchedules {
		newRP := v0_14incentive.NewRewardPeriod(rp.DistributionSchedule.Active, rp.DistributionSchedule.DepositDenom, rp.DistributionSchedule.Start, rp.DistributionSchedule.End, rp.DistributionSchedule.RewardsPerSecond)
		hardDelegatorRewardPeriods = append(hardDelegatorRewardPeriods, newRP)
	}
	params := v0_14incentive.NewParams(usdxMintingRewardPeriods, hardSupplyRewardPeriods, hardBorrowRewardPeriods, hardDelegatorRewardPeriods, v0_14incentive.Multipliers{v0_14incentive.NewMultiplier(v0_14incentive.Small, 1, sdk.MustNewDecFromStr("0.2")), v0_14incentive.NewMultiplier(v0_14incentive.Large, 12, sdk.MustNewDecFromStr("1.0"))}, ClaimEndTime)

	usdxGenAccumulationTimes := v0_14incentive.GenesisAccumulationTimes{}

	for _, rp := range params.USDXMintingRewardPeriods {
		gat := v0_14incentive.NewGenesisAccumulationTime(rp.CollateralType, GenesisTime)
		usdxGenAccumulationTimes = append(usdxGenAccumulationTimes, gat)
	}
	hardSupplyGenAccumulationTimes := v0_14incentive.GenesisAccumulationTimes{}
	for _, rp := range params.HardSupplyRewardPeriods {
		gat := v0_14incentive.NewGenesisAccumulationTime(rp.CollateralType, GenesisTime)
		hardSupplyGenAccumulationTimes = append(hardSupplyGenAccumulationTimes, gat)
	}
	hardBorrowGenAccumulationTimes := v0_14incentive.GenesisAccumulationTimes{}
	for _, rp := range params.HardBorrowRewardPeriods {
		gat := v0_14incentive.NewGenesisAccumulationTime(rp.CollateralType, GenesisTime)
		hardBorrowGenAccumulationTimes = append(hardBorrowGenAccumulationTimes, gat)
	}

	hardDelegatorGenAccumulationTimes := v0_14incentive.GenesisAccumulationTimes{}

	for _, rp := range params.HardDelegatorRewardPeriods {
		gat := v0_14incentive.NewGenesisAccumulationTime(rp.CollateralType, GenesisTime)
		hardDelegatorGenAccumulationTimes = append(hardDelegatorGenAccumulationTimes, gat)
	}

	usdxClaims := v0_14incentive.USDXMintingClaims{}
	usdxClaimMap := make(map[string]v0_14incentive.USDXMintingClaim)
	claimEndMap := make(map[uint64]time.Time)

	for _, cp := range incentiveGS.ClaimPeriods {
		claimEndMap[cp.ID] = cp.End
	}

	for _, claim := range incentiveGS.Claims {
		if claimEndMap[claim.ClaimPeriodID].Before(GenesisTime) {
			continue
		}
		newClaim, ok := usdxClaimMap[claim.Owner.String()]
		if !ok {
			newClaim = v0_14incentive.NewUSDXMintingClaim(claim.Owner, claim.Reward, v0_14incentive.RewardIndexes{v0_14incentive.NewRewardIndex(claim.CollateralType, sdk.ZeroDec())})
		} else {
			newClaim.Reward = newClaim.Reward.Add(claim.Reward)
			_, found := newClaim.RewardIndexes.GetRewardIndex(claim.CollateralType)
			if !found {
				newClaim.RewardIndexes = append(newClaim.RewardIndexes, v0_14incentive.NewRewardIndex(claim.CollateralType, sdk.ZeroDec()))
			}
		}
		usdxClaimMap[newClaim.Owner.String()] = newClaim
	}

	for _, claim := range usdxClaimMap {
		usdxClaims = append(usdxClaims, claim)
	}

	hardClaims := v0_14incentive.HardLiquidityProviderClaims{}
	hardClaimMap := make(map[string]v0_14incentive.HardLiquidityProviderClaim)

	for _, claim := range hardGS.Claims {
		newClaim, ok := hardClaimMap[claim.Owner.String()]
		if !ok {
			// if claim.Type == "lp" -- hard supply
			// if claim.Type == "stake" -- hard delegator
			// hard barrow always empty
			delegatorIndexes := v0_14incentive.RewardIndexes{}
			supplyIndexes := v0_14incentive.MultiRewardIndexes{}
			borrowIndexes := v0_14incentive.MultiRewardIndexes{}
			if claim.Type == v0_11hard.Stake {
				delegatorIndexes = v0_14incentive.RewardIndexes{v0_14incentive.NewRewardIndex(claim.DepositDenom, sdk.ZeroDec())}
			}
			if claim.Type == v0_11hard.LP {
				supplyIndexes = v0_14incentive.MultiRewardIndexes{v0_14incentive.NewMultiRewardIndex(claim.DepositDenom, v0_14incentive.RewardIndexes{v0_14incentive.NewRewardIndex("hard", sdk.ZeroDec())})}
			}
			newClaim = v0_14incentive.NewHardLiquidityProviderClaim(claim.Owner, sdk.NewCoins(claim.Amount), supplyIndexes, borrowIndexes, delegatorIndexes)
		} else {
			newClaim.Reward = newClaim.Reward.Add(claim.Amount)
			if claim.Type == v0_11hard.Stake {
				newClaim.DelegatorRewardIndexes = v0_14incentive.RewardIndexes{v0_14incentive.NewRewardIndex(claim.DepositDenom, sdk.ZeroDec())}
			}
			if claim.Type == v0_11hard.LP {
				_, found := newClaim.SupplyRewardIndexes.GetRewardIndex(claim.DepositDenom)
				if !found {
					newClaim.SupplyRewardIndexes = append(newClaim.SupplyRewardIndexes, v0_14incentive.NewMultiRewardIndex(claim.DepositDenom, v0_14incentive.RewardIndexes{v0_14incentive.NewRewardIndex("hard", sdk.ZeroDec())}))
				}
			}
		}
		hardClaimMap[claim.Owner.String()] = newClaim
	}

	for _, claim := range hardClaimMap {
		hardClaims = append(hardClaims, claim)
	}

	sort.Slice(hardClaims, func(i, j int) bool { return hardClaims[i].Owner.String() < hardClaims[j].Owner.String() })
	sort.Slice(usdxClaims, func(i, j int) bool { return usdxClaims[i].Owner.String() < usdxClaims[j].Owner.String() })

	return v0_14incentive.NewGenesisState(
		params,
		usdxGenAccumulationTimes,
		hardSupplyGenAccumulationTimes,
		hardBorrowGenAccumulationTimes,
		hardDelegatorGenAccumulationTimes,
		usdxClaims,
		hardClaims,
	)
}

// Auth migrates from a v0.11 auth genesis state to a v0.13
func Auth(genesisState auth.GenesisState) auth.GenesisState {
	validatorVestingChangeAddress, err := sdk.AccAddressFromBech32("kava1a3qmze57knfj29a5knqs5ptewh76v4fg23xsvn")
	if err != nil {
		panic(err)
	}
	validatorVestingUpdatedValAddress, err := sdk.ConsAddressFromBech32("kavavalcons1ucxhn6zh7y2zun49m36psjffrhmux7ukqxdcte")
	if err != nil {
		panic(err)
	}

	savingsRateMaccCoins := sdk.NewCoins()
	savingsMaccAddr := supply.NewModuleAddress(v0_11cdp.SavingsRateMacc)
	savingsRateMaccIndex := 0
	liquidatorMaccIndex := 0

	// moves hard distributions from hard module account to kavadist module account
	hardDelegatorAddr := supply.NewModuleAddress(v0_11hard.DelegatorAccount)
	hardDelegatorIdx := 0
	hardDelegatorCoins := sdk.NewCoins()
	hardLPAddr := supply.NewModuleAddress(v0_11hard.LPAccount)
	hardLPIdx := 0
	hardLPCoins := sdk.NewCoins()

	harvestAddr := supply.NewModuleAddress(v0_11hard.ModuleAccountName)
	harvestIdx := 0

	kavaDistAddr := supply.NewModuleAddress(kavadist.KavaDistMacc)
	kavaDistIdx := 0

	for idx, acc := range genesisState.Accounts {
		// reset validator vesting missed blocks to zero (due to ongoing network issues in kava-4)
		vvacc, ok := acc.(*validatorvesting.ValidatorVestingAccount)
		if ok {
			vvacc.CurrentPeriodProgress.MissedBlocks = 0
			if vvacc.GetAddress().Equals(validatorVestingChangeAddress) {
				// update validator vesting validator address for shiprekt
				vvacc.ValidatorAddress = validatorVestingUpdatedValAddress
			}
		}
		if acc.GetAddress().Equals(savingsMaccAddr) {
			savingsRateMaccCoins = acc.GetCoins()
			savingsRateMaccIndex = idx
			err := acc.SetCoins(acc.GetCoins().Sub(acc.GetCoins()))
			if err != nil {
				panic(err)
			}
		}
		if acc.GetAddress().Equals(supply.NewModuleAddress(v0_14cdp.LiquidatorMacc)) {
			liquidatorMaccIndex = idx
		}
		if acc.GetAddress().Equals(hardDelegatorAddr) {
			hardDelegatorIdx = idx
			hardDelegatorCoins = acc.GetCoins()
		}
		if acc.GetAddress().Equals(hardLPAddr) {
			hardLPIdx = idx
			hardLPCoins = acc.GetCoins()
		}
		if acc.GetAddress().Equals(kavaDistAddr) {
			kavaDistIdx = idx
		}
		if acc.GetAddress().Equals(harvestAddr) {
			harvestIdx = idx

		}
	}
	// move remaining cdp savings to liquidator account
	liquidatorAcc := genesisState.Accounts[liquidatorMaccIndex]
	err = liquidatorAcc.SetCoins(liquidatorAcc.GetCoins().Add(savingsRateMaccCoins...))
	if err != nil {
		panic(err)
	}
	genesisState.Accounts[liquidatorMaccIndex] = liquidatorAcc

	// migrate harvest account to new hard name
	harvestAcc := genesisState.Accounts[harvestIdx].(*supply.ModuleAccount)
	harvestAcc.Address = supply.NewModuleAddress(v0_14hard.ModuleAccountName)
	harvestAcc.Name = v0_14hard.ModuleAccountName
	harvestAcc.Permissions = []string{supply.Minter}
	genesisState.Accounts[harvestIdx] = harvestAcc

	// add hard module accounts to kavadist
	kavaDistAcc := genesisState.Accounts[kavaDistIdx]
	err = kavaDistAcc.SetCoins(kavaDistAcc.GetCoins().Add(hardDelegatorCoins...).Add(hardLPCoins...))
	if err != nil {
		panic(err)
	}
	genesisState.Accounts[kavaDistIdx] = kavaDistAcc

	// reverse sort indexes of accounts to remove so that re-numbering is irrelevant
	indexesToRemove := []int{savingsRateMaccIndex, hardDelegatorIdx, hardLPIdx}
	sort.Slice(indexesToRemove, func(i, j int) bool { return indexesToRemove[i] > indexesToRemove[j] })

	// delete hard delegator, hard lp, and savings rate module accounts
	for _, idx := range indexesToRemove {
		genesisState.Accounts = removeIndex(genesisState.Accounts, idx)
	}

	return genesisState
}

// Bep3 migrates a v0.11 bep3 genesis state to a v0.13 genesis state
func Bep3(genesisState bep3.GenesisState) bep3.GenesisState {
	var newSupplies bep3.AssetSupplies
	for _, supply := range genesisState.Supplies {
		if supply.GetDenom() == "bnb" {
			supply.CurrentSupply = supply.CurrentSupply.Sub(sdk.NewCoin("bnb", sdk.NewInt(1000000000000)))
		}
		newSupplies = append(newSupplies, supply)
	}
	var newSwaps bep3.AtomicSwaps
	for _, swap := range genesisState.AtomicSwaps {
		if swap.Status == bep3.Completed {
			swap.ClosedBlock = 1 // reset closed block to one so completed swaps are removed from long term storage properly
		}
		if swap.Status == bep3.Open || swap.Status == bep3.Expired {
			swap.Status = bep3.Expired // set open swaps to expired so they can be refunded after chain start
			swap.ExpireHeight = 1      // set expire on first block as well to be safe
		}
		newSwaps = append(newSwaps, swap)
	}
	var newAssetParams bep3.AssetParams
	for _, ap := range genesisState.Params.AssetParams {
		ap.MinBlockLock = uint64(24686)
		ap.MaxBlockLock = uint64(86400)
		newAssetParams = append(newAssetParams, ap)
	}
	newParams := bep3.NewParams(newAssetParams)
	return bep3.NewGenesisState(newParams, newSwaps, newSupplies, genesisState.PreviousBlockTime)
}

// Committee migrates from a v0.11 (or v0.12) committee genesis state to a v0.13 committee genesis state
func Committee(genesisState v0_11committee.GenesisState) v0_14committee.GenesisState {
	committees := []v0_14committee.Committee{}
	votes := []v0_14committee.Vote{}
	proposals := []v0_14committee.Proposal{}

	var newStabilityCommittee v0_14committee.Committee
	var newSafetyCommittee v0_14committee.Committee

	for _, com := range genesisState.Committees {
		if com.ID == 1 {
			newStabilityCommittee.Description = com.Description
			newStabilityCommittee.ID = com.ID
			newStabilityCommittee.Members = com.Members
			newStabilityCommittee.VoteThreshold = com.VoteThreshold
			newStabilityCommittee.ProposalDuration = com.ProposalDuration
			var newStabilityCommitteePermissions []v0_14committee.Permission
			var newStabilitySubParamPermissions v0_14committee.SubParamChangePermission

			for _, perm := range com.Permissions {
				subPerm, ok := perm.(v0_11committee.SubParamChangePermission)
				if ok {
					// update AllowedParams
					var newAllowedParams v0_14committee.AllowedParams
					for _, ap := range subPerm.AllowedParams {
						if ap.Subspace == "harvest" {
							continue
						}
						newAP := v0_14committee.AllowedParam(ap)
						newAllowedParams = append(newAllowedParams, newAP)
					}
					hrdaMMAp := v0_14committee.AllowedParam{Subspace: "hard", Key: "MoneyMarkets"}
					hardLimitAp := v0_14committee.AllowedParam{Subspace: "hard", Key: "MinimumBorrowUSDValue"}
					newAllowedParams = append(newAllowedParams, hrdaMMAp)
					newAllowedParams = append(newAllowedParams, hardLimitAp)

					newStabilitySubParamPermissions.AllowedParams = newAllowedParams

					// update AllowedCollateralParams
					var newCollateralParams v0_14committee.AllowedCollateralParams
					collateralTypes := []string{"bnb-a", "busd-a", "busd-b", "btcb-a", "xrpb-a", "ukava-a", "hard-a", "hbtc-a"}
					for _, cp := range subPerm.AllowedCollateralParams {
						newCP := v0_14committee.NewAllowedCollateralParam(
							cp.Type,
							cp.Denom,
							cp.LiquidationRatio,
							cp.DebtLimit,
							cp.StabilityFee,
							cp.AuctionSize,
							cp.LiquidationPenalty,
							cp.Prefix,
							cp.SpotMarketID,
							cp.LiquidationMarketID,
							cp.ConversionFactor,
							true,
							true,
						)
						newCollateralParams = append(newCollateralParams, newCP)
					}
					for _, cType := range collateralTypes {
						var foundCtype bool
						for _, cp := range newCollateralParams {
							if cType == cp.Type {
								foundCtype = true
							}
						}
						if !foundCtype {
							newCP := v0_14committee.NewAllowedCollateralParam(cType, false, false, true, true, true, false, false, false, false, false, true, true)
							newCollateralParams = append(newCollateralParams, newCP)
						}
					}
					newStabilitySubParamPermissions.AllowedCollateralParams = newCollateralParams

					// update AllowedDebtParam
					newDP := v0_14committee.AllowedDebtParam{
						Denom:            subPerm.AllowedDebtParam.Denom,
						ReferenceAsset:   subPerm.AllowedDebtParam.ReferenceAsset,
						ConversionFactor: subPerm.AllowedDebtParam.ConversionFactor,
						DebtFloor:        subPerm.AllowedDebtParam.DebtFloor,
					}
					newStabilitySubParamPermissions.AllowedDebtParam = newDP

					// update AllowedAssetParams
					var newAssetParams v0_14committee.AllowedAssetParams
					for _, ap := range subPerm.AllowedAssetParams {
						newAP := v0_14committee.AllowedAssetParam(ap)
						newAssetParams = append(newAssetParams, newAP)
					}
					newStabilitySubParamPermissions.AllowedAssetParams = newAssetParams

					// Update Allowed Markets
					var newMarketParams v0_14committee.AllowedMarkets
					for _, mp := range subPerm.AllowedMarkets {
						newMP := v0_14committee.AllowedMarket(mp)
						newMarketParams = append(newMarketParams, newMP)
					}
					newStabilitySubParamPermissions.AllowedMarkets = newMarketParams

					// Add hard money market committee permissions
					var newMoneyMarketParams v0_14committee.AllowedMoneyMarkets
					hardMMDenoms := []string{"bnb", "busd", "btcb", "xrpb", "usdx", "ukava", "hard"}
					for _, mmDenom := range hardMMDenoms {
						newMoneyMarketParam := v0_14committee.NewAllowedMoneyMarket(mmDenom, true, false, false, true, true, true)
						newMoneyMarketParams = append(newMoneyMarketParams, newMoneyMarketParam)
					}
					newStabilitySubParamPermissions.AllowedMoneyMarkets = newMoneyMarketParams
					newStabilityCommitteePermissions = append(newStabilityCommitteePermissions, newStabilitySubParamPermissions)
				}
			}
			newStabilityCommitteePermissions = append(newStabilityCommitteePermissions, v0_14committee.TextPermission{})
			newStabilityCommittee.Permissions = newStabilityCommitteePermissions
			committees = append(committees, newStabilityCommittee)
		} else {
			newSafetyCommittee.ID = com.ID
			newSafetyCommittee.Description = com.Description
			newSafetyCommittee.Members = com.Members
			newSafetyCommittee.Permissions = []v0_14committee.Permission{v0_14committee.SoftwareUpgradePermission{}}
			newSafetyCommittee.VoteThreshold = com.VoteThreshold
			newSafetyCommittee.ProposalDuration = com.ProposalDuration
			committees = append(committees, newSafetyCommittee)
		}
	}

	for _, v := range genesisState.Votes {
		votes = append(votes, v0_14committee.Vote(v))
	}

	for _, p := range genesisState.Proposals {
		newPubProp := v0_14committee.PubProposal(p.PubProposal)
		newProp := v0_14committee.NewProposal(newPubProp, p.ID, p.CommitteeID, p.Deadline)
		proposals = append(proposals, newProp)
	}
	return v0_14committee.NewGenesisState(
		genesisState.NextProposalID, committees, proposals, votes)
}

// Pricefeed migrates from a v0.11 (or v0.12) pricefeed genesis state to a v0.13 pricefeed genesis state
func Pricefeed(genesisState v0_11pricefeed.GenesisState) v0_14pricefeed.GenesisState {
	newMarkets := v0_14pricefeed.Markets{}
	oracles := genesisState.Params.Markets[0].Oracles

	for _, m := range genesisState.Params.Markets {
		newMarkets = append(newMarkets, m)
	}
	usdx := v0_11pricefeed.NewMarket("usdx:usd", "usdx", "usd", oracles, true)
	newMarkets = append(newMarkets, usdx)

	newPrices := v0_14pricefeed.PostedPrices{}

	for _, p := range genesisState.PostedPrices {
		if p.Expiry.After(GenesisTime) {
			newPrices = append(newPrices, p)
		}
	}

	return v0_14pricefeed.NewGenesisState(v0_14pricefeed.NewParams(newMarkets), newPrices)
}

func removeIndex(accs authexported.GenesisAccounts, index int) authexported.GenesisAccounts {
	ret := make(authexported.GenesisAccounts, 0)
	ret = append(ret, accs[:index]...)
	newAccounts := append(ret, accs[index+1:]...)
	return newAccounts
}