// Copyright 2018 The dexon-consensus Authors
// This file is part of the dexon-consensus library.
//
// The dexon-consensus library is free software: you can redistribute it
// and/or modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// The dexon-consensus library is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
// General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the dexon-consensus library. If not, see
// <http://www.gnu.org/licenses/>.

package test

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

	"github.com/dexon-foundation/dexon-consensus/common"
	"github.com/dexon-foundation/dexon-consensus/core"
	"github.com/dexon-foundation/dexon-consensus/core/crypto"
	"github.com/dexon-foundation/dexon-consensus/core/crypto/dkg"
	"github.com/dexon-foundation/dexon-consensus/core/types"
	typesDKG "github.com/dexon-foundation/dexon-consensus/core/types/dkg"
	"github.com/dexon-foundation/dexon-consensus/core/utils"
	"github.com/stretchr/testify/suite"
)

func getCRS(round, reset uint64) []byte {
	return []byte(fmt.Sprintf("r#%d,reset#%d", round, reset))
}

type evtParamToCheck struct {
	round  uint64
	reset  uint64
	height uint64
	crs    common.Hash
}

type AppTestSuite struct {
	suite.Suite

	pubKeys []crypto.PublicKey
	signers []*utils.Signer
	logger  common.Logger
}

func (s *AppTestSuite) SetupSuite() {
	prvKeys, pubKeys, err := NewKeys(4)
	s.Require().NoError(err)
	s.pubKeys = pubKeys
	for _, k := range prvKeys {
		s.signers = append(s.signers, utils.NewSigner(k))
	}
	s.logger = &common.NullLogger{}
}

func (s *AppTestSuite) prepareGov() *Governance {
	gov, err := NewGovernance(
		NewState(1, s.pubKeys, 100*time.Millisecond, s.logger, true),
		core.ConfigRoundShift)
	s.Require().NoError(err)
	return gov
}

func (s *AppTestSuite) proposeMPK(
	gov *Governance,
	round, reset uint64,
	count int) {
	for idx, pubKey := range s.pubKeys[:count] {
		_, pubShare := dkg.NewPrivateKeyShares(utils.GetDKGThreshold(
			gov.Configuration(round)))
		mpk := &typesDKG.MasterPublicKey{
			Round:           round,
			Reset:           reset,
			DKGID:           typesDKG.NewID(types.NewNodeID(pubKey)),
			PublicKeyShares: *pubShare,
		}
		s.Require().NoError(s.signers[idx].SignDKGMasterPublicKey(mpk))
		gov.AddDKGMasterPublicKey(mpk)
	}
}

func (s *AppTestSuite) proposeFinalize(
	gov *Governance,
	round, reset uint64,
	count int) {
	for idx, pubKey := range s.pubKeys[:count] {
		final := &typesDKG.Finalize{
			ProposerID: types.NewNodeID(pubKey),
			Round:      round,
			Reset:      reset,
		}
		s.Require().NoError(s.signers[idx].SignDKGFinalize(final))
		gov.AddDKGFinalize(final)
	}
}

func (s *AppTestSuite) deliverBlockWithTimeFromSequenceLength(
	app *App, hash common.Hash) {

	s.deliverBlock(app, hash, time.Time{}.Add(
		time.Duration(len(app.DeliverSequence))*time.Second),
		uint64(len(app.DeliverSequence)+1))
}

func (s *AppTestSuite) deliverBlock(
	app *App, hash common.Hash, timestamp time.Time, height uint64) {

	app.BlockDelivered(hash, types.Position{}, types.FinalizationResult{
		Timestamp: timestamp,
		Height:    height,
	})
}

func (s *AppTestSuite) TestCompare() {
	var (
		now = time.Now().UTC()
		b0  = types.Block{Hash: common.Hash{}}
		b1  = types.Block{
			Hash:     common.NewRandomHash(),
			Position: types.Position{Height: 1},
		}
	)
	// Prepare an OK App instance.
	app1 := NewApp(0, nil, nil)
	app1.BlockConfirmed(b0)
	app1.BlockConfirmed(b1)
	app1.BlockDelivered(b0.Hash, b0.Position, types.FinalizationResult{
		Height:    1,
		Timestamp: now,
	})
	app1.BlockDelivered(b1.Hash, b1.Position, types.FinalizationResult{
		Height:    2,
		Timestamp: now.Add(1 * time.Second),
	})
	app2 := NewApp(0, nil, nil)
	s.Require().Equal(ErrEmptyDeliverSequence.Error(),
		app1.Compare(app2).Error())
	app2.BlockConfirmed(b0)
	app2.BlockDelivered(b0.Hash, b0.Position, types.FinalizationResult{
		Height:    1,
		Timestamp: now,
	})
	b1Bad := types.Block{
		Hash:     common.NewRandomHash(),
		Position: types.Position{Height: 1},
	}
	app2.BlockConfirmed(b1Bad)
	app2.BlockDelivered(b1Bad.Hash, b1Bad.Position, types.FinalizationResult{
		Height:    1,
		Timestamp: now,
	})
	s.Require().Equal(ErrMismatchBlockHashSequence.Error(),
		app1.Compare(app2).Error())
	app2 = NewApp(0, nil, nil)
	app2.BlockConfirmed(b0)
	app2.BlockDelivered(b0.Hash, b0.Position, types.FinalizationResult{
		Height:    1,
		Timestamp: now.Add(1 * time.Second),
	})
	s.Require().Equal(ErrMismatchConsensusTime.Error(),
		app1.Compare(app2).Error())
}

func (s *AppTestSuite) TestVerify() {
	var (
		now = time.Now().UTC()
		b0  = types.Block{Hash: common.Hash{}}
		b1  = types.Block{
			Hash:     common.NewRandomHash(),
			Position: types.Position{Height: 1},
		}
	)
	app := NewApp(0, nil, nil)
	s.Require().Equal(ErrEmptyDeliverSequence.Error(), app.Verify().Error())
	app.BlockDelivered(b0.Hash, b0.Position, types.FinalizationResult{})
	app.BlockDelivered(b1.Hash, b1.Position, types.FinalizationResult{Height: 1})
	s.Require().Equal(
		ErrDeliveredBlockNotConfirmed.Error(), app.Verify().Error())
	app = NewApp(0, nil, nil)
	app.BlockConfirmed(b0)
	app.BlockDelivered(b0.Hash, b0.Position, types.FinalizationResult{
		Height:    1,
		Timestamp: now,
	})
	app.BlockConfirmed(b1)
	app.BlockDelivered(b1.Hash, b1.Position, types.FinalizationResult{
		Height:    2,
		Timestamp: now.Add(-1 * time.Second),
	})
	s.Require().Equal(ErrConsensusTimestampOutOfOrder.Error(),
		app.Verify().Error())
	app = NewApp(0, nil, nil)
	app.BlockConfirmed(b0)
	app.BlockConfirmed(b1)
	app.BlockDelivered(b0.Hash, b0.Position, types.FinalizationResult{
		Height:    1,
		Timestamp: now,
	})
	app.BlockDelivered(b1.Hash, b1.Position, types.FinalizationResult{
		Height:    1,
		Timestamp: now.Add(1 * time.Second),
	})
}

func (s *AppTestSuite) TestWitness() {
	// Deliver several blocks, there is only one chain only.
	app := NewApp(0, nil, nil)
	deliver := func(b *types.Block) {
		app.BlockConfirmed(*b)
		app.BlockDelivered(b.Hash, b.Position, b.Finalization)
	}
	b00 := &types.Block{
		Hash: common.NewRandomHash(),
		Finalization: types.FinalizationResult{
			Height:    1,
			Timestamp: time.Now().UTC(),
		}}
	b01 := &types.Block{
		Hash:     common.NewRandomHash(),
		Position: types.Position{Height: 1},
		Finalization: types.FinalizationResult{
			ParentHash: b00.Hash,
			Height:     2,
			Timestamp:  time.Now().UTC(),
		},
		Witness: types.Witness{
			Height: 1,
			Data:   b00.Hash.Bytes(),
		}}
	b02 := &types.Block{
		Hash:     common.NewRandomHash(),
		Position: types.Position{Height: 2},
		Finalization: types.FinalizationResult{
			ParentHash: b01.Hash,
			Height:     3,
			Timestamp:  time.Now().UTC(),
		},
		Witness: types.Witness{
			Height: 1,
			Data:   b00.Hash.Bytes(),
		}}
	deliver(b00)
	deliver(b01)
	deliver(b02)
	// A block with higher witness height, should retry later.
	s.Require().Equal(types.VerifyRetryLater, app.VerifyBlock(&types.Block{
		Witness: types.Witness{Height: 4}}))
	// Mismatched witness height and data, should return invalid.
	s.Require().Equal(types.VerifyInvalidBlock, app.VerifyBlock(&types.Block{
		Witness: types.Witness{Height: 1, Data: b01.Hash.Bytes()}}))
	// We can only verify a block followed last confirmed block.
	s.Require().Equal(types.VerifyRetryLater, app.VerifyBlock(&types.Block{
		Witness:  types.Witness{Height: 2, Data: b01.Hash.Bytes()},
		Position: types.Position{Height: 4}}))
	// It's the OK case.
	s.Require().Equal(types.VerifyOK, app.VerifyBlock(&types.Block{
		Witness:  types.Witness{Height: 2, Data: b01.Hash.Bytes()},
		Position: types.Position{Height: 3}}))
	// Check current last pending height.
	s.Require().Equal(app.LastPendingHeight, uint64(3))
	// We can only prepare witness for what've delivered.
	_, err := app.PrepareWitness(4)
	s.Require().Equal(err.Error(), ErrLowerPendingHeight.Error())
	// It should be ok to prepare for height that already delivered.
	w, err := app.PrepareWitness(3)
	s.Require().NoError(err)
	s.Require().Equal(w.Height, b02.Finalization.Height)
	s.Require().Equal(0, bytes.Compare(w.Data, b02.Hash[:]))
}

func (s *AppTestSuite) TestAttachedWithRoundEvent() {
	// This test case is copied/modified from
	// integraion.RoundEventTestSuite.TestFromRoundN, the difference is the
	// calls to utils.RoundEvent.ValidateNextRound is not explicitly called but
	// triggered by App.BlockDelivered.
	var (
		gov         = s.prepareGov()
		roundLength = uint64(100)
	)
	s.Require().NoError(gov.State().RequestChange(StateChangeRoundLength,
		roundLength))
	for r := uint64(2); r <= uint64(20); r++ {
		gov.ProposeCRS(r, getCRS(r, 0))
	}
	for r := uint64(0); r <= uint64(19); r++ {
		gov.NotifyRound(r, r*roundLength)
	}
	gov.NotifyRound(20, 2200)
	// Reset round#20 twice, then make it done DKG preparation.
	gov.ResetDKG(getCRS(20, 1))
	gov.ResetDKG(getCRS(20, 2))
	s.proposeMPK(gov, 20, 2, 3)
	s.proposeFinalize(gov, 20, 2, 3)
	s.Require().Equal(gov.DKGResetCount(20), uint64(2))
	// Propose CRS for round#21, and it works without reset.
	gov.ProposeCRS(21, getCRS(21, 0))
	s.proposeMPK(gov, 21, 0, 3)
	s.proposeFinalize(gov, 21, 0, 3)
	// Propose CRS for round#22, and it works without reset.
	gov.ProposeCRS(22, getCRS(22, 0))
	s.proposeMPK(gov, 22, 0, 3)
	s.proposeFinalize(gov, 22, 0, 3)
	// Prepare utils.RoundEvent, starts from round#19, reset(for round#20)#1.
	rEvt, err := utils.NewRoundEvent(context.Background(), gov, s.logger, 19,
		2019, core.ConfigRoundShift)
	s.Require().NoError(err)
	// Register a handler to collects triggered events.
	evts := make(chan evtParamToCheck, 3)
	rEvt.Register(func(params []utils.RoundEventParam) {
		for _, p := range params {
			evts <- evtParamToCheck{
				round:  p.Round,
				reset:  p.Reset,
				height: p.BeginHeight,
				crs:    p.CRS,
			}
		}
	})
	// Setup App instance.
	app := NewApp(19, gov, rEvt)
	deliver := func(round, start, end uint64) {
		for i := start; i <= end; i++ {
			b := &types.Block{
				Hash:         common.NewRandomHash(),
				Position:     types.Position{Round: round, Height: i},
				Finalization: types.FinalizationResult{Height: i},
			}
			app.BlockConfirmed(*b)
			app.BlockDelivered(b.Hash, b.Position, b.Finalization)
		}
	}
	// Deliver blocks from height=2020 to height=2081.
	for r := uint64(0); r <= uint64(19); r++ {
		deliver(r, r*roundLength, (r+1)*roundLength-1)
	}
	deliver(19, 2000, 2091)
	s.Require().Equal(<-evts, evtParamToCheck{19, 1, 2000, gov.CRS(19)})
	s.Require().Equal(<-evts, evtParamToCheck{19, 2, 2100, gov.CRS(19)})
	s.Require().Equal(<-evts, evtParamToCheck{20, 0, 2200, gov.CRS(20)})
	// Deliver blocks from height=2082 to height=2281.
	deliver(19, 2092, 2199)
	deliver(20, 2200, 2291)
	s.Require().Equal(<-evts, evtParamToCheck{21, 0, 2300, gov.CRS(21)})
	// Deliver blocks from height=2282 to height=2381.
	deliver(20, 2292, 2299)
	deliver(21, 2300, 2391)
	s.Require().Equal(<-evts, evtParamToCheck{22, 0, 2400, gov.CRS(22)})
}

func TestApp(t *testing.T) {
	suite.Run(t, new(AppTestSuite))
}