package merkletree

import (
	"bytes"
	"encoding/binary"
	"encoding/hex"
	"fmt"
	"strings"

	"github.com/ethereum/go-ethereum/crypto"
)

// Hex returns a hex string from the Hash type
func (hash Hash) Hex() string {
	r := "0x"
	h := hex.EncodeToString(hash[:])
	r = r + h
	return r
}

// Bytes returns a byte array from a Hash
func (hash Hash) Bytes() []byte {
	return hash[:]
}

// HashBytes performs a Keccak256 hash over the bytes
func HashBytes(b []byte) (hash Hash) {
	h := crypto.Keccak256(b)
	copy(hash[:], h)
	// if instead of Keccak256 want to use SHA256:
	// hash = sha256.Sum256(b)
	return hash
}

// getPath returns the binary path, from the leaf to the root
func getPath(numLevels int, hi Hash) []bool {
	path := []bool{}
	for bitno := numLevels - 2; bitno >= 0; bitno-- {
		path = append(path, testbitmap(hi[:], uint(bitno)))
	}
	return path
}

func comparePaths(b1 []bool, b2 []bool) int {
	for i := len(b1) - 1; i >= 0; i-- {
		if b1[i] != b2[i] {
			return i
		}
	}
	return -1
}

func getEmptiesBetweenIAndPosHash(mt *MerkleTree, iPos int, posHash int) []Hash {
	var sibl []Hash
	for i := iPos; i >= posHash; i-- {
		sibl = append(sibl, EmptyNodeValue)
	}
	return sibl
}

func setbitmap(bitmap []byte, bitno uint) {
	bitmap[uint(len(bitmap))-bitno/8-1] |= 1 << (bitno % 8)
}
func testbitmap(bitmap []byte, bitno uint) bool {
	return bitmap[uint(len(bitmap))-bitno/8-1]&(1<<(bitno%8)) > 0
}

// Uint32ToBytes returns a byte array from a uint32
func Uint32ToBytes(u uint32) []byte {
	buff := new(bytes.Buffer)
	err := binary.Write(buff, binary.LittleEndian, u)
	if err != nil {
		panic(err)
	}
	return buff.Bytes()
}

// BytesToUint32 returns a uint32 from a byte array
func BytesToUint32(b []byte) uint32 {
	return binary.LittleEndian.Uint32(b)
}

// BytesToHex encodes an array of bytes into a string in hex.
func BytesToHex(bs []byte) string {
	return fmt.Sprintf("0x%s", hex.EncodeToString(bs))
}

// HexToBytes decodes a hex string into an array of bytes.
func HexToBytes(h string) ([]byte, error) {
	if strings.HasPrefix(h, "0x") {
		h = h[2:]
	}
	return hex.DecodeString(h)
}