package wallet_test

import (
	"runtime"
	"testing"

	"github.com/lbryio/lbcwallet/wallet"
)

// Harness holds the BranchRecoveryState being tested, the recovery window being
// used, provides access to the test object, and tracks the expected horizon
// and next unfound values.
type Harness struct {
	t              *testing.T
	brs            *wallet.BranchRecoveryState
	recoveryWindow uint32
	expHorizon     uint32
	expNextUnfound uint32
}

type (
	// Stepper is a generic interface that performs an action or assertion
	// against a test Harness.
	Stepper interface {
		// Apply performs an action or assertion against branch recovery
		// state held by the Harness.  The step index is provided so
		// that any failures can report which Step failed.
		Apply(step int, harness *Harness)
	}

	// InitialiDelta is a Step that verifies our first attempt to expand the
	// branch recovery state's horizons tells us to derive a number of
	// adddresses equal to the recovery window.
	InitialDelta struct{}

	// CheckDelta is a Step that expands the branch recovery state's
	// horizon, and checks that the returned delta meets our expected
	// `delta`.
	CheckDelta struct {
		delta uint32
	}

	// CheckNumInvalid is a Step that asserts that the branch recovery
	// state reports `total` invalid children with the current horizon.
	CheckNumInvalid struct {
		total uint32
	}

	// MarkInvalid is a Step that marks the `child` as invalid in the branch
	// recovery state.
	MarkInvalid struct {
		child uint32
	}

	// ReportFound is a Step that reports `child` as being found to the
	// branch recovery state.
	ReportFound struct {
		child uint32
	}
)

// Apply extends the current horizon of the branch recovery state, and checks
// that the returned delta is equal to the test's recovery window. If the
// assertions pass, the harness's expected horizon is increased by the returned
// delta.
//
// NOTE: This should be used before applying any CheckDelta steps.
func (InitialDelta) Apply(i int, h *Harness) {
	curHorizon, delta := h.brs.ExtendHorizon()
	assertHorizon(h.t, i, curHorizon, h.expHorizon)
	assertDelta(h.t, i, delta, h.recoveryWindow)
	h.expHorizon += delta
}

// Apply extends the current horizon of the branch recovery state, and checks
// that the returned delta is equal to the CheckDelta's child value.
func (d CheckDelta) Apply(i int, h *Harness) {
	curHorizon, delta := h.brs.ExtendHorizon()
	assertHorizon(h.t, i, curHorizon, h.expHorizon)
	assertDelta(h.t, i, delta, d.delta)
	h.expHorizon += delta
}

// Apply queries the branch recovery state for the number of invalid children
// that lie between the last found address and the current horizon, and compares
// that to the CheckNumInvalid's total.
func (m CheckNumInvalid) Apply(i int, h *Harness) {
	assertNumInvalid(h.t, i, h.brs.NumInvalidInHorizon(), m.total)
}

// Apply marks the MarkInvalid's child index as invalid in the branch recovery
// state, and increments the harness's expected horizon.
func (m MarkInvalid) Apply(i int, h *Harness) {
	h.brs.MarkInvalidChild(m.child)
	h.expHorizon++
}

// Apply reports the ReportFound's child index as found in the branch recovery
// state. If the child index meets or exceeds our expected next unfound value,
// the expected value will be modified to be the child index + 1. Afterwards,
// this step asserts that the branch recovery state's next reported unfound
// value matches our potentially-updated value.
func (r ReportFound) Apply(i int, h *Harness) {
	h.brs.ReportFound(r.child)
	if r.child >= h.expNextUnfound {
		h.expNextUnfound = r.child + 1
	}
	assertNextUnfound(h.t, i, h.brs.NextUnfound(), h.expNextUnfound)
}

// Compile-time checks to ensure our steps implement the Step interface.
var _ Stepper = InitialDelta{}
var _ Stepper = CheckDelta{}
var _ Stepper = CheckNumInvalid{}
var _ Stepper = MarkInvalid{}
var _ Stepper = ReportFound{}

// TestBranchRecoveryState walks the BranchRecoveryState through a sequence of
// steps, verifying that:
//   - the horizon is properly expanded in response to found addrs
//   - report found children below or equal to previously found causes no change
//   - marking invalid children expands the horizon
func TestBranchRecoveryState(t *testing.T) {

	const recoveryWindow = 10

	recoverySteps := []Stepper{
		// First, check that expanding our horizon returns exactly the
		// recovery window (10).
		InitialDelta{},

		// Expected horizon: 10.

		// Report finding the 2nd addr, this should cause our horizon
		// to expand by 2.
		ReportFound{1},
		CheckDelta{2},

		// Expected horizon: 12.

		// Sanity check that expanding again reports zero delta, as
		// nothing has changed.
		CheckDelta{0},

		// Now, report finding the 6th addr, which should expand our
		// horizon to 16 with a detla of 4.
		ReportFound{5},
		CheckDelta{4},

		// Expected horizon: 16.

		// Sanity check that expanding again reports zero delta, as
		// nothing has changed.
		CheckDelta{0},

		// Report finding child index 5 again, nothing should change.
		ReportFound{5},
		CheckDelta{0},

		// Report finding a lower index that what was last found,
		// nothing should change.
		ReportFound{4},
		CheckDelta{0},

		// Moving on, report finding the 11th addr, which should extend
		// our horizon to 21.
		ReportFound{10},
		CheckDelta{5},

		// Expected horizon: 21.

		// Before testing the lookahead expansion when encountering
		// invalid child keys, check that we are correctly starting with
		// no invalid keys.
		CheckNumInvalid{0},

		// Now that the window has been expanded, simulate deriving
		// invalid keys in range of addrs that are being derived for the
		// first time. The horizon will be incremented by one, as the
		// recovery manager is expected to try and derive at least the
		// next address.
		MarkInvalid{17},
		CheckNumInvalid{1},
		CheckDelta{0},

		// Expected horizon: 22.

		// Check that deriving a second invalid key shows both invalid
		// indexes currently within the horizon.
		MarkInvalid{18},
		CheckNumInvalid{2},
		CheckDelta{0},

		// Expected horizon: 23.

		// Lastly, report finding the addr immediately after our two
		// invalid keys. This should return our number of invalid keys
		// within the horizon back to 0.
		ReportFound{19},
		CheckNumInvalid{0},

		// As the 20-th key was just marked found, our horizon will need
		// to expand to 30. With the horizon at 23, the delta returned
		// should be 7.
		CheckDelta{7},
		CheckDelta{0},

		// Expected horizon: 30.
	}

	brs := wallet.NewBranchRecoveryState(recoveryWindow)
	harness := &Harness{
		t:              t,
		brs:            brs,
		recoveryWindow: recoveryWindow,
	}

	for i, step := range recoverySteps {
		step.Apply(i, harness)
	}
}

func assertHorizon(t *testing.T, i int, have, want uint32) {
	assertHaveWant(t, i, "incorrect horizon", have, want)
}

func assertDelta(t *testing.T, i int, have, want uint32) {
	assertHaveWant(t, i, "incorrect delta", have, want)
}

func assertNextUnfound(t *testing.T, i int, have, want uint32) {
	assertHaveWant(t, i, "incorrect next unfound", have, want)
}

func assertNumInvalid(t *testing.T, i int, have, want uint32) {
	assertHaveWant(t, i, "incorrect num invalid children", have, want)
}

func assertHaveWant(t *testing.T, i int, msg string, have, want uint32) {
	_, _, line, _ := runtime.Caller(2)
	if want != have {
		t.Fatalf("[line: %d, step: %d] %s: got %d, want %d",
			line, i, msg, have, want)
	}
}