// 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"
	"testing"
	"time"

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

type AppTestSuite struct {
	suite.Suite

	to1, to2, to3 *AppTotalOrderRecord
}

func (s *AppTestSuite) SetupSuite() {
	s.to1 = &AppTotalOrderRecord{
		BlockHashes: common.Hashes{
			common.NewRandomHash(),
			common.NewRandomHash(),
		},
		Mode: core.TotalOrderingModeNormal,
	}
	s.to2 = &AppTotalOrderRecord{
		BlockHashes: common.Hashes{
			common.NewRandomHash(),
			common.NewRandomHash(),
			common.NewRandomHash(),
		},
		Mode: core.TotalOrderingModeNormal,
	}
	s.to3 = &AppTotalOrderRecord{
		BlockHashes: common.Hashes{
			common.NewRandomHash(),
		},
		Mode: core.TotalOrderingModeNormal,
	}
}

func (s *AppTestSuite) setupAppByTotalOrderDeliver(
	app *App, to *AppTotalOrderRecord) {
	for _, h := range to.BlockHashes {
		app.BlockConfirmed(types.Block{Hash: h})
	}
	app.TotalOrderingDelivered(to.BlockHashes, to.Mode)
	for _, h := range to.BlockHashes {
		// To make it simpler, use the index of hash sequence
		// as the time.
		s.deliverBlockWithTimeFromSequenceLength(app, h)
	}
}

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() {
	req := s.Require()

	app1 := NewApp(nil)
	s.setupAppByTotalOrderDeliver(app1, s.to1)
	s.setupAppByTotalOrderDeliver(app1, s.to2)
	s.setupAppByTotalOrderDeliver(app1, s.to3)
	// An App with different deliver sequence.
	app2 := NewApp(nil)
	s.setupAppByTotalOrderDeliver(app2, s.to1)
	s.setupAppByTotalOrderDeliver(app2, s.to2)
	hash := common.NewRandomHash()
	app2.BlockConfirmed(types.Block{Hash: hash})
	app2.TotalOrderingDelivered(common.Hashes{hash}, core.TotalOrderingModeNormal)
	s.deliverBlockWithTimeFromSequenceLength(app2, hash)
	req.Equal(ErrMismatchBlockHashSequence, app1.Compare(app2))
	// An App with different consensus time for the same block.
	app3 := NewApp(nil)
	s.setupAppByTotalOrderDeliver(app3, s.to1)
	s.setupAppByTotalOrderDeliver(app3, s.to2)
	for _, h := range s.to3.BlockHashes {
		app3.BlockConfirmed(types.Block{Hash: h})
	}
	app3.TotalOrderingDelivered(s.to3.BlockHashes, s.to3.Mode)
	wrongTime := time.Time{}.Add(
		time.Duration(len(app3.DeliverSequence)) * time.Second)
	wrongTime = wrongTime.Add(1 * time.Second)
	s.deliverBlock(app3, s.to3.BlockHashes[0], wrongTime,
		uint64(len(app3.DeliverSequence)+1))
	req.Equal(ErrMismatchConsensusTime, app1.Compare(app3))
	req.Equal(ErrMismatchConsensusTime, app3.Compare(app1))
	// An App without any delivered blocks.
	app4 := NewApp(nil)
	req.Equal(ErrEmptyDeliverSequence, app4.Compare(app1))
	req.Equal(ErrEmptyDeliverSequence, app1.Compare(app4))
}

func (s *AppTestSuite) TestVerify() {
	req := s.Require()

	// An OK App instance.
	app1 := NewApp(nil)
	s.setupAppByTotalOrderDeliver(app1, s.to1)
	s.setupAppByTotalOrderDeliver(app1, s.to2)
	s.setupAppByTotalOrderDeliver(app1, s.to3)
	req.NoError(app1.Verify())
	// A delivered block without strongly ack
	s.deliverBlock(app1, common.NewRandomHash(), time.Time{},
		uint64(len(app1.DeliverSequence)))
	req.Equal(ErrDeliveredBlockNotConfirmed, app1.Verify())
	// The consensus time is out of order.
	app2 := NewApp(nil)
	s.setupAppByTotalOrderDeliver(app2, s.to1)
	for _, h := range s.to2.BlockHashes {
		app2.BlockConfirmed(types.Block{Hash: h})
	}
	app2.TotalOrderingDelivered(s.to2.BlockHashes, s.to2.Mode)
	s.deliverBlock(app2, s.to2.BlockHashes[0], time.Time{},
		uint64(len(app2.DeliverSequence)+1))
	req.Equal(ErrConsensusTimestampOutOfOrder, app2.Verify())
	// A delivered block is not found in total ordering delivers.
	app3 := NewApp(nil)
	s.setupAppByTotalOrderDeliver(app3, s.to1)
	hash := common.NewRandomHash()
	app3.BlockConfirmed(types.Block{Hash: hash})
	s.deliverBlockWithTimeFromSequenceLength(app3, hash)
	req.Equal(ErrMismatchTotalOrderingAndDelivered, app3.Verify())
	// A delivered block is not found in total ordering delivers.
	app4 := NewApp(nil)
	s.setupAppByTotalOrderDeliver(app4, s.to1)
	for _, h := range s.to2.BlockHashes {
		app4.BlockConfirmed(types.Block{Hash: h})
	}
	app4.TotalOrderingDelivered(s.to2.BlockHashes, s.to2.Mode)
	hash = common.NewRandomHash()
	app4.BlockConfirmed(types.Block{Hash: hash})
	app4.TotalOrderingDelivered(common.Hashes{hash}, core.TotalOrderingModeNormal)
	s.deliverBlockWithTimeFromSequenceLength(app4, hash)
	// Witness ack on unknown block.
	app5 := NewApp(nil)
	s.setupAppByTotalOrderDeliver(app5, s.to1)
	// The conensus height is out of order.
	app6 := NewApp(nil)
	s.setupAppByTotalOrderDeliver(app6, s.to1)
	for _, h := range s.to2.BlockHashes {
		app6.BlockConfirmed(types.Block{Hash: h})
	}
	app6.TotalOrderingDelivered(s.to2.BlockHashes, s.to2.Mode)
	s.deliverBlock(app6, s.to2.BlockHashes[0], time.Time{}.Add(
		time.Duration(len(app6.DeliverSequence))*time.Second),
		uint64(len(app6.DeliverSequence)+2))
	req.Equal(ErrConsensusHeightOutOfOrder, app6.Verify())
	// Test the acking block doesn't delivered.
	app7 := NewApp(nil)
	// Patch a block's acks.
	b7 := &types.Block{
		Hash: common.NewRandomHash(),
		Acks: common.NewSortedHashes(common.Hashes{common.NewRandomHash()}),
	}
	app7.BlockConfirmed(*b7)
	app7.TotalOrderingDelivered(
		common.Hashes{b7.Hash}, core.TotalOrderingModeNormal)
	app7.BlockDelivered(b7.Hash, types.Position{}, types.FinalizationResult{
		Timestamp: time.Now(),
		Height:    1,
	})
	req.Equal(ErrAckingBlockNotDelivered, app7.Verify())
}

func (s *AppTestSuite) TestWitness() {
	// Deliver several blocks, there is only one chain only.
	app := NewApp(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().IsType(err, ErrLowerPendingHeight)
	// 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 TestApp(t *testing.T) {
	suite.Run(t, new(AppTestSuite))
}