/*
Copyright IBM Corp. 2016 All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

		 http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package main

import (
	"encoding/base64"
	"errors"
	"fmt"

	"github.com/hyperledger/fabric/core/chaincode/shim"
	"github.com/hyperledger/fabric/examples/chaincode/go/utxo/util"
)

// The UTXO example chaincode contains a single invocation function named execute. This function accepts BASE64
// encoded transactions from the Bitcoin network. This chaincode will parse the transactions and pass the transaction
// components to the Bitcoin libconsensus C library for script verification. A table of UTXOs is maintained to ensure
// each transaction is valid.
// Documentation can be found at
// https://github.com/hyperledger/fabric/blob/master/examples/chaincode/go/utxo/README.md

// SimpleChaincode example simple Chaincode implementation
type SimpleChaincode struct {
}

// Init does nothing in the UTXO chaincode
func (t *SimpleChaincode) Init(stub shim.ChaincodeStubInterface) pb.Response {
	return nil, nil
}

// Invoke callback representing the invocation of a chaincode
func (t *SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
	function, args := stub.GetFunctionAndParameters()
	switch function {

	case "execute":

		if len(args) < 1 {
			return nil, errors.New("execute operation must include single argument, the base64 encoded form of a bitcoin transaction")
		}
		txDataBase64 := args[0]
		txData, err := base64.StdEncoding.DecodeString(txDataBase64)
		if err != nil {
			return nil, fmt.Errorf("Error decoding TX as base64:  %s", err)
		}

		utxo := util.MakeUTXO(MakeChaincodeStore(stub))
		execResult, err := utxo.Execute(txData)
		if err != nil {
			return nil, fmt.Errorf("Error executing TX:  %s", err)
		}

		fmt.Printf("\nExecResult: Coinbase: %t, SumInputs %d, SumOutputs %d\n\n", execResult.IsCoinbase, execResult.SumPriorOutputs, execResult.SumCurrentOutputs)

		if execResult.IsCoinbase == false {
			if execResult.SumCurrentOutputs > execResult.SumPriorOutputs {
				return nil, fmt.Errorf("sumOfCurrentOutputs > sumOfPriorOutputs: sumOfCurrentOutputs = %d, sumOfPriorOutputs = %d", execResult.SumCurrentOutputs, execResult.SumPriorOutputs)
			}
		}

		return nil, nil

	case "getTran":

		if len(args) < 1 {
			return nil, errors.New("queryBTC operation must include single argument, the TX hash hex")
		}

		utxo := util.MakeUTXO(MakeChaincodeStore(stub))
		tx, err := utxo.Query(args[0])
		if err != nil {
			return nil, fmt.Errorf("Error querying for transaction:  %s", err)
		}
		if tx == nil {
			var data []byte
			return data, nil
		}
		return tx, nil

	default:
		return nil, errors.New("Unsupported operation")
	}

}

func main() {
	err := shim.Start(new(SimpleChaincode))
	if err != nil {
		fmt.Printf("Error starting chaincode: %s", err)
	}
}