package privval

import (
	"context"
	"fmt"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"github.com/tendermint/tendermint/crypto"
	"github.com/tendermint/tendermint/crypto/tmhash"
	tmrand "github.com/tendermint/tendermint/libs/rand"
	cryptoproto "github.com/tendermint/tendermint/proto/tendermint/crypto"
	privvalproto "github.com/tendermint/tendermint/proto/tendermint/privval"
	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
	"github.com/tendermint/tendermint/types"
)

type signerTestCase struct {
	chainID      string
	mockPV       types.PrivValidator
	signerClient *SignerClient
	signerServer *SignerServer
	name         string
	closer       context.CancelFunc
}

func getSignerTestCases(ctx context.Context, t *testing.T) []signerTestCase {
	t.Helper()

	testCases := make([]signerTestCase, 0)

	// Get test cases for each possible dialer (DialTCP / DialUnix / etc)
	for idx, dtc := range getDialerTestCases(t) {
		chainID := tmrand.Str(12)
		mockPV := types.NewMockPV()

		cctx, ccancel := context.WithCancel(ctx)
		// get a pair of signer listener, signer dialer endpoints
		sl, sd := getMockEndpoints(cctx, t, dtc.addr, dtc.dialer)
		sc, err := NewSignerClient(cctx, sl, chainID)
		require.NoError(t, err)
		ss := NewSignerServer(sd, chainID, mockPV)

		require.NoError(t, ss.Start(cctx))

		testCases = append(testCases, signerTestCase{
			name:         fmt.Sprintf("Case%d%T_%s", idx, dtc.dialer, chainID),
			closer:       ccancel,
			chainID:      chainID,
			mockPV:       mockPV,
			signerClient: sc,
			signerServer: ss,
		})
	}

	return testCases
}

func TestSignerClose(t *testing.T) {
	bctx, bcancel := context.WithCancel(context.Background())
	defer bcancel()

	for _, tc := range getSignerTestCases(bctx, t) {
		t.Run(tc.name, func(t *testing.T) {
			defer tc.closer()

			assert.NoError(t, tc.signerClient.Close())
			assert.NoError(t, tc.signerServer.Stop())
		})
	}
}

func TestSignerPing(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	for _, tc := range getSignerTestCases(ctx, t) {
		err := tc.signerClient.Ping()
		assert.NoError(t, err)
	}
}

func TestSignerGetPubKey(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	for _, tc := range getSignerTestCases(ctx, t) {
		t.Run(tc.name, func(t *testing.T) {
			defer tc.closer()

			pubKey, err := tc.signerClient.GetPubKey(ctx)
			require.NoError(t, err)
			expectedPubKey, err := tc.mockPV.GetPubKey(ctx)
			require.NoError(t, err)

			assert.Equal(t, expectedPubKey, pubKey)

			pubKey, err = tc.signerClient.GetPubKey(ctx)
			require.NoError(t, err)
			expectedpk, err := tc.mockPV.GetPubKey(ctx)
			require.NoError(t, err)
			expectedAddr := expectedpk.Address()

			assert.Equal(t, expectedAddr, pubKey.Address())
		})
	}
}

func TestSignerProposal(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	for _, tc := range getSignerTestCases(ctx, t) {
		t.Run(tc.name, func(t *testing.T) {
			defer tc.closer()

			ts := time.Now()
			hash := tmrand.Bytes(tmhash.Size)
			have := &types.Proposal{
				Type:      tmproto.ProposalType,
				Height:    1,
				Round:     2,
				POLRound:  2,
				BlockID:   types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
				Timestamp: ts,
			}
			want := &types.Proposal{
				Type:      tmproto.ProposalType,
				Height:    1,
				Round:     2,
				POLRound:  2,
				BlockID:   types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
				Timestamp: ts,
			}

			require.NoError(t, tc.mockPV.SignProposal(ctx, tc.chainID, want.ToProto()))
			require.NoError(t, tc.signerClient.SignProposal(ctx, tc.chainID, have.ToProto()))

			assert.Equal(t, want.Signature, have.Signature)
		})

	}
}

func TestSignerVote(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	for _, tc := range getSignerTestCases(ctx, t) {
		t.Run(tc.name, func(t *testing.T) {
			defer tc.closer()

			ts := time.Now()
			hash := tmrand.Bytes(tmhash.Size)
			valAddr := tmrand.Bytes(crypto.AddressSize)
			want := &types.Vote{
				Type:             tmproto.PrecommitType,
				Height:           1,
				Round:            2,
				BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
				Timestamp:        ts,
				ValidatorAddress: valAddr,
				ValidatorIndex:   1,
			}

			have := &types.Vote{
				Type:             tmproto.PrecommitType,
				Height:           1,
				Round:            2,
				BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
				Timestamp:        ts,
				ValidatorAddress: valAddr,
				ValidatorIndex:   1,
			}

			require.NoError(t, tc.mockPV.SignVote(ctx, tc.chainID, want.ToProto()))
			require.NoError(t, tc.signerClient.SignVote(ctx, tc.chainID, have.ToProto()))

			assert.Equal(t, want.Signature, have.Signature)
		})
	}
}

func TestSignerVoteResetDeadline(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	for _, tc := range getSignerTestCases(ctx, t) {
		t.Run(tc.name, func(t *testing.T) {
			ts := time.Now()
			hash := tmrand.Bytes(tmhash.Size)
			valAddr := tmrand.Bytes(crypto.AddressSize)
			want := &types.Vote{
				Type:             tmproto.PrecommitType,
				Height:           1,
				Round:            2,
				BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
				Timestamp:        ts,
				ValidatorAddress: valAddr,
				ValidatorIndex:   1,
			}

			have := &types.Vote{
				Type:             tmproto.PrecommitType,
				Height:           1,
				Round:            2,
				BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
				Timestamp:        ts,
				ValidatorAddress: valAddr,
				ValidatorIndex:   1,
			}

			time.Sleep(testTimeoutReadWrite2o3)

			require.NoError(t, tc.mockPV.SignVote(ctx, tc.chainID, want.ToProto()))
			require.NoError(t, tc.signerClient.SignVote(ctx, tc.chainID, have.ToProto()))
			assert.Equal(t, want.Signature, have.Signature)

			// TODO(jleni): Clarify what is actually being tested

			// This would exceed the deadline if it was not extended by the previous message
			time.Sleep(testTimeoutReadWrite2o3)

			require.NoError(t, tc.mockPV.SignVote(ctx, tc.chainID, want.ToProto()))
			require.NoError(t, tc.signerClient.SignVote(ctx, tc.chainID, have.ToProto()))
			assert.Equal(t, want.Signature, have.Signature)
		})
	}
}

func TestSignerVoteKeepAlive(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	for _, tc := range getSignerTestCases(ctx, t) {
		t.Run(tc.name, func(t *testing.T) {
			defer tc.closer()

			ts := time.Now()
			hash := tmrand.Bytes(tmhash.Size)
			valAddr := tmrand.Bytes(crypto.AddressSize)
			want := &types.Vote{
				Type:             tmproto.PrecommitType,
				Height:           1,
				Round:            2,
				BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
				Timestamp:        ts,
				ValidatorAddress: valAddr,
				ValidatorIndex:   1,
			}

			have := &types.Vote{
				Type:             tmproto.PrecommitType,
				Height:           1,
				Round:            2,
				BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
				Timestamp:        ts,
				ValidatorAddress: valAddr,
				ValidatorIndex:   1,
			}

			// Check that even if the client does not request a
			// signature for a long time. The service is still available

			// in this particular case, we use the dialer logger to ensure that
			// test messages are properly interleaved in the test logs
			tc.signerServer.endpoint.logger.Debug("TEST: Forced Wait -------------------------------------------------")
			time.Sleep(testTimeoutReadWrite * 3)
			tc.signerServer.endpoint.logger.Debug("TEST: Forced Wait DONE---------------------------------------------")

			require.NoError(t, tc.mockPV.SignVote(ctx, tc.chainID, want.ToProto()))
			require.NoError(t, tc.signerClient.SignVote(ctx, tc.chainID, have.ToProto()))

			assert.Equal(t, want.Signature, have.Signature)
		})
	}
}

func TestSignerSignProposalErrors(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	for _, tc := range getSignerTestCases(ctx, t) {
		t.Run(tc.name, func(t *testing.T) {
			defer tc.closer()
			// Replace service with a mock that always fails
			tc.signerServer.privVal = types.NewErroringMockPV()
			tc.mockPV = types.NewErroringMockPV()

			ts := time.Now()
			hash := tmrand.Bytes(tmhash.Size)
			proposal := &types.Proposal{
				Type:      tmproto.ProposalType,
				Height:    1,
				Round:     2,
				POLRound:  2,
				BlockID:   types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
				Timestamp: ts,
				Signature: []byte("signature"),
			}

			err := tc.signerClient.SignProposal(ctx, tc.chainID, proposal.ToProto())
			rserr, ok := err.(*RemoteSignerError)
			require.True(t, ok, "%T", err)
			require.Contains(t, rserr.Error(), types.ErroringMockPVErr.Error())

			err = tc.mockPV.SignProposal(ctx, tc.chainID, proposal.ToProto())
			require.Error(t, err)

			err = tc.signerClient.SignProposal(ctx, tc.chainID, proposal.ToProto())
			require.Error(t, err)
		})
	}
}

func TestSignerSignVoteErrors(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	for _, tc := range getSignerTestCases(ctx, t) {
		t.Run(tc.name, func(t *testing.T) {
			defer tc.closer()

			ts := time.Now()
			hash := tmrand.Bytes(tmhash.Size)
			valAddr := tmrand.Bytes(crypto.AddressSize)
			vote := &types.Vote{
				Type:             tmproto.PrecommitType,
				Height:           1,
				Round:            2,
				BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
				Timestamp:        ts,
				ValidatorAddress: valAddr,
				ValidatorIndex:   1,
				Signature:        []byte("signature"),
			}

			// Replace signer service privval with one that always fails
			tc.signerServer.privVal = types.NewErroringMockPV()
			tc.mockPV = types.NewErroringMockPV()

			err := tc.signerClient.SignVote(ctx, tc.chainID, vote.ToProto())
			rserr, ok := err.(*RemoteSignerError)
			require.True(t, ok, "%T", err)
			require.Contains(t, rserr.Error(), types.ErroringMockPVErr.Error())

			err = tc.mockPV.SignVote(ctx, tc.chainID, vote.ToProto())
			require.Error(t, err)

			err = tc.signerClient.SignVote(ctx, tc.chainID, vote.ToProto())
			require.Error(t, err)
		})
	}
}

func brokenHandler(ctx context.Context, privVal types.PrivValidator, request privvalproto.Message,
	chainID string) (privvalproto.Message, error) {
	var res privvalproto.Message
	var err error

	switch r := request.Sum.(type) {
	// This is broken and will answer most requests with a pubkey response
	case *privvalproto.Message_PubKeyRequest:
		res = mustWrapMsg(&privvalproto.PubKeyResponse{PubKey: cryptoproto.PublicKey{}, Error: nil})
	case *privvalproto.Message_SignVoteRequest:
		res = mustWrapMsg(&privvalproto.PubKeyResponse{PubKey: cryptoproto.PublicKey{}, Error: nil})
	case *privvalproto.Message_SignProposalRequest:
		res = mustWrapMsg(&privvalproto.PubKeyResponse{PubKey: cryptoproto.PublicKey{}, Error: nil})
	case *privvalproto.Message_PingRequest:
		err, res = nil, mustWrapMsg(&privvalproto.PingResponse{})
	default:
		err = fmt.Errorf("unknown msg: %v", r)
	}

	return res, err
}

func TestSignerUnexpectedResponse(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	for _, tc := range getSignerTestCases(ctx, t) {
		t.Run(tc.name, func(t *testing.T) {
			defer tc.closer()

			tc.signerServer.privVal = types.NewMockPV()
			tc.mockPV = types.NewMockPV()

			tc.signerServer.SetRequestHandler(brokenHandler)

			ts := time.Now()
			want := &types.Vote{Timestamp: ts, Type: tmproto.PrecommitType}

			e := tc.signerClient.SignVote(ctx, tc.chainID, want.ToProto())
			assert.EqualError(t, e, "empty response")
		})
	}
}