package routing

import (
	"bytes"
	"crypto/sha256"
	"encoding/binary"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"math"
	"math/big"
	"net"
	"os"
	"reflect"
	"strings"
	"testing"
	"time"

	"github.com/btcsuite/btcd/btcec"
	"github.com/btcsuite/btcd/chaincfg/chainhash"
	"github.com/btcsuite/btcd/wire"
	"github.com/btcsuite/btcutil"
	"github.com/lightningnetwork/lnd/channeldb"
	"github.com/lightningnetwork/lnd/feature"
	"github.com/lightningnetwork/lnd/lnwire"
	"github.com/lightningnetwork/lnd/record"
	"github.com/lightningnetwork/lnd/routing/route"
	"github.com/lightningnetwork/lnd/zpay32"
)

const (
	// basicGraphFilePath is the file path for a basic graph used within
	// the tests. The basic graph consists of 5 nodes with 5 channels
	// connecting them.
	basicGraphFilePath = "testdata/basic_graph.json"

	// excessiveHopsGraphFilePath is a file path which stores the JSON dump
	// of a graph which was previously triggering an erroneous excessive
	// hops error. The error has since been fixed, but a test case
	// exercising it is kept around to guard against regressions.
	excessiveHopsGraphFilePath = "testdata/excessive_hops.json"

	// specExampleFilePath is a file path which stores an example which
	// implementations will use in order to ensure that they're calculating
	// the payload for each hop in path properly.
	specExampleFilePath = "testdata/spec_example.json"

	// noFeeLimit is the maximum value of a payment through Lightning. We
	// can use this value to signal there is no fee limit since payments
	// should never be larger than this.
	noFeeLimit = lnwire.MilliSatoshi(math.MaxUint32)
)

var (
	noRestrictions = &RestrictParams{
		FeeLimit:          noFeeLimit,
		ProbabilitySource: noProbabilitySource,
		CltvLimit:         math.MaxUint32,
	}

	testPathFindingConfig = &PathFindingConfig{}

	tlvFeatures = lnwire.NewFeatureVector(
		lnwire.NewRawFeatureVector(
			lnwire.TLVOnionPayloadOptional,
		), lnwire.Features,
	)

	payAddrFeatures = lnwire.NewFeatureVector(
		lnwire.NewRawFeatureVector(
			lnwire.PaymentAddrOptional,
		), lnwire.Features,
	)

	tlvPayAddrFeatures = lnwire.NewFeatureVector(
		lnwire.NewRawFeatureVector(
			lnwire.TLVOnionPayloadOptional,
			lnwire.PaymentAddrOptional,
		), lnwire.Features,
	)

	unknownRequiredFeatures = lnwire.NewFeatureVector(
		lnwire.NewRawFeatureVector(100), lnwire.Features,
	)
)

var (
	testSig = &btcec.Signature{
		R: new(big.Int),
		S: new(big.Int),
	}
	_, _ = testSig.R.SetString("63724406601629180062774974542967536251589935445068131219452686511677818569431", 10)
	_, _ = testSig.S.SetString("18801056069249825825291287104931333862866033135609736119018462340006816851118", 10)

	testAuthProof = channeldb.ChannelAuthProof{
		NodeSig1Bytes:    testSig.Serialize(),
		NodeSig2Bytes:    testSig.Serialize(),
		BitcoinSig1Bytes: testSig.Serialize(),
		BitcoinSig2Bytes: testSig.Serialize(),
	}
)

// noProbabilitySource is used in testing to return the same probability 1 for
// all edges.
func noProbabilitySource(route.Vertex, route.Vertex, lnwire.MilliSatoshi) float64 {
	return 1
}

// testGraph is the struct which corresponds to the JSON format used to encode
// graphs within the files in the testdata directory.
//
// TODO(roasbeef): add test graph auto-generator
type testGraph struct {
	Info  []string   `json:"info"`
	Nodes []testNode `json:"nodes"`
	Edges []testChan `json:"edges"`
}

// testNode represents a node within the test graph above. We skip certain
// information such as the node's IP address as that information isn't needed
// for our tests.
type testNode struct {
	Source bool   `json:"source"`
	PubKey string `json:"pubkey"`
	Alias  string `json:"alias"`
}

// testChan represents the JSON version of a payment channel. This struct
// matches the Json that's encoded under the "edges" key within the test graph.
type testChan struct {
	Node1        string `json:"node_1"`
	Node2        string `json:"node_2"`
	ChannelID    uint64 `json:"channel_id"`
	ChannelPoint string `json:"channel_point"`
	ChannelFlags uint8  `json:"channel_flags"`
	MessageFlags uint8  `json:"message_flags"`
	Expiry       uint16 `json:"expiry"`
	MinHTLC      int64  `json:"min_htlc"`
	MaxHTLC      int64  `json:"max_htlc"`
	FeeBaseMsat  int64  `json:"fee_base_msat"`
	FeeRate      int64  `json:"fee_rate"`
	Capacity     int64  `json:"capacity"`
}

// makeTestGraph creates a new instance of a channeldb.ChannelGraph for testing
// purposes. A callback which cleans up the created temporary directories is
// also returned and intended to be executed after the test completes.
func makeTestGraph() (*channeldb.ChannelGraph, func(), error) {
	// First, create a temporary directory to be used for the duration of
	// this test.
	tempDirName, err := ioutil.TempDir("", "channeldb")
	if err != nil {
		return nil, nil, err
	}

	// Next, create channeldb for the first time.
	cdb, err := channeldb.Open(tempDirName)
	if err != nil {
		return nil, nil, err
	}

	cleanUp := func() {
		cdb.Close()
		os.RemoveAll(tempDirName)
	}

	return cdb.ChannelGraph(), cleanUp, nil
}

// parseTestGraph returns a fully populated ChannelGraph given a path to a JSON
// file which encodes a test graph.
func parseTestGraph(path string) (*testGraphInstance, error) {
	graphJSON, err := ioutil.ReadFile(path)
	if err != nil {
		return nil, err
	}

	// First unmarshal the JSON graph into an instance of the testGraph
	// struct. Using the struct tags created above in the struct, the JSON
	// will be properly parsed into the struct above.
	var g testGraph
	if err := json.Unmarshal(graphJSON, &g); err != nil {
		return nil, err
	}

	// We'll use this fake address for the IP address of all the nodes in
	// our tests. This value isn't needed for path finding so it doesn't
	// need to be unique.
	var testAddrs []net.Addr
	testAddr, err := net.ResolveTCPAddr("tcp", "192.0.0.1:8888")
	if err != nil {
		return nil, err
	}
	testAddrs = append(testAddrs, testAddr)

	// Next, create a temporary graph database for usage within the test.
	graph, cleanUp, err := makeTestGraph()
	if err != nil {
		return nil, err
	}

	aliasMap := make(map[string]route.Vertex)
	var source *channeldb.LightningNode

	// First we insert all the nodes within the graph as vertexes.
	for _, node := range g.Nodes {
		pubBytes, err := hex.DecodeString(node.PubKey)
		if err != nil {
			return nil, err
		}

		dbNode := &channeldb.LightningNode{
			HaveNodeAnnouncement: true,
			AuthSigBytes:         testSig.Serialize(),
			LastUpdate:           testTime,
			Addresses:            testAddrs,
			Alias:                node.Alias,
			Features:             testFeatures,
		}
		copy(dbNode.PubKeyBytes[:], pubBytes)

		// We require all aliases within the graph to be unique for our
		// tests.
		if _, ok := aliasMap[node.Alias]; ok {
			return nil, errors.New("aliases for nodes " +
				"must be unique!")
		}

		// If the alias is unique, then add the node to the
		// alias map for easy lookup.
		aliasMap[node.Alias] = dbNode.PubKeyBytes

		// If the node is tagged as the source, then we create a
		// pointer to is so we can mark the source in the graph
		// properly.
		if node.Source {
			// If we come across a node that's marked as the
			// source, and we've already set the source in a prior
			// iteration, then the JSON has an error as only ONE
			// node can be the source in the graph.
			if source != nil {
				return nil, errors.New("JSON is invalid " +
					"multiple nodes are tagged as the source")
			}

			source = dbNode
		}

		// With the node fully parsed, add it as a vertex within the
		// graph.
		if err := graph.AddLightningNode(dbNode); err != nil {
			return nil, err
		}
	}

	if source != nil {
		// Set the selected source node
		if err := graph.SetSourceNode(source); err != nil {
			return nil, err
		}
	}

	// With all the vertexes inserted, we can now insert the edges into the
	// test graph.
	for _, edge := range g.Edges {
		node1Bytes, err := hex.DecodeString(edge.Node1)
		if err != nil {
			return nil, err
		}

		node2Bytes, err := hex.DecodeString(edge.Node2)
		if err != nil {
			return nil, err
		}

		if bytes.Compare(node1Bytes, node2Bytes) == 1 {
			return nil, fmt.Errorf(
				"channel %v node order incorrect",
				edge.ChannelID,
			)
		}

		fundingTXID := strings.Split(edge.ChannelPoint, ":")[0]
		txidBytes, err := chainhash.NewHashFromStr(fundingTXID)
		if err != nil {
			return nil, err
		}
		fundingPoint := wire.OutPoint{
			Hash:  *txidBytes,
			Index: 0,
		}

		// We first insert the existence of the edge between the two
		// nodes.
		edgeInfo := channeldb.ChannelEdgeInfo{
			ChannelID:    edge.ChannelID,
			AuthProof:    &testAuthProof,
			ChannelPoint: fundingPoint,
			Capacity:     btcutil.Amount(edge.Capacity),
		}

		copy(edgeInfo.NodeKey1Bytes[:], node1Bytes)
		copy(edgeInfo.NodeKey2Bytes[:], node2Bytes)
		copy(edgeInfo.BitcoinKey1Bytes[:], node1Bytes)
		copy(edgeInfo.BitcoinKey2Bytes[:], node2Bytes)

		err = graph.AddChannelEdge(&edgeInfo)
		if err != nil && err != channeldb.ErrEdgeAlreadyExist {
			return nil, err
		}

		edgePolicy := &channeldb.ChannelEdgePolicy{
			SigBytes:                  testSig.Serialize(),
			MessageFlags:              lnwire.ChanUpdateMsgFlags(edge.MessageFlags),
			ChannelFlags:              lnwire.ChanUpdateChanFlags(edge.ChannelFlags),
			ChannelID:                 edge.ChannelID,
			LastUpdate:                testTime,
			TimeLockDelta:             edge.Expiry,
			MinHTLC:                   lnwire.MilliSatoshi(edge.MinHTLC),
			MaxHTLC:                   lnwire.MilliSatoshi(edge.MaxHTLC),
			FeeBaseMSat:               lnwire.MilliSatoshi(edge.FeeBaseMsat),
			FeeProportionalMillionths: lnwire.MilliSatoshi(edge.FeeRate),
		}
		if err := graph.UpdateEdgePolicy(edgePolicy); err != nil {
			return nil, err
		}
	}

	return &testGraphInstance{
		graph:    graph,
		cleanUp:  cleanUp,
		aliasMap: aliasMap,
	}, nil
}

type testChannelPolicy struct {
	Expiry      uint16
	MinHTLC     lnwire.MilliSatoshi
	MaxHTLC     lnwire.MilliSatoshi
	FeeBaseMsat lnwire.MilliSatoshi
	FeeRate     lnwire.MilliSatoshi
	LastUpdate  time.Time
	Disabled    bool
	Features    *lnwire.FeatureVector
}

type testChannelEnd struct {
	Alias string
	*testChannelPolicy
}

func symmetricTestChannel(alias1, alias2 string, capacity btcutil.Amount,
	policy *testChannelPolicy, chanID ...uint64) *testChannel {

	// Leaving id zero will result in auto-generation of a channel id during
	// graph construction.
	var id uint64
	if len(chanID) > 0 {
		id = chanID[0]
	}

	policy2 := *policy

	return asymmetricTestChannel(
		alias1, alias2, capacity, policy, &policy2, id,
	)
}

func asymmetricTestChannel(alias1, alias2 string, capacity btcutil.Amount,
	policy1, policy2 *testChannelPolicy, id uint64) *testChannel {

	return &testChannel{
		Capacity: capacity,
		Node1: &testChannelEnd{
			Alias:             alias1,
			testChannelPolicy: policy1,
		},
		Node2: &testChannelEnd{
			Alias:             alias2,
			testChannelPolicy: policy2,
		},
		ChannelID: id,
	}
}

type testChannel struct {
	Node1     *testChannelEnd
	Node2     *testChannelEnd
	Capacity  btcutil.Amount
	ChannelID uint64
}

type testGraphInstance struct {
	graph   *channeldb.ChannelGraph
	cleanUp func()

	// aliasMap is a map from a node's alias to its public key. This type is
	// provided in order to allow easily look up from the human memorable alias
	// to an exact node's public key.
	aliasMap map[string]route.Vertex

	// privKeyMap maps a node alias to its private key. This is used to be
	// able to mock a remote node's signing behaviour.
	privKeyMap map[string]*btcec.PrivateKey
}

// createTestGraphFromChannels returns a fully populated ChannelGraph based on a set of
// test channels. Additional required information like keys are derived in
// a deterministical way and added to the channel graph. A list of nodes is
// not required and derived from the channel data. The goal is to keep
// instantiating a test channel graph as light weight as possible.
func createTestGraphFromChannels(testChannels []*testChannel, source string) (
	*testGraphInstance, error) {

	// We'll use this fake address for the IP address of all the nodes in
	// our tests. This value isn't needed for path finding so it doesn't
	// need to be unique.
	var testAddrs []net.Addr
	testAddr, err := net.ResolveTCPAddr("tcp", "192.0.0.1:8888")
	if err != nil {
		return nil, err
	}
	testAddrs = append(testAddrs, testAddr)

	// Next, create a temporary graph database for usage within the test.
	graph, cleanUp, err := makeTestGraph()
	if err != nil {
		return nil, err
	}

	aliasMap := make(map[string]route.Vertex)
	privKeyMap := make(map[string]*btcec.PrivateKey)

	nodeIndex := byte(0)
	addNodeWithAlias := func(alias string, features *lnwire.FeatureVector) (
		*channeldb.LightningNode, error) {

		keyBytes := make([]byte, 32)
		keyBytes = []byte{
			0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, nodeIndex + 1,
		}

		privKey, pubKey := btcec.PrivKeyFromBytes(btcec.S256(),
			keyBytes)

		if features == nil {
			features = lnwire.EmptyFeatureVector()
		}

		dbNode := &channeldb.LightningNode{
			HaveNodeAnnouncement: true,
			AuthSigBytes:         testSig.Serialize(),
			LastUpdate:           testTime,
			Addresses:            testAddrs,
			Alias:                alias,
			Features:             features,
		}

		copy(dbNode.PubKeyBytes[:], pubKey.SerializeCompressed())

		privKeyMap[alias] = privKey

		// With the node fully parsed, add it as a vertex within the
		// graph.
		if err := graph.AddLightningNode(dbNode); err != nil {
			return nil, err
		}

		aliasMap[alias] = dbNode.PubKeyBytes
		nodeIndex++

		return dbNode, nil
	}

	// Add the source node.
	dbNode, err := addNodeWithAlias(source, lnwire.EmptyFeatureVector())
	if err != nil {
		return nil, err
	}

	if err = graph.SetSourceNode(dbNode); err != nil {
		return nil, err
	}

	// Initialize variable that keeps track of the next channel id to assign
	// if none is specified.
	nextUnassignedChannelID := uint64(100000)

	for _, testChannel := range testChannels {
		for _, node := range []*testChannelEnd{
			testChannel.Node1, testChannel.Node2} {

			_, exists := aliasMap[node.Alias]
			if !exists {
				var features *lnwire.FeatureVector
				if node.testChannelPolicy != nil {
					features =
						node.testChannelPolicy.Features
				}
				_, err := addNodeWithAlias(
					node.Alias, features,
				)
				if err != nil {
					return nil, err
				}
			}
		}

		channelID := testChannel.ChannelID

		// If no channel id is specified, generate an id.
		if channelID == 0 {
			channelID = nextUnassignedChannelID
			nextUnassignedChannelID++
		}

		var hash [sha256.Size]byte
		hash[len(hash)-1] = byte(channelID)

		fundingPoint := &wire.OutPoint{
			Hash:  chainhash.Hash(hash),
			Index: 0,
		}

		// Sort nodes
		node1 := testChannel.Node1
		node2 := testChannel.Node2
		node1Vertex := aliasMap[node1.Alias]
		node2Vertex := aliasMap[node2.Alias]
		if bytes.Compare(node1Vertex[:], node2Vertex[:]) == 1 {
			node1, node2 = node2, node1
			node1Vertex, node2Vertex = node2Vertex, node1Vertex
		}

		// We first insert the existence of the edge between the two
		// nodes.
		edgeInfo := channeldb.ChannelEdgeInfo{
			ChannelID:    channelID,
			AuthProof:    &testAuthProof,
			ChannelPoint: *fundingPoint,
			Capacity:     testChannel.Capacity,

			NodeKey1Bytes:    node1Vertex,
			BitcoinKey1Bytes: node1Vertex,
			NodeKey2Bytes:    node2Vertex,
			BitcoinKey2Bytes: node2Vertex,
		}

		err = graph.AddChannelEdge(&edgeInfo)
		if err != nil && err != channeldb.ErrEdgeAlreadyExist {
			return nil, err
		}

		if node1.testChannelPolicy != nil {
			var msgFlags lnwire.ChanUpdateMsgFlags
			if node1.MaxHTLC != 0 {
				msgFlags |= lnwire.ChanUpdateOptionMaxHtlc
			}
			var channelFlags lnwire.ChanUpdateChanFlags
			if node1.Disabled {
				channelFlags |= lnwire.ChanUpdateDisabled
			}

			edgePolicy := &channeldb.ChannelEdgePolicy{
				SigBytes:                  testSig.Serialize(),
				MessageFlags:              msgFlags,
				ChannelFlags:              channelFlags,
				ChannelID:                 channelID,
				LastUpdate:                node1.LastUpdate,
				TimeLockDelta:             node1.Expiry,
				MinHTLC:                   node1.MinHTLC,
				MaxHTLC:                   node1.MaxHTLC,
				FeeBaseMSat:               node1.FeeBaseMsat,
				FeeProportionalMillionths: node1.FeeRate,
			}
			if err := graph.UpdateEdgePolicy(edgePolicy); err != nil {
				return nil, err
			}
		}

		if node2.testChannelPolicy != nil {
			var msgFlags lnwire.ChanUpdateMsgFlags
			if node2.MaxHTLC != 0 {
				msgFlags |= lnwire.ChanUpdateOptionMaxHtlc
			}
			var channelFlags lnwire.ChanUpdateChanFlags
			if node2.Disabled {
				channelFlags |= lnwire.ChanUpdateDisabled
			}
			channelFlags |= lnwire.ChanUpdateDirection

			edgePolicy := &channeldb.ChannelEdgePolicy{
				SigBytes:                  testSig.Serialize(),
				MessageFlags:              msgFlags,
				ChannelFlags:              channelFlags,
				ChannelID:                 channelID,
				LastUpdate:                node2.LastUpdate,
				TimeLockDelta:             node2.Expiry,
				MinHTLC:                   node2.MinHTLC,
				MaxHTLC:                   node2.MaxHTLC,
				FeeBaseMSat:               node2.FeeBaseMsat,
				FeeProportionalMillionths: node2.FeeRate,
			}
			if err := graph.UpdateEdgePolicy(edgePolicy); err != nil {
				return nil, err
			}
		}

		channelID++
	}

	return &testGraphInstance{
		graph:      graph,
		cleanUp:    cleanUp,
		aliasMap:   aliasMap,
		privKeyMap: privKeyMap,
	}, nil
}

// TestFindLowestFeePath tests that out of two routes with identical total
// time lock values, the route with the lowest total fee should be returned.
// The fee rates are chosen such that the test failed on the previous edge
// weight function where one of the terms was fee squared.
func TestFindLowestFeePath(t *testing.T) {
	t.Parallel()

	// Set up a test graph with two paths from roasbeef to target. Both
	// paths have equal total time locks, but the path through b has lower
	// fees (700 compared to 800 for the path through a).
	testChannels := []*testChannel{
		symmetricTestChannel("roasbeef", "first", 100000, &testChannelPolicy{
			Expiry:  144,
			FeeRate: 400,
			MinHTLC: 1,
			MaxHTLC: 100000000,
		}),
		symmetricTestChannel("first", "a", 100000, &testChannelPolicy{
			Expiry:  144,
			FeeRate: 400,
			MinHTLC: 1,
			MaxHTLC: 100000000,
		}),
		symmetricTestChannel("a", "target", 100000, &testChannelPolicy{
			Expiry:  144,
			FeeRate: 400,
			MinHTLC: 1,
			MaxHTLC: 100000000,
		}),
		symmetricTestChannel("first", "b", 100000, &testChannelPolicy{
			Expiry:  144,
			FeeRate: 100,
			MinHTLC: 1,
			MaxHTLC: 100000000,
		}),
		symmetricTestChannel("b", "target", 100000, &testChannelPolicy{
			Expiry:  144,
			FeeRate: 600,
			MinHTLC: 1,
			MaxHTLC: 100000000,
		}),
	}

	ctx := newPathFindingTestContext(t, testChannels, "roasbeef")
	defer ctx.cleanup()

	const (
		startingHeight = 100
		finalHopCLTV   = 1
	)

	paymentAmt := lnwire.NewMSatFromSatoshis(100)
	target := ctx.keyFromAlias("target")
	path, err := ctx.findPath(target, paymentAmt)
	if err != nil {
		t.Fatalf("unable to find path: %v", err)
	}
	route, err := newRoute(
		ctx.source, path, startingHeight,
		finalHopParams{
			amt:       paymentAmt,
			cltvDelta: finalHopCLTV,
			records:   nil,
		},
	)
	if err != nil {
		t.Fatalf("unable to create path: %v", err)
	}

	// Assert that the lowest fee route is returned.
	if route.Hops[1].PubKeyBytes != ctx.keyFromAlias("b") {
		t.Fatalf("expected route to pass through b, "+
			"but got a route through %v",
			ctx.aliasFromKey(route.Hops[1].PubKeyBytes))
	}
}

func getAliasFromPubKey(pubKey route.Vertex,
	aliases map[string]route.Vertex) string {

	for alias, key := range aliases {
		if key == pubKey {
			return alias
		}
	}
	return ""
}

type expectedHop struct {
	alias     string
	fee       lnwire.MilliSatoshi
	fwdAmount lnwire.MilliSatoshi
	timeLock  uint32
}

type basicGraphPathFindingTestCase struct {
	target                string
	paymentAmt            btcutil.Amount
	feeLimit              lnwire.MilliSatoshi
	expectedTotalAmt      lnwire.MilliSatoshi
	expectedTotalTimeLock uint32
	expectedHops          []expectedHop
	expectFailureNoPath   bool
}

var basicGraphPathFindingTests = []basicGraphPathFindingTestCase{
	// Basic route with one intermediate hop.
	{target: "sophon", paymentAmt: 100, feeLimit: noFeeLimit,
		expectedTotalTimeLock: 102, expectedTotalAmt: 100110,
		expectedHops: []expectedHop{
			{alias: "songoku", fwdAmount: 100000, fee: 110, timeLock: 101},
			{alias: "sophon", fwdAmount: 100000, fee: 0, timeLock: 101},
		}},

	// Basic direct (one hop) route.
	{target: "luoji", paymentAmt: 100, feeLimit: noFeeLimit,
		expectedTotalTimeLock: 101, expectedTotalAmt: 100000,
		expectedHops: []expectedHop{
			{alias: "luoji", fwdAmount: 100000, fee: 0, timeLock: 101},
		}},

	// Three hop route where fees need to be added in to the forwarding amount.
	// The high fee hop phamnewun should be avoided.
	{target: "elst", paymentAmt: 50000, feeLimit: noFeeLimit,
		expectedTotalTimeLock: 103, expectedTotalAmt: 50050210,
		expectedHops: []expectedHop{
			{alias: "songoku", fwdAmount: 50000200, fee: 50010, timeLock: 102},
			{alias: "sophon", fwdAmount: 50000000, fee: 200, timeLock: 101},
			{alias: "elst", fwdAmount: 50000000, fee: 0, timeLock: 101},
		}},
	// Three hop route where fees need to be added in to the forwarding amount.
	// However this time the fwdAmount becomes too large for the roasbeef <->
	// songoku channel. Then there is no other option than to choose the
	// expensive phamnuwen channel. This test case was failing before
	// the route search was executed backwards.
	{target: "elst", paymentAmt: 100000, feeLimit: noFeeLimit,
		expectedTotalTimeLock: 103, expectedTotalAmt: 110010220,
		expectedHops: []expectedHop{
			{alias: "phamnuwen", fwdAmount: 100000200, fee: 10010020, timeLock: 102},
			{alias: "sophon", fwdAmount: 100000000, fee: 200, timeLock: 101},
			{alias: "elst", fwdAmount: 100000000, fee: 0, timeLock: 101},
		}},

	// Basic route with fee limit.
	{target: "sophon", paymentAmt: 100, feeLimit: 50,
		expectFailureNoPath: true,
	}}

func TestBasicGraphPathFinding(t *testing.T) {
	t.Parallel()

	testGraphInstance, err := parseTestGraph(basicGraphFilePath)
	if err != nil {
		t.Fatalf("unable to create graph: %v", err)
	}
	defer testGraphInstance.cleanUp()

	// With the test graph loaded, we'll test some basic path finding using
	// the pre-generated graph. Consult the testdata/basic_graph.json file
	// to follow along with the assumptions we'll use to test the path
	// finding.

	for _, testCase := range basicGraphPathFindingTests {
		t.Run(testCase.target, func(subT *testing.T) {
			testBasicGraphPathFindingCase(subT, testGraphInstance, &testCase)
		})
	}
}

func testBasicGraphPathFindingCase(t *testing.T, graphInstance *testGraphInstance,
	test *basicGraphPathFindingTestCase) {

	aliases := graphInstance.aliasMap
	expectedHops := test.expectedHops
	expectedHopCount := len(expectedHops)

	sourceNode, err := graphInstance.graph.SourceNode()
	if err != nil {
		t.Fatalf("unable to fetch source node: %v", err)
	}
	sourceVertex := route.Vertex(sourceNode.PubKeyBytes)

	const (
		startingHeight = 100
		finalHopCLTV   = 1
	)

	paymentAmt := lnwire.NewMSatFromSatoshis(test.paymentAmt)
	target := graphInstance.aliasMap[test.target]
	path, err := findPath(
		&graphParams{
			graph: graphInstance.graph,
		},
		&RestrictParams{
			FeeLimit:          test.feeLimit,
			ProbabilitySource: noProbabilitySource,
			CltvLimit:         math.MaxUint32,
		},
		testPathFindingConfig,
		sourceNode.PubKeyBytes, target, paymentAmt,
		startingHeight+finalHopCLTV,
	)
	if test.expectFailureNoPath {
		if err == nil {
			t.Fatal("expected no path to be found")
		}
		return
	}
	if err != nil {
		t.Fatalf("unable to find path: %v", err)
	}

	route, err := newRoute(
		sourceVertex, path, startingHeight,
		finalHopParams{
			amt:       paymentAmt,
			cltvDelta: finalHopCLTV,
			records:   nil,
		},
	)
	if err != nil {
		t.Fatalf("unable to create path: %v", err)
	}

	if len(route.Hops) != len(expectedHops) {
		t.Fatalf("route is of incorrect length, expected %v got %v",
			expectedHopCount, len(route.Hops))
	}

	// Check hop nodes
	for i := 0; i < len(expectedHops); i++ {
		if route.Hops[i].PubKeyBytes != aliases[expectedHops[i].alias] {

			t.Fatalf("%v-th hop should be %v, is instead: %v",
				i, expectedHops[i],
				getAliasFromPubKey(route.Hops[i].PubKeyBytes,
					aliases))
		}
	}

	// Next, we'll assert that the "next hop" field in each route payload
	// properly points to the channel ID that the HTLC should be forwarded
	// along.
	sphinxPath, err := route.ToSphinxPath()
	if err != nil {
		t.Fatalf("unable to make sphinx path: %v", err)
	}
	if sphinxPath.TrueRouteLength() != expectedHopCount {
		t.Fatalf("incorrect number of hop payloads: expected %v, got %v",
			expectedHopCount, sphinxPath.TrueRouteLength())
	}

	// Hops should point to the next hop
	for i := 0; i < len(expectedHops)-1; i++ {
		var expectedHop [8]byte
		binary.BigEndian.PutUint64(expectedHop[:], route.Hops[i+1].ChannelID)

		hopData, err := sphinxPath[i].HopPayload.HopData()
		if err != nil {
			t.Fatalf("unable to make hop data: %v", err)
		}

		if !bytes.Equal(hopData.NextAddress[:], expectedHop[:]) {
			t.Fatalf("first hop has incorrect next hop: expected %x, got %x",
				expectedHop[:], hopData.NextAddress[:])
		}
	}

	// The final hop should have a next hop value of all zeroes in order
	// to indicate it's the exit hop.
	var exitHop [8]byte
	lastHopIndex := len(expectedHops) - 1

	hopData, err := sphinxPath[lastHopIndex].HopPayload.HopData()
	if err != nil {
		t.Fatalf("unable to create hop data: %v", err)
	}

	if !bytes.Equal(hopData.NextAddress[:], exitHop[:]) {
		t.Fatalf("first hop has incorrect next hop: expected %x, got %x",
			exitHop[:], hopData.NextAddress)
	}

	var expectedTotalFee lnwire.MilliSatoshi
	for i := 0; i < expectedHopCount; i++ {
		// We'll ensure that the amount to forward, and fees
		// computed for each hop are correct.

		fee := route.HopFee(i)
		if fee != expectedHops[i].fee {
			t.Fatalf("fee incorrect for hop %v: expected %v, got %v",
				i, expectedHops[i].fee, fee)
		}

		if route.Hops[i].AmtToForward != expectedHops[i].fwdAmount {
			t.Fatalf("forwarding amount for hop %v incorrect: "+
				"expected %v, got %v",
				i, expectedHops[i].fwdAmount,
				route.Hops[i].AmtToForward)
		}

		// We'll also assert that the outgoing CLTV value for each
		// hop was set accordingly.
		if route.Hops[i].OutgoingTimeLock != expectedHops[i].timeLock {
			t.Fatalf("outgoing time-lock for hop %v is incorrect: "+
				"expected %v, got %v", i,
				expectedHops[i].timeLock,
				route.Hops[i].OutgoingTimeLock)
		}

		expectedTotalFee += expectedHops[i].fee
	}

	if route.TotalAmount != test.expectedTotalAmt {
		t.Fatalf("total amount incorrect: "+
			"expected %v, got %v",
			test.expectedTotalAmt, route.TotalAmount)
	}

	if route.TotalTimeLock != test.expectedTotalTimeLock {
		t.Fatalf("expected time lock of %v, instead have %v", 2,
			route.TotalTimeLock)
	}
}

// TestPathFindingWithAdditionalEdges asserts that we are able to find paths to
// nodes that do not exist in the graph by way of hop hints. We also test that
// the path can support custom TLV records for the receiver under the
// appropriate circumstances.
func TestPathFindingWithAdditionalEdges(t *testing.T) {
	t.Parallel()

	graph, err := parseTestGraph(basicGraphFilePath)
	if err != nil {
		t.Fatalf("unable to create graph: %v", err)
	}
	defer graph.cleanUp()

	sourceNode, err := graph.graph.SourceNode()
	if err != nil {
		t.Fatalf("unable to fetch source node: %v", err)
	}

	paymentAmt := lnwire.NewMSatFromSatoshis(100)

	// In this test, we'll test that we're able to find paths through
	// private channels when providing them as additional edges in our path
	// finding algorithm. To do so, we'll create a new node, doge, and
	// create a private channel between it and songoku. We'll then attempt
	// to find a path from our source node, roasbeef, to doge.
	dogePubKeyHex := "03dd46ff29a6941b4a2607525b043ec9b020b3f318a1bf281536fd7011ec59c882"
	dogePubKeyBytes, err := hex.DecodeString(dogePubKeyHex)
	if err != nil {
		t.Fatalf("unable to decode public key: %v", err)
	}
	dogePubKey, err := btcec.ParsePubKey(dogePubKeyBytes, btcec.S256())
	if err != nil {
		t.Fatalf("unable to parse public key from bytes: %v", err)
	}

	doge := &channeldb.LightningNode{}
	doge.AddPubKey(dogePubKey)
	doge.Alias = "doge"
	copy(doge.PubKeyBytes[:], dogePubKeyBytes)
	graph.aliasMap["doge"] = doge.PubKeyBytes

	// Create the channel edge going from songoku to doge and include it in
	// our map of additional edges.
	songokuToDoge := &channeldb.ChannelEdgePolicy{
		Node:                      doge,
		ChannelID:                 1337,
		FeeBaseMSat:               1,
		FeeProportionalMillionths: 1000,
		TimeLockDelta:             9,
	}

	additionalEdges := map[route.Vertex][]*channeldb.ChannelEdgePolicy{
		graph.aliasMap["songoku"]: {songokuToDoge},
	}

	find := func(r *RestrictParams) (
		[]*channeldb.ChannelEdgePolicy, error) {

		return findPath(
			&graphParams{
				graph:           graph.graph,
				additionalEdges: additionalEdges,
			},
			r, testPathFindingConfig,
			sourceNode.PubKeyBytes, doge.PubKeyBytes, paymentAmt,
			0,
		)
	}

	// We should now be able to find a path from roasbeef to doge.
	path, err := find(noRestrictions)
	if err != nil {
		t.Fatalf("unable to find private path to doge: %v", err)
	}

	// The path should represent the following hops:
	//	roasbeef -> songoku -> doge
	assertExpectedPath(t, graph.aliasMap, path, "songoku", "doge")

	// Now, set custom records for the final hop. This should fail since no
	// dest features are set, and we won't have a node ann to fall back on.
	restrictions := *noRestrictions
	restrictions.DestCustomRecords = record.CustomSet{70000: []byte{}}

	_, err = find(&restrictions)
	if err != errNoTlvPayload {
		t.Fatalf("path shouldn't have been found: %v", err)
	}

	// Set empty dest features so we don't try the fallback. We should still
	// fail since the tlv feature isn't set.
	restrictions.DestFeatures = lnwire.EmptyFeatureVector()

	_, err = find(&restrictions)
	if err != errNoTlvPayload {
		t.Fatalf("path shouldn't have been found: %v", err)
	}

	// Finally, set the tlv feature in the payload and assert we found the
	// same path as before.
	restrictions.DestFeatures = tlvFeatures

	path, err = find(&restrictions)
	if err != nil {
		t.Fatalf("path should have been found: %v", err)
	}
	assertExpectedPath(t, graph.aliasMap, path, "songoku", "doge")
}

// TestNewRoute tests whether the construction of hop payloads by newRoute
// is executed correctly.
func TestNewRoute(t *testing.T) {

	var sourceKey [33]byte
	sourceVertex := route.Vertex(sourceKey)

	testPaymentAddr := [32]byte{0x01, 0x02, 0x03}

	const (
		startingHeight = 100
		finalHopCLTV   = 1
	)

	createHop := func(baseFee lnwire.MilliSatoshi,
		feeRate lnwire.MilliSatoshi,
		bandwidth lnwire.MilliSatoshi,
		timeLockDelta uint16) *channeldb.ChannelEdgePolicy {

		return &channeldb.ChannelEdgePolicy{
			Node: &channeldb.LightningNode{
				Features: lnwire.NewFeatureVector(
					nil, nil,
				),
			},
			FeeProportionalMillionths: feeRate,
			FeeBaseMSat:               baseFee,
			TimeLockDelta:             timeLockDelta,
		}
	}

	testCases := []struct {
		// name identifies the test case in the test output.
		name string

		// hops is the list of hops (the route) that gets passed into
		// the call to newRoute.
		hops []*channeldb.ChannelEdgePolicy

		// paymentAmount is the amount that is send into the route
		// indicated by hops.
		paymentAmount lnwire.MilliSatoshi

		// destFeatures is a feature vector, that if non-nil, will
		// overwrite the final hop's feature vector in the graph.
		destFeatures *lnwire.FeatureVector

		paymentAddr *[32]byte

		// expectedFees is a list of fees that every hop is expected
		// to charge for forwarding.
		expectedFees []lnwire.MilliSatoshi

		// expectedTimeLocks is a list of time lock values that every
		// hop is expected to specify in its outgoing HTLC. The time
		// lock values in this list are relative to the current block
		// height.
		expectedTimeLocks []uint32

		// expectedTotalAmount is the total amount that is expected to
		// be returned from newRoute. This amount should include all
		// the fees to be paid to intermediate hops.
		expectedTotalAmount lnwire.MilliSatoshi

		// expectedTotalTimeLock is the time lock that is expected to
		// be returned from newRoute. This is the time lock that should
		// be specified in the HTLC that is sent by the source node.
		// expectedTotalTimeLock is relative to the current block height.
		expectedTotalTimeLock uint32

		// expectError indicates whether the newRoute call is expected
		// to fail or succeed.
		expectError bool

		// expectedErrorCode indicates the expected error code when
		// expectError is true.
		expectedErrorCode errorCode

		expectedTLVPayload bool

		expectedMPP *record.MPP
	}{
		{
			// For a single hop payment, no fees are expected to be paid.
			name:          "single hop",
			paymentAmount: 100000,
			hops: []*channeldb.ChannelEdgePolicy{
				createHop(100, 1000, 1000000, 10),
			},
			expectedFees:          []lnwire.MilliSatoshi{0},
			expectedTimeLocks:     []uint32{1},
			expectedTotalAmount:   100000,
			expectedTotalTimeLock: 1,
		}, {
			// For a two hop payment, only the fee for the first hop
			// needs to be paid. The destination hop does not require
			// a fee to receive the payment.
			name:          "two hop",
			paymentAmount: 100000,
			hops: []*channeldb.ChannelEdgePolicy{
				createHop(0, 1000, 1000000, 10),
				createHop(30, 1000, 1000000, 5),
			},
			expectedFees:          []lnwire.MilliSatoshi{130, 0},
			expectedTimeLocks:     []uint32{1, 1},
			expectedTotalAmount:   100130,
			expectedTotalTimeLock: 6,
		}, {
			// For a two hop payment, only the fee for the first hop
			// needs to be paid. The destination hop does not require
			// a fee to receive the payment.
			name:          "two hop tlv onion feature",
			destFeatures:  tlvFeatures,
			paymentAmount: 100000,
			hops: []*channeldb.ChannelEdgePolicy{
				createHop(0, 1000, 1000000, 10),
				createHop(30, 1000, 1000000, 5),
			},
			expectedFees:          []lnwire.MilliSatoshi{130, 0},
			expectedTimeLocks:     []uint32{1, 1},
			expectedTotalAmount:   100130,
			expectedTotalTimeLock: 6,
			expectedTLVPayload:    true,
		}, {
			// For a two hop payment, only the fee for the first hop
			// needs to be paid. The destination hop does not require
			// a fee to receive the payment.
			name:          "two hop single shot mpp",
			destFeatures:  tlvPayAddrFeatures,
			paymentAddr:   &testPaymentAddr,
			paymentAmount: 100000,
			hops: []*channeldb.ChannelEdgePolicy{
				createHop(0, 1000, 1000000, 10),
				createHop(30, 1000, 1000000, 5),
			},
			expectedFees:          []lnwire.MilliSatoshi{130, 0},
			expectedTimeLocks:     []uint32{1, 1},
			expectedTotalAmount:   100130,
			expectedTotalTimeLock: 6,
			expectedTLVPayload:    true,
			expectedMPP: record.NewMPP(
				100000, testPaymentAddr,
			),
		}, {
			// A three hop payment where the first and second hop
			// will both charge 1 msat. The fee for the first hop
			// is actually slightly higher than 1, because the amount
			// to forward also includes the fee for the second hop. This
			// gets rounded down to 1.
			name:          "three hop",
			paymentAmount: 100000,
			hops: []*channeldb.ChannelEdgePolicy{
				createHop(0, 10, 1000000, 10),
				createHop(0, 10, 1000000, 5),
				createHop(0, 10, 1000000, 3),
			},
			expectedFees:          []lnwire.MilliSatoshi{1, 1, 0},
			expectedTotalAmount:   100002,
			expectedTimeLocks:     []uint32{4, 1, 1},
			expectedTotalTimeLock: 9,
		}, {
			// A three hop payment where the fee of the first hop
			// is slightly higher (11) than the fee at the second hop,
			// because of the increase amount to forward.
			name:          "three hop with fee carry over",
			paymentAmount: 100000,
			hops: []*channeldb.ChannelEdgePolicy{
				createHop(0, 10000, 1000000, 10),
				createHop(0, 10000, 1000000, 5),
				createHop(0, 10000, 1000000, 3),
			},
			expectedFees:          []lnwire.MilliSatoshi{1010, 1000, 0},
			expectedTotalAmount:   102010,
			expectedTimeLocks:     []uint32{4, 1, 1},
			expectedTotalTimeLock: 9,
		}, {
			// A three hop payment where the fee policies of the first and
			// second hop are just high enough to show the fee carry over
			// effect.
			name:          "three hop with minimal fees for carry over",
			paymentAmount: 100000,
			hops: []*channeldb.ChannelEdgePolicy{
				createHop(0, 10000, 1000000, 10),

				// First hop charges 0.1% so the second hop fee
				// should show up in the first hop fee as 1 msat
				// extra.
				createHop(0, 1000, 1000000, 5),

				// Second hop charges a fixed 1000 msat.
				createHop(1000, 0, 1000000, 3),
			},
			expectedFees:          []lnwire.MilliSatoshi{101, 1000, 0},
			expectedTotalAmount:   101101,
			expectedTimeLocks:     []uint32{4, 1, 1},
			expectedTotalTimeLock: 9,
		}}

	for _, testCase := range testCases {
		testCase := testCase

		// Overwrite the final hop's features if the test requires a
		// custom feature vector.
		if testCase.destFeatures != nil {
			finalHop := testCase.hops[len(testCase.hops)-1]
			finalHop.Node.Features = testCase.destFeatures
		}

		assertRoute := func(t *testing.T, route *route.Route) {
			if route.TotalAmount != testCase.expectedTotalAmount {
				t.Errorf("Expected total amount is be %v"+
					", but got %v instead",
					testCase.expectedTotalAmount,
					route.TotalAmount)
			}

			for i := 0; i < len(testCase.expectedFees); i++ {
				fee := route.HopFee(i)
				if testCase.expectedFees[i] != fee {

					t.Errorf("Expected fee for hop %v to "+
						"be %v, but got %v instead",
						i, testCase.expectedFees[i],
						fee)
				}
			}

			expectedTimeLockHeight := startingHeight +
				testCase.expectedTotalTimeLock

			if route.TotalTimeLock != expectedTimeLockHeight {

				t.Errorf("Expected total time lock to be %v"+
					", but got %v instead",
					expectedTimeLockHeight,
					route.TotalTimeLock)
			}

			for i := 0; i < len(testCase.expectedTimeLocks); i++ {
				expectedTimeLockHeight := startingHeight +
					testCase.expectedTimeLocks[i]

				if expectedTimeLockHeight !=
					route.Hops[i].OutgoingTimeLock {

					t.Errorf("Expected time lock for hop "+
						"%v to be %v, but got %v instead",
						i, expectedTimeLockHeight,
						route.Hops[i].OutgoingTimeLock)
				}
			}

			finalHop := route.Hops[len(route.Hops)-1]
			if !finalHop.LegacyPayload !=
				testCase.expectedTLVPayload {

				t.Errorf("Expected final hop tlv payload: %t, "+
					"but got: %t instead",
					testCase.expectedTLVPayload,
					!finalHop.LegacyPayload)
			}

			if !reflect.DeepEqual(
				finalHop.MPP, testCase.expectedMPP,
			) {
				t.Errorf("Expected final hop mpp field: %v, "+
					" but got: %v instead",
					testCase.expectedMPP, finalHop.MPP)
			}
		}

		t.Run(testCase.name, func(t *testing.T) {
			route, err := newRoute(
				sourceVertex, testCase.hops, startingHeight,
				finalHopParams{
					amt:         testCase.paymentAmount,
					cltvDelta:   finalHopCLTV,
					records:     nil,
					paymentAddr: testCase.paymentAddr,
				},
			)

			if testCase.expectError {
				expectedCode := testCase.expectedErrorCode
				if err == nil || !IsError(err, expectedCode) {
					t.Fatalf("expected newRoute to fail "+
						"with error code %v but got "+
						"%v instead",
						expectedCode, err)
				}
			} else {
				if err != nil {
					t.Errorf("unable to create path: %v", err)
					return
				}

				assertRoute(t, route)
			}
		})
	}
}

func TestNewRoutePathTooLong(t *testing.T) {
	t.Parallel()

	var testChannels []*testChannel

	// Setup a linear network of 21 hops.
	fromNode := "start"
	for i := 0; i < 21; i++ {
		toNode := fmt.Sprintf("node-%v", i+1)
		c := symmetricTestChannel(fromNode, toNode, 100000, &testChannelPolicy{
			Expiry:  144,
			FeeRate: 400,
			MinHTLC: 1,
			MaxHTLC: 100000001,
		})
		testChannels = append(testChannels, c)

		fromNode = toNode
	}

	ctx := newPathFindingTestContext(t, testChannels, "start")
	defer ctx.cleanup()

	// Assert that we can find 20 hop routes.
	node20 := ctx.keyFromAlias("node-20")
	payAmt := lnwire.MilliSatoshi(100001)
	_, err := ctx.findPath(node20, payAmt)
	if err != nil {
		t.Fatalf("unexpected pathfinding failure: %v", err)
	}

	// Assert that finding a 21 hop route fails.
	node21 := ctx.keyFromAlias("node-21")
	_, err = ctx.findPath(node21, payAmt)
	if err != errNoPathFound {
		t.Fatalf("not route error expected, but got %v", err)
	}

	// Assert that we can't find a 20 hop route if custom records make it
	// exceed the maximum payload size.
	ctx.restrictParams.DestFeatures = tlvFeatures
	ctx.restrictParams.DestCustomRecords = map[uint64][]byte{
		100000: bytes.Repeat([]byte{1}, 100),
	}
	_, err = ctx.findPath(node20, payAmt)
	if err != errNoPathFound {
		t.Fatalf("not route error expected, but got %v", err)
	}
}

func TestPathNotAvailable(t *testing.T) {
	t.Parallel()

	graph, err := parseTestGraph(basicGraphFilePath)
	if err != nil {
		t.Fatalf("unable to create graph: %v", err)
	}
	defer graph.cleanUp()

	sourceNode, err := graph.graph.SourceNode()
	if err != nil {
		t.Fatalf("unable to fetch source node: %v", err)
	}

	// With the test graph loaded, we'll test that queries for target that
	// are either unreachable within the graph, or unknown result in an
	// error.
	unknownNodeStr := "03dd46ff29a6941b4a2607525b043ec9b020b3f318a1bf281536fd7011ec59c882"
	unknownNodeBytes, err := hex.DecodeString(unknownNodeStr)
	if err != nil {
		t.Fatalf("unable to parse bytes: %v", err)
	}
	var unknownNode route.Vertex
	copy(unknownNode[:], unknownNodeBytes)

	_, err = findPath(
		&graphParams{
			graph: graph.graph,
		},
		noRestrictions, testPathFindingConfig,
		sourceNode.PubKeyBytes, unknownNode, 100, 0,
	)
	if err != errNoPathFound {
		t.Fatalf("path shouldn't have been found: %v", err)
	}
}

// TestDestTLVGraphFallback asserts that we properly detect when we can send TLV
// records to a receiver, and also that we fallback to the receiver's node
// announcement if we don't have an invoice features.
func TestDestTLVGraphFallback(t *testing.T) {
	t.Parallel()

	testChannels := []*testChannel{
		asymmetricTestChannel("roasbeef", "luoji", 100000,
			&testChannelPolicy{
				Expiry:  144,
				FeeRate: 400,
				MinHTLC: 1,
				MaxHTLC: 100000000,
			}, &testChannelPolicy{
				Expiry:  144,
				FeeRate: 400,
				MinHTLC: 1,
				MaxHTLC: 100000000,
			}, 0),
		asymmetricTestChannel("roasbeef", "satoshi", 100000,
			&testChannelPolicy{
				Expiry:  144,
				FeeRate: 400,
				MinHTLC: 1,
				MaxHTLC: 100000000,
			}, &testChannelPolicy{
				Expiry:   144,
				FeeRate:  400,
				MinHTLC:  1,
				MaxHTLC:  100000000,
				Features: tlvFeatures,
			}, 0),
	}

	ctx := newPathFindingTestContext(t, testChannels, "roasbeef")
	defer ctx.cleanup()

	sourceNode, err := ctx.graphParams.graph.SourceNode()
	if err != nil {
		t.Fatalf("unable to fetch source node: %v", err)

	}

	find := func(r *RestrictParams,
		target route.Vertex) ([]*channeldb.ChannelEdgePolicy, error) {

		return findPath(
			&graphParams{
				graph: ctx.graphParams.graph,
			},
			r, testPathFindingConfig,
			sourceNode.PubKeyBytes, target, 100, 0,
		)
	}

	// Luoji's node ann has an empty feature vector.
	luoji := ctx.testGraphInstance.aliasMap["luoji"]

	// Satoshi's node ann supports TLV.
	satoshi := ctx.testGraphInstance.aliasMap["satoshi"]

	restrictions := *noRestrictions

	// Add custom records w/o any dest features.
	restrictions.DestCustomRecords = record.CustomSet{70000: []byte{}}

	// Path to luoji should fail because his node ann features are empty.
	_, err = find(&restrictions, luoji)
	if err != errNoTlvPayload {
		t.Fatalf("path shouldn't have been found: %v", err)
	}

	// However, path to satoshi should succeed via the fallback because his
	// node ann features have the TLV bit.
	path, err := find(&restrictions, satoshi)
	if err != nil {
		t.Fatalf("path should have been found: %v", err)
	}
	assertExpectedPath(t, ctx.testGraphInstance.aliasMap, path, "satoshi")

	// Add empty destination features. This should cause both paths to fail,
	// since this override anything in the graph.
	restrictions.DestFeatures = lnwire.EmptyFeatureVector()

	_, err = find(&restrictions, luoji)
	if err != errNoTlvPayload {
		t.Fatalf("path shouldn't have been found: %v", err)
	}
	_, err = find(&restrictions, satoshi)
	if err != errNoTlvPayload {
		t.Fatalf("path shouldn't have been found: %v", err)
	}

	// Finally, set the TLV dest feature. We should succeed in finding a
	// path to luoji.
	restrictions.DestFeatures = tlvFeatures

	path, err = find(&restrictions, luoji)
	if err != nil {
		t.Fatalf("path should have been found: %v", err)
	}
	assertExpectedPath(t, ctx.testGraphInstance.aliasMap, path, "luoji")
}

// TestMissingFeatureDep asserts that we fail path finding when the
// destination's features are broken, in that the feature vector doesn't signal
// all transitive dependencies.
func TestMissingFeatureDep(t *testing.T) {
	t.Parallel()

	testChannels := []*testChannel{
		asymmetricTestChannel("roasbeef", "conner", 100000,
			&testChannelPolicy{
				Expiry:  144,
				FeeRate: 400,
				MinHTLC: 1,
				MaxHTLC: 100000000,
			},
			&testChannelPolicy{
				Expiry:   144,
				FeeRate:  400,
				MinHTLC:  1,
				MaxHTLC:  100000000,
				Features: payAddrFeatures,
			}, 0,
		),
		asymmetricTestChannel("conner", "joost", 100000,
			&testChannelPolicy{
				Expiry:   144,
				FeeRate:  400,
				MinHTLC:  1,
				MaxHTLC:  100000000,
				Features: payAddrFeatures,
			},
			&testChannelPolicy{
				Expiry:  144,
				FeeRate: 400,
				MinHTLC: 1,
				MaxHTLC: 100000000,
			}, 0,
		),
	}

	ctx := newPathFindingTestContext(t, testChannels, "roasbeef")
	defer ctx.cleanup()

	// Conner's node in the graph has a broken feature vector, since it
	// signals payment addresses without signaling tlv onions. Pathfinding
	// should fail since we validate transitive feature dependencies for the
	// final node.
	conner := ctx.keyFromAlias("conner")
	joost := ctx.keyFromAlias("joost")

	_, err := ctx.findPath(conner, 100)
	if err != feature.NewErrMissingFeatureDep(
		lnwire.TLVOnionPayloadOptional,
	) {
		t.Fatalf("path shouldn't have been found: %v", err)
	}

	// Now, set the TLV and payment addresses features to override the
	// broken features found in the graph. We should succeed in finding a
	// path to conner.
	ctx.restrictParams.DestFeatures = tlvPayAddrFeatures

	path, err := ctx.findPath(conner, 100)
	if err != nil {
		t.Fatalf("path should have been found: %v", err)
	}
	assertExpectedPath(t, ctx.testGraphInstance.aliasMap, path, "conner")

	// Finally, try to find a route to joost through conner. The
	// destination features are set properly from the previous assertions,
	// but conner's feature vector in the graph is still broken. We expect
	// errNoPathFound and not the missing feature dep err above since
	// intermediate hops are simply skipped if they have invalid feature
	// vectors, leaving no possible route to joost.
	_, err = ctx.findPath(joost, 100)
	if err != errNoPathFound {
		t.Fatalf("path shouldn't have been found: %v", err)
	}
}

// TestUnknownRequiredFeatures asserts that we fail path finding when the
// destination requires an unknown required feature, and that we skip
// intermediaries that signal unknown required features.
func TestUnknownRequiredFeatures(t *testing.T) {
	t.Parallel()

	testChannels := []*testChannel{
		asymmetricTestChannel("roasbeef", "conner", 100000,
			&testChannelPolicy{
				Expiry:  144,
				FeeRate: 400,
				MinHTLC: 1,
				MaxHTLC: 100000000,
			},
			&testChannelPolicy{
				Expiry:   144,
				FeeRate:  400,
				MinHTLC:  1,
				MaxHTLC:  100000000,
				Features: unknownRequiredFeatures,
			}, 0,
		),
		asymmetricTestChannel("conner", "joost", 100000,
			&testChannelPolicy{
				Expiry:   144,
				FeeRate:  400,
				MinHTLC:  1,
				MaxHTLC:  100000000,
				Features: unknownRequiredFeatures,
			},
			&testChannelPolicy{
				Expiry:  144,
				FeeRate: 400,
				MinHTLC: 1,
				MaxHTLC: 100000000,
			}, 0,
		),
	}

	ctx := newPathFindingTestContext(t, testChannels, "roasbeef")
	defer ctx.cleanup()

	conner := ctx.keyFromAlias("conner")
	joost := ctx.keyFromAlias("joost")

	// Conner's node in the graph has an unknown required feature (100).
	// Pathfinding should fail since we check the destination's features for
	// unknown required features before beginning pathfinding.
	expErr := feature.NewErrUnknownRequired([]lnwire.FeatureBit{100})
	_, err := ctx.findPath(conner, 100)
	if !reflect.DeepEqual(err, expErr) {
		t.Fatalf("path shouldn't have been found: %v", err)
	}

	// Now, try to find a route to joost through conner. The destination
	// features are valid, but conner's feature vector in the graph still
	// requires feature 100. We expect errNoPathFound and not the error
	// above since intermediate hops are simply skipped if they have invalid
	// feature vectors, leaving no possible route to joost. This asserts
	// that we don't try to route _through_ nodes with unknown required
	// features.
	_, err = ctx.findPath(joost, 100)
	if err != errNoPathFound {
		t.Fatalf("path shouldn't have been found: %v", err)
	}
}

// TestDestPaymentAddr asserts that we properly detect when we can send a
// payment address to a receiver, and also that we fallback to the receiver's
// node announcement if we don't have an invoice features.
func TestDestPaymentAddr(t *testing.T) {
	t.Parallel()

	testChannels := []*testChannel{
		symmetricTestChannel("roasbeef", "luoji", 100000,
			&testChannelPolicy{
				Expiry:  144,
				FeeRate: 400,
				MinHTLC: 1,
				MaxHTLC: 100000000,
			},
		),
	}

	ctx := newPathFindingTestContext(t, testChannels, "roasbeef")
	defer ctx.cleanup()

	luoji := ctx.keyFromAlias("luoji")

	// Add payment address w/o any invoice features.
	ctx.restrictParams.PaymentAddr = &[32]byte{1}

	// Add empty destination features. This should cause us to fail, since
	// this overrides anything in the graph.
	ctx.restrictParams.DestFeatures = lnwire.EmptyFeatureVector()

	_, err := ctx.findPath(luoji, 100)
	if err != errNoPaymentAddr {
		t.Fatalf("path shouldn't have been found: %v", err)
	}

	// Now, set the TLV and payment address features for the destination. We
	// should succeed in finding a path to luoji.
	ctx.restrictParams.DestFeatures = tlvPayAddrFeatures

	path, err := ctx.findPath(luoji, 100)
	if err != nil {
		t.Fatalf("path should have been found: %v", err)
	}
	assertExpectedPath(t, ctx.testGraphInstance.aliasMap, path, "luoji")
}

func TestPathInsufficientCapacity(t *testing.T) {
	t.Parallel()

	graph, err := parseTestGraph(basicGraphFilePath)
	if err != nil {
		t.Fatalf("unable to create graph: %v", err)
	}
	defer graph.cleanUp()

	sourceNode, err := graph.graph.SourceNode()
	if err != nil {
		t.Fatalf("unable to fetch source node: %v", err)
	}

	// Next, test that attempting to find a path in which the current
	// channel graph cannot support due to insufficient capacity triggers
	// an error.

	// To test his we'll attempt to make a payment of 1 BTC, or 100 million
	// satoshis. The largest channel in the basic graph is of size 100k
	// satoshis, so we shouldn't be able to find a path to sophon even
	// though we have a 2-hop link.
	target := graph.aliasMap["sophon"]

	payAmt := lnwire.NewMSatFromSatoshis(btcutil.SatoshiPerBitcoin)
	_, err = findPath(
		&graphParams{
			graph: graph.graph,
		},
		noRestrictions, testPathFindingConfig,
		sourceNode.PubKeyBytes, target, payAmt, 0,
	)
	if err != errNoPathFound {
		t.Fatalf("graph shouldn't be able to support payment: %v", err)
	}
}

// TestRouteFailMinHTLC tests that if we attempt to route an HTLC which is
// smaller than the advertised minHTLC of an edge, then path finding fails.
func TestRouteFailMinHTLC(t *testing.T) {
	t.Parallel()

	graph, err := parseTestGraph(basicGraphFilePath)
	if err != nil {
		t.Fatalf("unable to create graph: %v", err)
	}
	defer graph.cleanUp()

	sourceNode, err := graph.graph.SourceNode()
	if err != nil {
		t.Fatalf("unable to fetch source node: %v", err)
	}

	// We'll not attempt to route an HTLC of 10 SAT from roasbeef to Son
	// Goku. However, the min HTLC of Son Goku is 1k SAT, as a result, this
	// attempt should fail.
	target := graph.aliasMap["songoku"]
	payAmt := lnwire.MilliSatoshi(10)
	_, err = findPath(
		&graphParams{
			graph: graph.graph,
		},
		noRestrictions, testPathFindingConfig,
		sourceNode.PubKeyBytes, target, payAmt, 0,
	)
	if err != errNoPathFound {
		t.Fatalf("graph shouldn't be able to support payment: %v", err)
	}
}

// TestRouteFailMaxHTLC tests that if we attempt to route an HTLC which is
// larger than the advertised max HTLC of an edge, then path finding fails.
func TestRouteFailMaxHTLC(t *testing.T) {
	t.Parallel()

	// Set up a test graph:
	// roasbeef <--> firstHop <--> secondHop <--> target
	// We will be adjusting the max HTLC of the edge between the first and
	// second hops.
	var firstToSecondID uint64 = 1
	testChannels := []*testChannel{
		symmetricTestChannel("roasbeef", "first", 100000, &testChannelPolicy{
			Expiry:  144,
			FeeRate: 400,
			MinHTLC: 1,
			MaxHTLC: 100000001,
		}),
		symmetricTestChannel("first", "second", 100000, &testChannelPolicy{
			Expiry:  144,
			FeeRate: 400,
			MinHTLC: 1,
			MaxHTLC: 100000002,
		}, firstToSecondID),
		symmetricTestChannel("second", "target", 100000, &testChannelPolicy{
			Expiry:  144,
			FeeRate: 400,
			MinHTLC: 1,
			MaxHTLC: 100000003,
		}),
	}

	ctx := newPathFindingTestContext(t, testChannels, "roasbeef")
	defer ctx.cleanup()

	// First, attempt to send a payment greater than the max HTLC we are
	// about to set, which should succeed.
	target := ctx.keyFromAlias("target")
	payAmt := lnwire.MilliSatoshi(100001)
	_, err := ctx.findPath(target, payAmt)
	if err != nil {
		t.Fatalf("graph should've been able to support payment: %v", err)
	}

	// Next, update the middle edge policy to only allow payments up to 100k
	// msat.
	graph := ctx.testGraphInstance.graph
	_, midEdge, _, err := graph.FetchChannelEdgesByID(firstToSecondID)
	if err != nil {
		t.Fatalf("unable to fetch channel edges by ID: %v", err)
	}
	midEdge.MessageFlags = 1
	midEdge.MaxHTLC = payAmt - 1
	if err := graph.UpdateEdgePolicy(midEdge); err != nil {
		t.Fatalf("unable to update edge: %v", err)
	}

	// We'll now attempt to route through that edge with a payment above
	// 100k msat, which should fail.
	_, err = ctx.findPath(target, payAmt)
	if err != errNoPathFound {
		t.Fatalf("graph shouldn't be able to support payment: %v", err)
	}
}

// TestRouteFailDisabledEdge tests that if we attempt to route to an edge
// that's disabled, then that edge is disqualified, and the routing attempt
// will fail. We also test that this is true only for non-local edges, as we'll
// ignore the disable flags, with the assumption that the correct bandwidth is
// found among the bandwidth hints.
func TestRouteFailDisabledEdge(t *testing.T) {
	t.Parallel()

	graph, err := parseTestGraph(basicGraphFilePath)
	if err != nil {
		t.Fatalf("unable to create graph: %v", err)
	}
	defer graph.cleanUp()

	sourceNode, err := graph.graph.SourceNode()
	if err != nil {
		t.Fatalf("unable to fetch source node: %v", err)
	}

	// First, we'll try to route from roasbeef -> sophon. This should
	// succeed without issue, and return a single path via phamnuwen
	target := graph.aliasMap["sophon"]
	payAmt := lnwire.NewMSatFromSatoshis(105000)
	_, err = findPath(
		&graphParams{
			graph: graph.graph,
		},
		noRestrictions, testPathFindingConfig,
		sourceNode.PubKeyBytes, target, payAmt, 0,
	)
	if err != nil {
		t.Fatalf("unable to find path: %v", err)
	}

	// Disable the edge roasbeef->phamnuwen. This should not impact the
	// path finding, as we don't consider the disable flag for local
	// channels (and roasbeef is the source).
	roasToPham := uint64(999991)
	_, e1, e2, err := graph.graph.FetchChannelEdgesByID(roasToPham)
	if err != nil {
		t.Fatalf("unable to fetch edge: %v", err)
	}
	e1.ChannelFlags |= lnwire.ChanUpdateDisabled
	if err := graph.graph.UpdateEdgePolicy(e1); err != nil {
		t.Fatalf("unable to update edge: %v", err)
	}
	e2.ChannelFlags |= lnwire.ChanUpdateDisabled
	if err := graph.graph.UpdateEdgePolicy(e2); err != nil {
		t.Fatalf("unable to update edge: %v", err)
	}

	_, err = findPath(
		&graphParams{
			graph: graph.graph,
		},
		noRestrictions, testPathFindingConfig,
		sourceNode.PubKeyBytes, target, payAmt, 0,
	)
	if err != nil {
		t.Fatalf("unable to find path: %v", err)
	}

	// Now, we'll modify the edge from phamnuwen -> sophon, to read that
	// it's disabled.
	phamToSophon := uint64(99999)
	_, e, _, err := graph.graph.FetchChannelEdgesByID(phamToSophon)
	if err != nil {
		t.Fatalf("unable to fetch edge: %v", err)
	}
	e.ChannelFlags |= lnwire.ChanUpdateDisabled
	if err := graph.graph.UpdateEdgePolicy(e); err != nil {
		t.Fatalf("unable to update edge: %v", err)
	}

	// If we attempt to route through that edge, we should get a failure as
	// it is no longer eligible.
	_, err = findPath(
		&graphParams{
			graph: graph.graph,
		},
		noRestrictions, testPathFindingConfig,
		sourceNode.PubKeyBytes, target, payAmt, 0,
	)
	if err != errNoPathFound {
		t.Fatalf("graph shouldn't be able to support payment: %v", err)
	}
}

// TestPathSourceEdgesBandwidth tests that explicitly passing in a set of
// bandwidth hints is used by the path finding algorithm to consider whether to
// use a local channel.
func TestPathSourceEdgesBandwidth(t *testing.T) {
	t.Parallel()

	graph, err := parseTestGraph(basicGraphFilePath)
	if err != nil {
		t.Fatalf("unable to create graph: %v", err)
	}
	defer graph.cleanUp()

	sourceNode, err := graph.graph.SourceNode()
	if err != nil {
		t.Fatalf("unable to fetch source node: %v", err)
	}

	// First, we'll try to route from roasbeef -> sophon. This should
	// succeed without issue, and return a path via songoku, as that's the
	// cheapest path.
	target := graph.aliasMap["sophon"]
	payAmt := lnwire.NewMSatFromSatoshis(50000)
	path, err := findPath(
		&graphParams{
			graph: graph.graph,
		},
		noRestrictions, testPathFindingConfig,
		sourceNode.PubKeyBytes, target, payAmt, 0,
	)
	if err != nil {
		t.Fatalf("unable to find path: %v", err)
	}
	assertExpectedPath(t, graph.aliasMap, path, "songoku", "sophon")

	// Now we'll set the bandwidth of the edge roasbeef->songoku and
	// roasbeef->phamnuwen to 0.
	roasToSongoku := uint64(12345)
	roasToPham := uint64(999991)
	bandwidths := map[uint64]lnwire.MilliSatoshi{
		roasToSongoku: 0,
		roasToPham:    0,
	}

	// Since both these edges has a bandwidth of zero, no path should be
	// found.
	_, err = findPath(
		&graphParams{
			graph:          graph.graph,
			bandwidthHints: bandwidths,
		},
		noRestrictions, testPathFindingConfig,
		sourceNode.PubKeyBytes, target, payAmt, 0,
	)
	if err != errNoPathFound {
		t.Fatalf("graph shouldn't be able to support payment: %v", err)
	}

	// Set the bandwidth of roasbeef->phamnuwen high enough to carry the
	// payment.
	bandwidths[roasToPham] = 2 * payAmt

	// Now, if we attempt to route again, we should find the path via
	// phamnuven, as the other source edge won't be considered.
	path, err = findPath(
		&graphParams{
			graph:          graph.graph,
			bandwidthHints: bandwidths,
		},
		noRestrictions, testPathFindingConfig,
		sourceNode.PubKeyBytes, target, payAmt, 0,
	)
	if err != nil {
		t.Fatalf("unable to find path: %v", err)
	}
	assertExpectedPath(t, graph.aliasMap, path, "phamnuwen", "sophon")

	// Finally, set the roasbeef->songoku bandwidth, but also set its
	// disable flag.
	bandwidths[roasToSongoku] = 2 * payAmt
	_, e1, e2, err := graph.graph.FetchChannelEdgesByID(roasToSongoku)
	if err != nil {
		t.Fatalf("unable to fetch edge: %v", err)
	}
	e1.ChannelFlags |= lnwire.ChanUpdateDisabled
	if err := graph.graph.UpdateEdgePolicy(e1); err != nil {
		t.Fatalf("unable to update edge: %v", err)
	}
	e2.ChannelFlags |= lnwire.ChanUpdateDisabled
	if err := graph.graph.UpdateEdgePolicy(e2); err != nil {
		t.Fatalf("unable to update edge: %v", err)
	}

	// Since we ignore disable flags for local channels, a path should
	// still be found.
	path, err = findPath(
		&graphParams{
			graph:          graph.graph,
			bandwidthHints: bandwidths,
		},
		noRestrictions, testPathFindingConfig,
		sourceNode.PubKeyBytes, target, payAmt, 0,
	)
	if err != nil {
		t.Fatalf("unable to find path: %v", err)
	}
	assertExpectedPath(t, graph.aliasMap, path, "songoku", "sophon")
}

func TestPathInsufficientCapacityWithFee(t *testing.T) {
	t.Parallel()

	// TODO(roasbeef): encode live graph to json

	// TODO(roasbeef): need to add a case, or modify the fee ratio for one
	// to ensure that has going forward, but when fees are applied doesn't
	// work
}

func TestPathFindSpecExample(t *testing.T) {
	t.Parallel()

	// All our path finding tests will assume a starting height of 100, so
	// we'll pass that in to ensure that the router uses 100 as the current
	// height.
	const startingHeight = 100
	ctx, cleanUp, err := createTestCtxFromFile(startingHeight, specExampleFilePath)
	if err != nil {
		t.Fatalf("unable to create router: %v", err)
	}
	defer cleanUp()

	// We'll first exercise the scenario of a direct payment from Bob to
	// Carol, so we set "B" as the source node so path finding starts from
	// Bob.
	bob := ctx.aliases["B"]
	bobNode, err := ctx.graph.FetchLightningNode(nil, bob)
	if err != nil {
		t.Fatalf("unable to find bob: %v", err)
	}
	if err := ctx.graph.SetSourceNode(bobNode); err != nil {
		t.Fatalf("unable to set source node: %v", err)
	}

	// Query for a route of 4,999,999 mSAT to carol.
	carol := ctx.aliases["C"]
	const amt lnwire.MilliSatoshi = 4999999
	route, err := ctx.router.FindRoute(
		bobNode.PubKeyBytes, carol, amt, noRestrictions, nil,
	)
	if err != nil {
		t.Fatalf("unable to find route: %v", err)
	}

	// Now we'll examine the route returned for correctness.
	//
	// It should be sending the exact payment amount as there are no
	// additional hops.
	if route.TotalAmount != amt {
		t.Fatalf("wrong total amount: got %v, expected %v",
			route.TotalAmount, amt)
	}
	if route.Hops[0].AmtToForward != amt {
		t.Fatalf("wrong forward amount: got %v, expected %v",
			route.Hops[0].AmtToForward, amt)
	}

	fee := route.HopFee(0)
	if fee != 0 {
		t.Fatalf("wrong hop fee: got %v, expected %v", fee, 0)
	}

	// The CLTV expiry should be the current height plus 9 (the expiry for
	// the B -> C channel.
	if route.TotalTimeLock !=
		startingHeight+zpay32.DefaultFinalCLTVDelta {

		t.Fatalf("wrong total time lock: got %v, expecting %v",
			route.TotalTimeLock,
			startingHeight+zpay32.DefaultFinalCLTVDelta)
	}

	// Next, we'll set A as the source node so we can assert that we create
	// the proper route for any queries starting with Alice.
	alice := ctx.aliases["A"]
	aliceNode, err := ctx.graph.FetchLightningNode(nil, alice)
	if err != nil {
		t.Fatalf("unable to find alice: %v", err)
	}
	if err := ctx.graph.SetSourceNode(aliceNode); err != nil {
		t.Fatalf("unable to set source node: %v", err)
	}
	ctx.router.selfNode = aliceNode
	source, err := ctx.graph.SourceNode()
	if err != nil {
		t.Fatalf("unable to retrieve source node: %v", err)
	}
	if source.PubKeyBytes != alice {
		t.Fatalf("source node not set")
	}

	// We'll now request a route from A -> B -> C.
	route, err = ctx.router.FindRoute(
		source.PubKeyBytes, carol, amt, noRestrictions, nil,
	)
	if err != nil {
		t.Fatalf("unable to find routes: %v", err)
	}

	// The route should be two hops.
	if len(route.Hops) != 2 {
		t.Fatalf("route should be %v hops, is instead %v", 2,
			len(route.Hops))
	}

	// The total amount should factor in a fee of 10199 and also use a CLTV
	// delta total of 29 (20 + 9),
	expectedAmt := lnwire.MilliSatoshi(5010198)
	if route.TotalAmount != expectedAmt {
		t.Fatalf("wrong amount: got %v, expected %v",
			route.TotalAmount, expectedAmt)
	}
	if route.TotalTimeLock != startingHeight+29 {
		t.Fatalf("wrong total time lock: got %v, expecting %v",
			route.TotalTimeLock, startingHeight+29)
	}

	// Ensure that the hops of the route are properly crafted.
	//
	// After taking the fee, Bob should be forwarding the remainder which
	// is the exact payment to Bob.
	if route.Hops[0].AmtToForward != amt {
		t.Fatalf("wrong forward amount: got %v, expected %v",
			route.Hops[0].AmtToForward, amt)
	}

	// We shouldn't pay any fee for the first, hop, but the fee for the
	// second hop posted fee should be exactly:

	// The fee that we pay for the second hop will be "applied to the first
	// hop, so we should get a fee of exactly:
	//
	//  * 200 + 4999999 * 2000 / 1000000 = 10199

	fee = route.HopFee(0)
	if fee != 10199 {
		t.Fatalf("wrong hop fee: got %v, expected %v", fee, 10199)
	}

	// While for the final hop, as there's no additional hop afterwards, we
	// pay no fee.
	fee = route.HopFee(1)
	if fee != 0 {
		t.Fatalf("wrong hop fee: got %v, expected %v", fee, 0)
	}

	// The outgoing CLTV value itself should be the current height plus 30
	// to meet Carol's requirements.
	if route.Hops[0].OutgoingTimeLock !=
		startingHeight+zpay32.DefaultFinalCLTVDelta {

		t.Fatalf("wrong total time lock: got %v, expecting %v",
			route.Hops[0].OutgoingTimeLock,
			startingHeight+zpay32.DefaultFinalCLTVDelta)
	}

	// For B -> C, we assert that the final hop also has the proper
	// parameters.
	lastHop := route.Hops[1]
	if lastHop.AmtToForward != amt {
		t.Fatalf("wrong forward amount: got %v, expected %v",
			lastHop.AmtToForward, amt)
	}
	if lastHop.OutgoingTimeLock !=
		startingHeight+zpay32.DefaultFinalCLTVDelta {

		t.Fatalf("wrong total time lock: got %v, expecting %v",
			lastHop.OutgoingTimeLock,
			startingHeight+zpay32.DefaultFinalCLTVDelta)
	}
}

func assertExpectedPath(t *testing.T, aliasMap map[string]route.Vertex,
	path []*channeldb.ChannelEdgePolicy, nodeAliases ...string) {

	if len(path) != len(nodeAliases) {
		t.Fatal("number of hops and number of aliases do not match")
	}

	for i, hop := range path {
		if hop.Node.PubKeyBytes != aliasMap[nodeAliases[i]] {
			t.Fatalf("expected %v to be pos #%v in hop, instead "+
				"%v was", nodeAliases[i], i, hop.Node.Alias)
		}
	}
}

// TestNewRouteFromEmptyHops tests that the NewRouteFromHops function returns an
// error when the hop list is empty.
func TestNewRouteFromEmptyHops(t *testing.T) {
	t.Parallel()

	var source route.Vertex
	_, err := route.NewRouteFromHops(0, 0, source, []*route.Hop{})
	if err != route.ErrNoRouteHopsProvided {
		t.Fatalf("expected empty hops error: instead got: %v", err)
	}
}

// TestRestrictOutgoingChannel asserts that a outgoing channel restriction is
// obeyed by the path finding algorithm.
func TestRestrictOutgoingChannel(t *testing.T) {
	t.Parallel()

	// Set up a test graph with three possible paths from roasbeef to
	// target. The path through channel 2 is the highest cost path.
	testChannels := []*testChannel{
		symmetricTestChannel("roasbeef", "a", 100000, &testChannelPolicy{
			Expiry: 144,
		}, 1),
		symmetricTestChannel("a", "target", 100000, &testChannelPolicy{
			Expiry:  144,
			FeeRate: 400,
		}, 4),
		symmetricTestChannel("roasbeef", "b", 100000, &testChannelPolicy{
			Expiry: 144,
		}, 2),
		symmetricTestChannel("roasbeef", "b", 100000, &testChannelPolicy{
			Expiry: 144,
		}, 3),
		symmetricTestChannel("b", "target", 100000, &testChannelPolicy{
			Expiry:  144,
			FeeRate: 800,
		}, 5),
	}

	ctx := newPathFindingTestContext(t, testChannels, "roasbeef")
	defer ctx.cleanup()

	const (
		startingHeight = 100
		finalHopCLTV   = 1
	)

	paymentAmt := lnwire.NewMSatFromSatoshis(100)
	target := ctx.keyFromAlias("target")
	outgoingChannelID := uint64(2)

	// Find the best path given the restriction to only use channel 2 as the
	// outgoing channel.
	ctx.restrictParams.OutgoingChannelID = &outgoingChannelID
	path, err := ctx.findPath(target, paymentAmt)
	if err != nil {
		t.Fatalf("unable to find path: %v", err)
	}
	route, err := newRoute(
		ctx.source, path, startingHeight,
		finalHopParams{
			amt:       paymentAmt,
			cltvDelta: finalHopCLTV,
			records:   nil,
		},
	)
	if err != nil {
		t.Fatalf("unable to create path: %v", err)
	}

	// Assert that the route starts with channel 2, in line with the
	// specified restriction.
	if route.Hops[0].ChannelID != 2 {
		t.Fatalf("expected route to pass through channel 2, "+
			"but channel %v was selected instead", route.Hops[0].ChannelID)
	}
}

// TestRestrictLastHop asserts that a last hop restriction is obeyed by the path
// finding algorithm.
func TestRestrictLastHop(t *testing.T) {
	t.Parallel()

	// Set up a test graph with three possible paths from roasbeef to
	// target. The path via channel 1 and 2 is the lowest cost path.
	testChannels := []*testChannel{
		symmetricTestChannel("source", "a", 100000, &testChannelPolicy{
			Expiry: 144,
		}, 1),
		symmetricTestChannel("a", "target", 100000, &testChannelPolicy{
			Expiry:  144,
			FeeRate: 400,
		}, 2),
		symmetricTestChannel("source", "b", 100000, &testChannelPolicy{
			Expiry: 144,
		}, 3),
		symmetricTestChannel("b", "target", 100000, &testChannelPolicy{
			Expiry:  144,
			FeeRate: 800,
		}, 4),
	}

	ctx := newPathFindingTestContext(t, testChannels, "source")
	defer ctx.cleanup()

	paymentAmt := lnwire.NewMSatFromSatoshis(100)
	target := ctx.keyFromAlias("target")
	lastHop := ctx.keyFromAlias("b")

	// Find the best path given the restriction to use b as the last hop.
	// This should force pathfinding to not take the lowest cost option.
	ctx.restrictParams.LastHop = &lastHop
	path, err := ctx.findPath(target, paymentAmt)
	if err != nil {
		t.Fatalf("unable to find path: %v", err)
	}
	if path[0].ChannelID != 3 {
		t.Fatalf("expected route to pass through channel 3, "+
			"but channel %v was selected instead",
			path[0].ChannelID)
	}
}

// TestCltvLimit asserts that a cltv limit is obeyed by the path finding
// algorithm.
func TestCltvLimit(t *testing.T) {
	t.Run("no limit", func(t *testing.T) { testCltvLimit(t, 2016, 1) })
	t.Run("no path", func(t *testing.T) { testCltvLimit(t, 50, 0) })
	t.Run("force high cost", func(t *testing.T) { testCltvLimit(t, 80, 3) })
}

func testCltvLimit(t *testing.T, limit uint32, expectedChannel uint64) {
	t.Parallel()

	// Set up a test graph with three possible paths to the target. The path
	// through a is the lowest cost with a high time lock (144). The path
	// through b has a higher cost but a lower time lock (100). That path
	// through c and d (two hops) has the same case as the path through b,
	// but the total time lock is lower (60).
	testChannels := []*testChannel{
		symmetricTestChannel("roasbeef", "a", 100000, &testChannelPolicy{}, 1),
		symmetricTestChannel("a", "target", 100000, &testChannelPolicy{
			Expiry:      144,
			FeeBaseMsat: 10000,
			MinHTLC:     1,
		}),
		symmetricTestChannel("roasbeef", "b", 100000, &testChannelPolicy{}, 2),
		symmetricTestChannel("b", "target", 100000, &testChannelPolicy{
			Expiry:      100,
			FeeBaseMsat: 20000,
			MinHTLC:     1,
		}),
		symmetricTestChannel("roasbeef", "c", 100000, &testChannelPolicy{}, 3),
		symmetricTestChannel("c", "d", 100000, &testChannelPolicy{
			Expiry:      30,
			FeeBaseMsat: 10000,
			MinHTLC:     1,
		}),
		symmetricTestChannel("d", "target", 100000, &testChannelPolicy{
			Expiry:      30,
			FeeBaseMsat: 10000,
			MinHTLC:     1,
		}),
	}

	ctx := newPathFindingTestContext(t, testChannels, "roasbeef")
	defer ctx.cleanup()

	paymentAmt := lnwire.NewMSatFromSatoshis(100)
	target := ctx.keyFromAlias("target")

	ctx.restrictParams.CltvLimit = limit
	path, err := ctx.findPath(target, paymentAmt)
	if expectedChannel == 0 {
		// Finish test if we expect no route.
		if err == errNoPathFound {
			return
		}
		t.Fatal("expected no path to be found")
	}
	if err != nil {
		t.Fatalf("unable to find path: %v", err)
	}

	const (
		startingHeight = 100
		finalHopCLTV   = 1
	)
	route, err := newRoute(
		ctx.source, path, startingHeight,
		finalHopParams{
			amt:       paymentAmt,
			cltvDelta: finalHopCLTV,
			records:   nil,
		},
	)
	if err != nil {
		t.Fatalf("unable to create path: %v", err)
	}

	// Assert that the route starts with the expected channel.
	if route.Hops[0].ChannelID != expectedChannel {
		t.Fatalf("expected route to pass through channel %v, "+
			"but channel %v was selected instead", expectedChannel,
			route.Hops[0].ChannelID)
	}
}

// TestProbabilityRouting asserts that path finding not only takes into account
// fees but also success probability.
func TestProbabilityRouting(t *testing.T) {
	t.Parallel()

	testCases := []struct {
		name           string
		p10, p11, p20  float64
		minProbability float64
		expectedChan   uint64
	}{
		// Test two variations with probabilities that should multiply
		// to the same total route probability. In both cases the three
		// hop route should be the best route. The three hop route has a
		// probability of 0.5 * 0.8 = 0.4. The fee is 5 (chan 10) + 8
		// (chan 11) = 13. Path finding distance should work out to: 13
		// + 10 (attempt penalty) / 0.4 = 38. The two hop route is 25 +
		// 10 / 0.7 = 39.
		{
			name: "three hop 1",
			p10:  0.8, p11: 0.5, p20: 0.7,
			minProbability: 0.1,
			expectedChan:   10,
		},
		{
			name: "three hop 2",
			p10:  0.5, p11: 0.8, p20: 0.7,
			minProbability: 0.1,
			expectedChan:   10,
		},

		// If the probability of the two hop route is increased, its
		// distance becomes 25 + 10 / 0.85 = 37. This is less than the
		// three hop route with its distance 38. So with an attempt
		// penalty of 10, the higher fee route is chosen because of the
		// compensation for success probability.
		{
			name: "two hop higher cost",
			p10:  0.5, p11: 0.8, p20: 0.85,
			minProbability: 0.1,
			expectedChan:   20,
		},

		// If the same probabilities are used with a probability lower bound of
		// 0.5, we expect the three hop route with probability 0.4 to be
		// excluded and the two hop route to be picked.
		{
			name: "probability limit",
			p10:  0.8, p11: 0.5, p20: 0.7,
			minProbability: 0.5,
			expectedChan:   20,
		},

		// With a probability limit above the probability of both routes, we
		// expect no route to be returned. This expectation is signaled by using
		// expected channel 0.
		{
			name: "probability limit no routes",
			p10:  0.8, p11: 0.5, p20: 0.7,
			minProbability: 0.8,
			expectedChan:   0,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			testProbabilityRouting(
				t, tc.p10, tc.p11, tc.p20,
				tc.minProbability, tc.expectedChan,
			)
		})
	}
}

func testProbabilityRouting(t *testing.T, p10, p11, p20, minProbability float64,
	expectedChan uint64) {

	t.Parallel()

	// Set up a test graph with two possible paths to the target: a three
	// hop path (via channels 10 and 11) and a two hop path (via channel
	// 20).
	testChannels := []*testChannel{
		symmetricTestChannel("roasbeef", "a1", 100000, &testChannelPolicy{}),
		symmetricTestChannel("roasbeef", "b", 100000, &testChannelPolicy{}),
		symmetricTestChannel("a1", "a2", 100000, &testChannelPolicy{
			Expiry:      144,
			FeeBaseMsat: lnwire.NewMSatFromSatoshis(5),
			MinHTLC:     1,
		}, 10),
		symmetricTestChannel("a2", "target", 100000, &testChannelPolicy{
			Expiry:      144,
			FeeBaseMsat: lnwire.NewMSatFromSatoshis(8),
			MinHTLC:     1,
		}, 11),
		symmetricTestChannel("b", "target", 100000, &testChannelPolicy{
			Expiry:      100,
			FeeBaseMsat: lnwire.NewMSatFromSatoshis(25),
			MinHTLC:     1,
		}, 20),
	}

	ctx := newPathFindingTestContext(t, testChannels, "roasbeef")
	defer ctx.cleanup()

	alias := ctx.testGraphInstance.aliasMap

	paymentAmt := lnwire.NewMSatFromSatoshis(100)
	target := ctx.testGraphInstance.aliasMap["target"]

	// Configure a probability source with the test parameters.
	ctx.restrictParams.ProbabilitySource = func(fromNode, toNode route.Vertex,
		amt lnwire.MilliSatoshi) float64 {

		if amt == 0 {
			t.Fatal("expected non-zero amount")
		}

		switch {
		case fromNode == alias["a1"] && toNode == alias["a2"]:
			return p10
		case fromNode == alias["a2"] && toNode == alias["target"]:
			return p11
		case fromNode == alias["b"] && toNode == alias["target"]:
			return p20
		default:
			return 1
		}
	}

	ctx.pathFindingConfig = PathFindingConfig{
		PaymentAttemptPenalty: lnwire.NewMSatFromSatoshis(10),
		MinProbability:        minProbability,
	}

	path, err := ctx.findPath(target, paymentAmt)
	if expectedChan == 0 {
		if err != errNoPathFound {
			t.Fatalf("expected no path found, but got %v", err)
		}
		return
	}
	if err != nil {
		t.Fatal(err)
	}

	// Assert that the route passes through the expected channel.
	if path[1].ChannelID != expectedChan {
		t.Fatalf("expected route to pass through channel %v, "+
			"but channel %v was selected instead", expectedChan,
			path[1].ChannelID)
	}
}

// TestEqualCostRouteSelection asserts that route probability will be used as a
// tie breaker in case the path finding probabilities are equal.
func TestEqualCostRouteSelection(t *testing.T) {
	t.Parallel()

	// Set up a test graph with two possible paths to the target: via a and
	// via b. The routing fees and probabilities are chosen such that the
	// algorithm will first explore target->a->source (backwards search).
	// This route has fee 6 and a penality of 4 for the 25% success
	// probability. The algorithm will then proceed with evaluating
	// target->b->source, which has a fee of 8 and a penalty of 2 for the
	// 50% success probability. Both routes have the same path finding cost
	// of 10. It is expected that in that case, the highest probability
	// route (through b) is chosen.
	testChannels := []*testChannel{
		symmetricTestChannel("source", "a", 100000, &testChannelPolicy{}),
		symmetricTestChannel("source", "b", 100000, &testChannelPolicy{}),
		symmetricTestChannel("a", "target", 100000, &testChannelPolicy{
			Expiry:      144,
			FeeBaseMsat: lnwire.NewMSatFromSatoshis(6),
			MinHTLC:     1,
		}, 1),
		symmetricTestChannel("b", "target", 100000, &testChannelPolicy{
			Expiry:      100,
			FeeBaseMsat: lnwire.NewMSatFromSatoshis(8),
			MinHTLC:     1,
		}, 2),
	}

	ctx := newPathFindingTestContext(t, testChannels, "source")
	defer ctx.cleanup()

	alias := ctx.testGraphInstance.aliasMap

	paymentAmt := lnwire.NewMSatFromSatoshis(100)
	target := ctx.testGraphInstance.aliasMap["target"]

	ctx.restrictParams.ProbabilitySource = func(fromNode, toNode route.Vertex,
		amt lnwire.MilliSatoshi) float64 {

		switch {
		case fromNode == alias["source"] && toNode == alias["a"]:
			return 0.25
		case fromNode == alias["source"] && toNode == alias["b"]:
			return 0.5
		default:
			return 1
		}
	}

	ctx.pathFindingConfig = PathFindingConfig{
		PaymentAttemptPenalty: lnwire.NewMSatFromSatoshis(1),
	}

	path, err := ctx.findPath(target, paymentAmt)
	if err != nil {
		t.Fatal(err)
	}

	if path[1].ChannelID != 2 {
		t.Fatalf("expected route to pass through channel %v, "+
			"but channel %v was selected instead", 2,
			path[1].ChannelID)
	}
}

// TestNoCycle tries to guide the path finding algorithm into reconstructing an
// endless route. It asserts that the algorithm is able to handle this properly.
func TestNoCycle(t *testing.T) {
	t.Parallel()

	// Set up a test graph with two paths: source->a->target and
	// source->b->c->target. The fees are setup such that, searching
	// backwards, the algorithm will evaluate the following end of the route
	// first: ->target->c->target. This does not make sense, because if
	// target is reached, there is no need to continue to c. A proper
	// implementation will then go on with alternative routes. It will then
	// consider ->a->target because its cost is lower than the alternative
	// ->b->c->target and finally find source->a->target as the best route.
	testChannels := []*testChannel{
		symmetricTestChannel("source", "a", 100000, &testChannelPolicy{
			Expiry: 144,
		}, 1),
		symmetricTestChannel("source", "b", 100000, &testChannelPolicy{
			Expiry: 144,
		}, 2),
		symmetricTestChannel("b", "c", 100000, &testChannelPolicy{
			Expiry:      144,
			FeeBaseMsat: 2000,
		}, 3),
		symmetricTestChannel("c", "target", 100000, &testChannelPolicy{
			Expiry:      144,
			FeeBaseMsat: 0,
		}, 4),
		symmetricTestChannel("a", "target", 100000, &testChannelPolicy{
			Expiry:      144,
			FeeBaseMsat: 600,
		}, 5),
	}

	ctx := newPathFindingTestContext(t, testChannels, "source")
	defer ctx.cleanup()

	const (
		startingHeight = 100
		finalHopCLTV   = 1
	)

	paymentAmt := lnwire.NewMSatFromSatoshis(100)
	target := ctx.keyFromAlias("target")

	// Find the best path given the restriction to only use channel 2 as the
	// outgoing channel.
	path, err := ctx.findPath(target, paymentAmt)
	if err != nil {
		t.Fatalf("unable to find path: %v", err)
	}
	route, err := newRoute(
		ctx.source, path, startingHeight,
		finalHopParams{
			amt:       paymentAmt,
			cltvDelta: finalHopCLTV,
			records:   nil,
		},
	)
	if err != nil {
		t.Fatalf("unable to create path: %v", err)
	}

	if len(route.Hops) != 2 {
		t.Fatalf("unexpected route")
	}
	if route.Hops[0].ChannelID != 1 {
		t.Fatalf("unexpected first hop")
	}
	if route.Hops[1].ChannelID != 5 {
		t.Fatalf("unexpected second hop")
	}
}

// TestRouteToSelf tests that it is possible to find a route to the self node.
func TestRouteToSelf(t *testing.T) {
	t.Parallel()

	testChannels := []*testChannel{
		symmetricTestChannel("source", "a", 100000, &testChannelPolicy{
			Expiry:      144,
			FeeBaseMsat: 500,
		}, 1),
		symmetricTestChannel("source", "b", 100000, &testChannelPolicy{
			Expiry:      144,
			FeeBaseMsat: 1000,
		}, 2),
		symmetricTestChannel("a", "b", 100000, &testChannelPolicy{
			Expiry:      144,
			FeeBaseMsat: 1000,
		}, 3),
	}

	ctx := newPathFindingTestContext(t, testChannels, "source")
	defer ctx.cleanup()

	paymentAmt := lnwire.NewMSatFromSatoshis(100)
	target := ctx.source

	// Find the best path to self. We expect this to be source->a->source,
	// because a charges the lowest forwarding fee.
	path, err := ctx.findPath(target, paymentAmt)
	if err != nil {
		t.Fatalf("unable to find path: %v", err)
	}
	ctx.assertPath(path, []uint64{1, 1})

	outgoingChanID := uint64(1)
	lastHop := ctx.keyFromAlias("b")
	ctx.restrictParams.OutgoingChannelID = &outgoingChanID
	ctx.restrictParams.LastHop = &lastHop

	// Find the best path to self given that we want to go out via channel 1
	// and return through node b.
	path, err = ctx.findPath(target, paymentAmt)
	if err != nil {
		t.Fatalf("unable to find path: %v", err)
	}
	ctx.assertPath(path, []uint64{1, 3, 2})
}

// TestInsufficientBalance tests that a dedicated error is returned for
// insufficient local balance.
func TestInsufficientBalance(t *testing.T) {
	t.Parallel()

	testChannels := []*testChannel{
		symmetricTestChannel("source", "target", 100000, &testChannelPolicy{
			Expiry:      144,
			FeeBaseMsat: 500,
		}, 1),
	}

	ctx := newPathFindingTestContext(t, testChannels, "source")
	defer ctx.cleanup()

	paymentAmt := lnwire.NewMSatFromSatoshis(100)
	target := ctx.keyFromAlias("target")

	ctx.graphParams.bandwidthHints = map[uint64]lnwire.MilliSatoshi{
		1: lnwire.NewMSatFromSatoshis(50),
	}

	// Find the best path to self. We expect this to be source->a->source,
	// because a charges the lowest forwarding fee.
	_, err := ctx.findPath(target, paymentAmt)
	if err != errInsufficientBalance {
		t.Fatalf("expected insufficient balance error, but got: %v",
			err)
	}
}

type pathFindingTestContext struct {
	t                 *testing.T
	graphParams       graphParams
	restrictParams    RestrictParams
	pathFindingConfig PathFindingConfig
	testGraphInstance *testGraphInstance
	source            route.Vertex
}

func newPathFindingTestContext(t *testing.T, testChannels []*testChannel,
	source string) *pathFindingTestContext {

	testGraphInstance, err := createTestGraphFromChannels(
		testChannels, source,
	)
	if err != nil {
		t.Fatalf("unable to create graph: %v", err)
	}

	sourceNode, err := testGraphInstance.graph.SourceNode()
	if err != nil {
		t.Fatalf("unable to fetch source node: %v", err)
	}

	ctx := &pathFindingTestContext{
		t:                 t,
		testGraphInstance: testGraphInstance,
		source:            route.Vertex(sourceNode.PubKeyBytes),
		pathFindingConfig: *testPathFindingConfig,
		graphParams: graphParams{
			graph: testGraphInstance.graph,
		},
		restrictParams: *noRestrictions,
	}

	return ctx
}

func (c *pathFindingTestContext) keyFromAlias(alias string) route.Vertex {
	return c.testGraphInstance.aliasMap[alias]
}

func (c *pathFindingTestContext) aliasFromKey(pubKey route.Vertex) string {
	for alias, key := range c.testGraphInstance.aliasMap {
		if key == pubKey {
			return alias
		}
	}
	return ""
}

func (c *pathFindingTestContext) cleanup() {
	c.testGraphInstance.cleanUp()
}

func (c *pathFindingTestContext) findPath(target route.Vertex,
	amt lnwire.MilliSatoshi) ([]*channeldb.ChannelEdgePolicy,
	error) {

	return findPath(
		&c.graphParams, &c.restrictParams, &c.pathFindingConfig,
		c.source, target, amt, 0,
	)
}

func (c *pathFindingTestContext) assertPath(path []*channeldb.ChannelEdgePolicy, expected []uint64) {
	if len(path) != len(expected) {
		c.t.Fatalf("expected path of length %v, but got %v",
			len(expected), len(path))
	}

	for i, edge := range path {
		if edge.ChannelID != expected[i] {
			c.t.Fatalf("expected hop %v to be channel %v, "+
				"but got %v", i, expected[i], edge.ChannelID)
		}
	}
}