package transaction

import (
	"bytes"
	"io"

	"github.com/CityOfZion/neo-go/pkg/wire/payload/transaction/types"
	"github.com/CityOfZion/neo-go/pkg/wire/payload/transaction/version"
	"github.com/CityOfZion/neo-go/pkg/wire/util"
)

type encodeExclusiveFields func(bw *util.BinWriter)
type decodeExclusiveFields func(br *util.BinReader)

// Transactioner is the interface that will unite the
// transaction types. Each transaction will implement this interface
// and so wil be a transactioner
type Transactioner interface {
	Encode(w io.Writer) error
	Decode(r io.Reader) error
	ID() (util.Uint256, error)
	Bytes() []byte
	UTXOs() []*Output
	TXOs() []*Input
	Witness() []*Witness
}

// Base transaction is the template for all other transactions
// It contains all of the shared fields between transactions and
// the additional encodeExclusive and decodeExclusive methods, which
// can be overwitten in the other transactions to encode the non shared fields
type Base struct {
	Type            types.TX
	Version         version.TX
	Inputs          []*Input
	Outputs         []*Output
	Attributes      []*Attribute
	Witnesses       []*Witness
	Hash            util.Uint256
	encodeExclusive encodeExclusiveFields
	decodeExclusive decodeExclusiveFields
}

func createBaseTransaction(typ types.TX, ver version.TX) *Base {
	return &Base{
		Type:       typ,
		Version:    ver,
		Inputs:     []*Input{},
		Outputs:    []*Output{},
		Attributes: []*Attribute{},
		Witnesses:  []*Witness{},
	}

}

// Decode implements the transactioner interface
func (b *Base) Decode(r io.Reader) error {
	br := &util.BinReader{R: r}
	return b.DecodePayload(br)
}

// Encode implements the transactioner interface
func (b *Base) Encode(w io.Writer) error {
	bw := &util.BinWriter{W: w}
	b.EncodePayload(bw)
	return bw.Err
}

//EncodePayload implements the Messager interface
func (b *Base) EncodePayload(bw *util.BinWriter) {
	b.encodeHashableFields(bw)

	lenWitnesses := uint64(len(b.Witnesses))
	bw.VarUint(lenWitnesses)

	for _, witness := range b.Witnesses {
		witness.Encode(bw)
	}
}

// DecodePayload implements the messager interface
func (b *Base) DecodePayload(br *util.BinReader) error {
	b.decodeHashableFields(br)

	lenWitnesses := br.VarUint()

	b.Witnesses = make([]*Witness, lenWitnesses)
	for i := 0; i < int(lenWitnesses); i++ {
		b.Witnesses[i] = &Witness{}
		b.Witnesses[i].Decode(br)
	}

	if br.Err != nil {
		return br.Err
	}

	return b.createHash()
}

func (b *Base) encodeHashableFields(bw *util.BinWriter) {
	b.Type.Encode(bw)
	b.Version.Encode(bw)

	b.encodeExclusive(bw)

	lenAttrs := uint64(len(b.Attributes))
	lenInputs := uint64(len(b.Inputs))
	lenOutputs := uint64(len(b.Outputs))

	bw.VarUint(lenAttrs)
	for _, attr := range b.Attributes {
		attr.Encode(bw)
	}

	bw.VarUint(lenInputs)
	for _, input := range b.Inputs {
		input.Encode(bw)
	}

	bw.VarUint(lenOutputs)
	for _, output := range b.Outputs {
		output.Encode(bw)
	}
}

func (b *Base) decodeHashableFields(br *util.BinReader) {
	b.Type.Decode(br)

	b.Version.Decode(br)

	b.decodeExclusive(br)

	lenAttrs := br.VarUint()
	b.Attributes = make([]*Attribute, lenAttrs)
	for i := 0; i < int(lenAttrs); i++ {

		b.Attributes[i] = &Attribute{}
		b.Attributes[i].Decode(br)
	}

	lenInputs := br.VarUint()

	b.Inputs = make([]*Input, lenInputs)
	for i := 0; i < int(lenInputs); i++ {
		b.Inputs[i] = &Input{}
		b.Inputs[i].Decode(br)
	}

	lenOutputs := br.VarUint()
	b.Outputs = make([]*Output, lenOutputs)
	for i := 0; i < int(lenOutputs); i++ {
		b.Outputs[i] = &Output{}
		b.Outputs[i].Decode(br)
	}

}

// AddInput adds an input to the transaction
func (b *Base) AddInput(i *Input) {
	b.Inputs = append(b.Inputs, i)
}

// AddOutput adds an output to the transaction
func (b *Base) AddOutput(o *Output) {
	b.Outputs = append(b.Outputs, o)
}

// AddAttribute adds an attribute to the transaction
func (b *Base) AddAttribute(a *Attribute) {
	b.Attributes = append(b.Attributes, a)
}

// AddWitness adds a witness object to the transaction
func (b *Base) AddWitness(w *Witness) {
	b.Witnesses = append(b.Witnesses, w)
}

func (b *Base) createHash() error {

	hash, err := util.CalculateHash(b.encodeHashableFields)
	b.Hash = hash
	return err
}

// ID returns the TXID of the transaction
func (b *Base) ID() (util.Uint256, error) {
	var emptyHash util.Uint256
	var err error
	if b.Hash == emptyHash {
		err = b.createHash()
	}
	return b.Hash, err
}

// Bytes returns the raw bytes of the tx
func (b *Base) Bytes() []byte {
	buf := new(bytes.Buffer)
	b.Encode(buf)
	return buf.Bytes()
}

// UTXOs returns the outputs in the tx
func (b *Base) UTXOs() []*Output {
	return b.Outputs
}

// TXOs returns the inputs in the tx
func (b *Base) TXOs() []*Input {
	return b.Inputs
}

// Witness returns the witnesses in the tx
func (b *Base) Witness() []*Witness {
	return b.Witnesses
}