package keeper_test

import (
	"context"
	"encoding/json"
	"testing"
	"time"

	"github.com/stretchr/testify/suite"
	"go.uber.org/mock/gomock"

	coreaddress "cosmossdk.io/core/address"
	"cosmossdk.io/log"
	storetypes "cosmossdk.io/store/types"
	banktypes "cosmossdk.io/x/bank/types"
	"cosmossdk.io/x/group"
	"cosmossdk.io/x/group/keeper"
	"cosmossdk.io/x/group/module"
	grouptestutil "cosmossdk.io/x/group/testutil"

	"github.com/cosmos/cosmos-sdk/baseapp"
	"github.com/cosmos/cosmos-sdk/codec"
	"github.com/cosmos/cosmos-sdk/codec/address"
	codectestutil "github.com/cosmos/cosmos-sdk/codec/testutil"
	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
	"github.com/cosmos/cosmos-sdk/runtime"
	"github.com/cosmos/cosmos-sdk/testutil"
	sdk "github.com/cosmos/cosmos-sdk/types"
	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
)

type GenesisTestSuite struct {
	suite.Suite

	ctx          context.Context
	sdkCtx       sdk.Context
	keeper       keeper.Keeper
	cdc          *codec.ProtoCodec
	addressCodec coreaddress.Codec
}

func TestGenesisTestSuite(t *testing.T) {
	suite.Run(t, new(GenesisTestSuite))
}

var (
	memberPub  = secp256k1.GenPrivKey().PubKey()
	accPub     = secp256k1.GenPrivKey().PubKey()
	accAddr    = sdk.AccAddress(accPub.Address())
	memberAddr = sdk.AccAddress(memberPub.Address())
)

func (s *GenesisTestSuite) SetupTest() {
	key := storetypes.NewKVStoreKey(group.StoreKey)
	storeService := runtime.NewKVStoreService(key)
	testCtx := testutil.DefaultContextWithDB(s.T(), key, storetypes.NewTransientStoreKey("transient_test"))
	encCfg := moduletestutil.MakeTestEncodingConfig(codectestutil.CodecOptions{}, module.AppModule{})

	ctrl := gomock.NewController(s.T())
	accountKeeper := grouptestutil.NewMockAccountKeeper(ctrl)
	accountKeeper.EXPECT().GetAccount(gomock.Any(), accAddr).Return(authtypes.NewBaseAccountWithAddress(accAddr)).AnyTimes()
	accountKeeper.EXPECT().GetAccount(gomock.Any(), memberAddr).Return(authtypes.NewBaseAccountWithAddress(memberAddr)).AnyTimes()
	accountKeeper.EXPECT().AddressCodec().Return(address.NewBech32Codec("cosmos")).AnyTimes()

	bApp := baseapp.NewBaseApp(
		"group",
		log.NewNopLogger(),
		testCtx.DB,
		encCfg.TxConfig.TxDecoder(),
	)

	banktypes.RegisterInterfaces(encCfg.InterfaceRegistry)

	s.sdkCtx = testCtx.Ctx
	s.cdc = codec.NewProtoCodec(encCfg.InterfaceRegistry)
	s.ctx = s.sdkCtx
	s.addressCodec = address.NewBech32Codec("cosmos")

	env := runtime.NewEnvironment(storeService, log.NewNopLogger(), runtime.EnvWithQueryRouterService(bApp.GRPCQueryRouter()), runtime.EnvWithMsgRouterService(bApp.MsgServiceRouter()))
	s.keeper = keeper.NewKeeper(env, s.cdc, accountKeeper, group.DefaultConfig())
}

func (s *GenesisTestSuite) TestInitExportGenesis() {
	sdkCtx := s.sdkCtx
	ctx := s.ctx
	cdc := s.cdc

	submittedAt := time.Now().UTC()
	timeout := submittedAt.Add(time.Second * 1).UTC()

	accStrAddr, err := s.addressCodec.BytesToString(accAddr)
	s.Require().NoError(err)
	memberStrAddr, err := s.addressCodec.BytesToString(memberAddr)
	s.Require().NoError(err)

	groupPolicy := &group.GroupPolicyInfo{
		Address:  accStrAddr,
		GroupId:  1,
		Admin:    accStrAddr,
		Version:  1,
		Metadata: "policy metadata",
	}
	err = groupPolicy.SetDecisionPolicy(&group.ThresholdDecisionPolicy{
		Threshold: "1",
		Windows: &group.DecisionPolicyWindows{
			VotingPeriod: time.Second,
		},
	})
	s.Require().NoError(err)

	proposal := &group.Proposal{
		Id:                 1,
		GroupPolicyAddress: accStrAddr,
		Metadata:           "proposal metadata",
		GroupVersion:       1,
		GroupPolicyVersion: 1,
		Proposers: []string{
			memberStrAddr,
		},
		SubmitTime: submittedAt,
		Status:     group.PROPOSAL_STATUS_ACCEPTED,
		FinalTallyResult: group.TallyResult{
			YesCount:        "1",
			NoCount:         "0",
			AbstainCount:    "0",
			NoWithVetoCount: "0",
		},
		VotingPeriodEnd: timeout,
		ExecutorResult:  group.PROPOSAL_EXECUTOR_RESULT_SUCCESS,
	}
	err = proposal.SetMsgs([]sdk.Msg{&banktypes.MsgSend{
		FromAddress: accStrAddr,
		ToAddress:   memberStrAddr,
		Amount:      sdk.Coins{sdk.NewInt64Coin("test", 100)},
	}})
	s.Require().NoError(err)

	genesisState := &group.GenesisState{
		GroupSeq:       2,
		Groups:         []*group.GroupInfo{{Id: 1, Admin: accStrAddr, Metadata: "1", Version: 1, TotalWeight: "1"}, {Id: 2, Admin: accStrAddr, Metadata: "2", Version: 2, TotalWeight: "2"}},
		GroupMembers:   []*group.GroupMember{{GroupId: 1, Member: &group.Member{Address: memberStrAddr, Weight: "1", Metadata: "member metadata"}}, {GroupId: 2, Member: &group.Member{Address: memberStrAddr, Weight: "2", Metadata: "member metadata"}}},
		GroupPolicySeq: 1,
		GroupPolicies:  []*group.GroupPolicyInfo{groupPolicy},
		ProposalSeq:    1,
		Proposals:      []*group.Proposal{proposal},
		Votes:          []*group.Vote{{ProposalId: proposal.Id, Voter: memberStrAddr, SubmitTime: submittedAt, Option: group.VOTE_OPTION_YES}},
	}
	genesisBytes, err := cdc.MarshalJSON(genesisState)
	s.Require().NoError(err)

	genesisData := map[string]json.RawMessage{
		group.ModuleName: genesisBytes,
	}

	err = s.keeper.InitGenesis(sdkCtx, cdc, genesisData[group.ModuleName])
	s.Require().NoError(err)

	for i, g := range genesisState.Groups {
		res, err := s.keeper.GroupInfo(ctx, &group.QueryGroupInfoRequest{
			GroupId: g.Id,
		})
		s.Require().NoError(err)
		s.Require().Equal(g, res.Info)

		membersRes, err := s.keeper.GroupMembers(ctx, &group.QueryGroupMembersRequest{
			GroupId: g.Id,
		})
		s.Require().NoError(err)
		s.Require().Equal(len(membersRes.Members), 1)
		s.Require().Equal(membersRes.Members[0], genesisState.GroupMembers[i])
	}

	for _, g := range genesisState.GroupPolicies {
		res, err := s.keeper.GroupPolicyInfo(ctx, &group.QueryGroupPolicyInfoRequest{
			Address: g.Address,
		})
		s.Require().NoError(err)
		s.assertGroupPoliciesEqual(g, res.Info)
	}

	for _, g := range genesisState.Proposals {
		res, err := s.keeper.Proposal(ctx, &group.QueryProposalRequest{
			ProposalId: g.Id,
		})
		s.Require().NoError(err)
		s.assertProposalsEqual(g, res.Proposal)

		votesRes, err := s.keeper.VotesByProposal(ctx, &group.QueryVotesByProposalRequest{
			ProposalId: g.Id,
		})
		s.Require().NoError(err)
		s.Require().Equal(len(votesRes.Votes), 1)
		s.Require().Equal(votesRes.Votes[0], genesisState.Votes[0])
	}

	exported, err := s.keeper.ExportGenesis(sdkCtx, cdc)
	s.Require().NoError(err)
	bz, err := cdc.MarshalJSON(exported)
	s.Require().NoError(err)

	var exportedGenesisState group.GenesisState
	err = cdc.UnmarshalJSON(bz, &exportedGenesisState)
	s.Require().NoError(err)

	s.Require().Equal(genesisState.Groups, exportedGenesisState.Groups)
	s.Require().Equal(genesisState.GroupMembers, exportedGenesisState.GroupMembers)

	s.Require().Equal(len(genesisState.GroupPolicies), len(exportedGenesisState.GroupPolicies))
	for i, g := range genesisState.GroupPolicies {
		res := exportedGenesisState.GroupPolicies[i]
		s.Require().NoError(err)
		s.assertGroupPoliciesEqual(g, res)
	}

	s.Require().Equal(len(genesisState.Proposals), len(exportedGenesisState.Proposals))
	for i, g := range genesisState.Proposals {
		res := exportedGenesisState.Proposals[i]
		s.Require().NoError(err)
		s.assertProposalsEqual(g, res)
	}
	s.Require().Equal(genesisState.Votes, exportedGenesisState.Votes)

	s.Require().Equal(genesisState.GroupSeq, exportedGenesisState.GroupSeq)
	s.Require().Equal(genesisState.GroupPolicySeq, exportedGenesisState.GroupPolicySeq)
	s.Require().Equal(genesisState.ProposalSeq, exportedGenesisState.ProposalSeq)
}

func (s *GenesisTestSuite) assertGroupPoliciesEqual(g, other *group.GroupPolicyInfo) {
	require := s.Require()
	require.Equal(g.Address, other.Address)
	require.Equal(g.GroupId, other.GroupId)
	require.Equal(g.Admin, other.Admin)
	require.Equal(g.Metadata, other.Metadata)
	require.Equal(g.Version, other.Version)
	dp1, err := g.GetDecisionPolicy()
	require.NoError(err)
	dp2, err := other.GetDecisionPolicy()
	require.NoError(err)
	require.Equal(dp1, dp2)
}

func (s *GenesisTestSuite) assertProposalsEqual(g, other *group.Proposal) {
	require := s.Require()
	require.Equal(g.Id, other.Id)
	require.Equal(g.GroupPolicyAddress, other.GroupPolicyAddress)
	require.Equal(g.Metadata, other.Metadata)
	require.Equal(g.Proposers, other.Proposers)
	require.Equal(g.SubmitTime, other.SubmitTime)
	require.Equal(g.GroupVersion, other.GroupVersion)
	require.Equal(g.GroupPolicyVersion, other.GroupPolicyVersion)
	require.Equal(g.Status, other.Status)
	require.Equal(g.FinalTallyResult, other.FinalTallyResult)
	require.Equal(g.VotingPeriodEnd, other.VotingPeriodEnd)
	require.Equal(g.ExecutorResult, other.ExecutorResult)
	msgs1, err := g.GetMsgs()
	require.NoError(err)
	msgs2, err := other.GetMsgs()
	require.NoError(err)
	require.Equal(msgs1, msgs2)
}