package words

import (
	"math/big"
	"strings"

	"github.com/pkg/errors"

	"github.com/tendermint/go-crypto/keys/words/wordlist"
)

const BankSize = 2048

// TODO: add error-checking codecs for invalid phrases

type Codec interface {
	BytesToWords([]byte) ([]string, error)
	WordsToBytes([]string) ([]byte, error)
}

type WordCodec struct {
	words []string
	bytes map[string]int
	check ECC
}

var _ Codec = &WordCodec{}

func NewCodec(words []string) (codec *WordCodec, err error) {
	if len(words) != BankSize {
		return codec, errors.Errorf("Bank must have %d words, found %d", BankSize, len(words))
	}

	res := &WordCodec{
		words: words,
		// TODO: configure this outside???
		check: NewIEEECRC32(),
		// check: NewIBMCRC16(),
	}

	return res, nil
}

// LoadCodec loads a pre-compiled language file
func LoadCodec(bank string) (codec *WordCodec, err error) {
	words, err := loadBank(bank)
	if err != nil {
		return codec, err
	}
	return NewCodec(words)
}

// MustLoadCodec panics if word bank is missing, only for tests
func MustLoadCodec(bank string) *WordCodec {
	codec, err := LoadCodec(bank)
	if err != nil {
		panic(err)
	}
	return codec
}

// loadBank opens a wordlist file and returns all words inside
func loadBank(bank string) ([]string, error) {
	filename := "keys/words/wordlist/" + bank + ".txt"
	words, err := wordlist.Asset(filename)
	if err != nil {
		return nil, err
	}
	wordsAll := strings.Split(strings.TrimSpace(string(words)), "\n")
	return wordsAll, nil
}

// // TODO: read from go-bind assets
// func getData(filename string) (string, error) {
// 	f, err := os.Open(filename)
// 	if err != nil {
// 		return "", errors.WithStack(err)
// 	}
// 	defer f.Close()

// 	data, err := ioutil.ReadAll(f)
// 	if err != nil {
// 		return "", errors.WithStack(err)
// 	}

// 	return string(data), nil
// }

// given this many bytes, we will produce this many words
func wordlenFromBytes(numBytes int) int {
	// 2048 words per bank, which is 2^11.
	// 8 bits per byte, and we add +10 so it rounds up
	return (8*numBytes + 10) / 11
}

// given this many words, we will produce this many bytes.
// sometimes there are two possibilities.
// if maybeShorter is true, then represents len OR len-1 bytes
func bytelenFromWords(numWords int) (length int, maybeShorter bool) {
	// calculate the max number of complete bytes we could store in this word
	length = 11 * numWords / 8
	// if one less byte would also generate this length, set maybeShorter
	if wordlenFromBytes(length-1) == numWords {
		maybeShorter = true
	}
	return
}

// TODO: add checksum
func (c *WordCodec) BytesToWords(raw []byte) (words []string, err error) {
	// always add a checksum to the data
	data := c.check.AddECC(raw)
	numWords := wordlenFromBytes(len(data))

	n2048 := big.NewInt(2048)
	nData := big.NewInt(0).SetBytes(data)
	nRem := big.NewInt(0)
	// Alternative, use condition "nData.BitLen() > 0"
	// to allow for shorter words when data has leading 0's
	for i := 0; i < numWords; i++ {
		nData.DivMod(nData, n2048, nRem)
		rem := nRem.Int64()
		w := c.words[rem]
		// double-check bank on generation...
		_, err := c.GetIndex(w)
		if err != nil {
			return nil, err
		}
		words = append(words, w)
	}
	return words, nil
}

func (c *WordCodec) WordsToBytes(words []string) ([]byte, error) {
	l := len(words)

	if l == 0 {
		return nil, errors.New("Didn't provide any words")
	}

	n2048 := big.NewInt(2048)
	nData := big.NewInt(0)
	// since we output words based on the remainder, the first word has the lowest
	// value... we must load them in reverse order
	for i := 1; i <= l; i++ {
		rem, err := c.GetIndex(words[l-i])
		if err != nil {
			return nil, err
		}
		nRem := big.NewInt(int64(rem))
		nData.Mul(nData, n2048)
		nData.Add(nData, nRem)
	}

	// we copy into a slice of the expected size, so it is not shorter if there
	// are lots of leading 0s
	dataBytes := nData.Bytes()

	// copy into the container we have with the expected size
	outLen, flex := bytelenFromWords(len(words))
	toCheck := make([]byte, outLen)
	if len(dataBytes) > outLen {
		return nil, errors.New("Invalid data, could not have been generated by this codec")
	}
	copy(toCheck[outLen-len(dataBytes):], dataBytes)

	// validate the checksum...
	output, err := c.check.CheckECC(toCheck)
	if flex && err != nil {
		// if flex, try again one shorter....
		toCheck = toCheck[1:]
		output, err = c.check.CheckECC(toCheck)
	}

	return output, err
}

// GetIndex finds the index of the words to create bytes
// Generates a map the first time it is loaded, to avoid needless
// computation when list is not used.
func (c *WordCodec) GetIndex(word string) (int, error) {
	// generate the first time
	if c.bytes == nil {
		b := map[string]int{}
		for i, w := range c.words {
			if _, ok := b[w]; ok {
				return -1, errors.Errorf("Duplicate word in list: %s", w)
			}
			b[w] = i
		}
		c.bytes = b
	}

	// get the index, or an error
	rem, ok := c.bytes[word]
	if !ok {
		return -1, errors.Errorf("Unrecognized word: %s", word)
	}
	return rem, nil
}