package lnwallet

import (
	"github.com/roasbeef/btcd/blockchain"
)

const (
	WitnessFactor              = blockchain.WitnessScaleFactor
	MaxTransactionWeightPolicy = blockchain.MaxBlockWeight / 10

	// The weight(cost), which is different from the !size! (see BIP-141),
	// is calculated as:
	// Weight = 4 * BaseSize + WitnessSize (weight).
	// BaseSize - size of the transaction without witness data (bytes).
	// WitnessSize - witness size (bytes).
	// Weight - the metric for determining the cost of the transaction.

	// P2WSH: 34 bytes
	//	- OP_0: 1 byte
	//	- OP_DATA: 1 byte (WitnessScriptSHA256 length)
	//	- WitnessScriptSHA256: 32 bytes
	P2WSHSize = 1 + 1 + 32

	// P2WPKH: 22 bytes
	//	- OP_0: 1 byte
	//	- OP_DATA: 1 byte (PublicKeyHASH160 length)
	//	- PublicKeyHASH160: 20 bytes
	P2WPKHSize = 1 + 1 + 20

	// MultiSig: 71 bytes
	//	- OP_2: 1 byte
	//	- OP_DATA: 1 byte (pubKeyAlice length)
	//	- pubKeyAlice: 33 bytes
	//	- OP_DATA: 1 byte (pubKeyBob length)
	//	- pubKeyBob: 33 bytes
	//	- OP_2: 1 byte
	//	- OP_CHECKMULTISIG: 1 byte
	MultiSigSize = 1 + 1 + 33 + 1 + 33 + 1 + 1

	// Witness: 222 bytes
	//	- NumberOfWitnessElements: 1 byte
	//	- NilLength: 1 byte
	//	- sigAliceLength: 1 byte
	//	- sigAlice: 73 bytes
	//	- sigBobLength: 1 byte
	//	- sigBob: 73 bytes
	//	- WitnessScriptLength: 1 byte
	//	- WitnessScript (MultiSig)
	WitnessSize = 1 + 1 + 1 + 73 + 1 + 73 + 1 + MultiSigSize

	// FundingInput: 41 bytes
	//	- PreviousOutPoint:
	//		- Hash: 32 bytes
	//		- Index: 4 bytes
	//	- OP_DATA: 1 byte (ScriptSigLength)
	//	- ScriptSig: 0 bytes
	//	- Witness <----	we use "Witness" instead of "ScriptSig" for
	// 			transaction validation, but "Witness" is stored
	// 			separately and cost for it size is smaller. So
	// 			we separate the calculation of ordinary data
	// 			from witness data.
	//	- Sequence: 4 bytes
	FundingInputSize = 32 + 4 + 1 + 4

	// OutputPayingToUs: 43 bytes
	//	- Value: 8 bytes
	//	- VarInt: 1 byte (PkScript length)
	//	- PkScript (P2WSH)
	CommitmentDelayOutput = 8 + 1 + P2WSHSize

	// OutputPayingToThem: 31 bytes
	//	- Value: 8 bytes
	//	- VarInt: 1 byte (PkScript length)
	//	- PkScript (P2WPKH)
	CommitmentKeyHashOutput = 8 + 1 + P2WPKHSize

	// HTLCOutput: 43 bytes
	//	- Value: 8 bytes
	//	- VarInt: 1 byte (PkScript length)
	//	- PkScript (PW2SH)
	HTLCSize = 8 + 1 + P2WSHSize

	// WitnessHeader: 2 bytes
	//	- Flag: 1 byte
	//	- Marker: 1 byte
	WitnessHeaderSize = 1 + 1

	// CommitmentTransaction: 125 bytes
	//	- Version: 4 bytes
	//	- WitnessHeader <---- part of the witness data
	//	- CountTxIn: 1 byte
	//	- TxIn:
	//		FundingInput
	//	- CountTxOut: 1 byte
	//	- TxOut:
	//		OutputPayingToThem,
	//		OutputPayingToUs,
	//		....HTLCOutputs...
	//	- LockTime: 4 bytes
	BaseCommitmentTxSize = 4 + 1 + FundingInputSize + 1 +
		CommitmentDelayOutput + CommitmentKeyHashOutput + 4

	// CommitmentTransactionCost: 500 weight
	BaseCommitmentTxCost = WitnessFactor * BaseCommitmentTxSize

	// WitnessCommitmentTxCost: 224 weight
	WitnessCommitmentTxCost = WitnessHeaderSize + WitnessSize

	// HTLCCost: 172 weight
	HTLCCost = WitnessFactor * HTLCSize

	// MaxHTLCNumber shows as the maximum number HTLCs which can be
	// included in commitment transaction. This numbers was calculated by
	// Rusty Russel in "BOLT #5: Recommendations for On-chain Transaction
	// Handling", based on the fact that we need to sweep all HTLCs within
	// one penalty transaction.
	MaxHTLCNumber = 1253
)

// estimateCommitTxCost estimate commitment transaction cost depending on the
// precalculated cost of base transaction, witness data, which is needed for
// paying for funding tx, and htlc cost multiplied by their count.
func estimateCommitTxCost(count int, prediction bool) int64 {
	// Make prediction about the size of commitment transaction with
	// additional HTLC.
	if prediction {
		count++
	}

	htlcCost := int64(count * HTLCCost)
	baseCost := int64(BaseCommitmentTxCost)
	witnessCost := int64(WitnessCommitmentTxCost)

	return htlcCost + baseCost + witnessCost
}