package adpcmgo

import (
	"fmt"
	"math"
)

// table of index changes
var indexTable = []int{
	-1, -1, -1, -1, 2, 4, 6, 8,
	-1, -1, -1, -1, 2, 4, 6, 8,
}

// quantize step size table
var stepTable = []int{
	7, 8, 9, 10, 11, 12, 13, 14,
	16, 17, 19, 21, 23, 25, 28, 31,
	34, 37, 41, 45, 50, 55, 60, 66,
	73, 80, 88, 97, 107, 118, 130, 143,
	157, 173, 190, 209, 230, 253, 279, 307,
	337, 371, 408, 449, 494, 544, 598, 658,
	724, 796, 876, 963, 1060, 1166, 1282, 1411,
	1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024,
	3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484,
	7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
	15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794,
	32767,
}

var (
	encPred  = 0
	encIndex = 0
	encStep  = 7
	decPred  = 0
	decIndex = 0
	decStep  = 7
)

// EncodeSample takes a single 16 bit PCM sample and
// returns a byte of which the last 4 bits are an encoded ADPCM nibble
func EncodeSample(sample int) byte {

	// find difference from predicted sample
	delta := sample - encPred

	// set sign bit and find absolute value of difference
	var newSample byte
	if delta < 0 {
		newSample = 8
		delta = -delta
	}

	step := stepTable[encIndex]
	diff := step >> 3
	var mask byte = 4

	// quantize delta down to four bits
	for i := 0; i < 3; i++ {
		if delta > step {
			newSample |= mask
			delta -= step
			diff += step
		}
		mask >>= 1
		step >>= 1
	}

	// adjust predicted sample based on calculated difference
	if newSample&8 != 0 {
		encPred -= diff
	} else {
		encPred += diff
	}

	// check for underflow and overflow
	fmt.Print("max, min: ", math.MaxInt16)
	fmt.Println(math.MinInt16)
	if encPred < math.MinInt16 {
		encPred = math.MinInt16
	} else if encPred > math.MaxInt16 {
		encPred = math.MaxInt16
	}

	encIndex += indexTable[newSample&7]

	// check for underflow and overflow
	if encIndex < 0 {
		encIndex = 0
	} else if encIndex > len(stepTable)-1 {
		encIndex = len(stepTable) - 1
	}

	return newSample
}

// DecodeSample takes a byte, the last 4 bits of which contain a single
// 4 bit ADPCM value/sample, and returns a 16 bit decoded PCM sample
func DecodeSample(nibble byte) int {

	diff := 0

	if nibble&4 != 0 {
		diff += decStep
	}

	if nibble&2 != 0 {
		diff += decStep >> 1
	}

	if nibble&1 != 0 {
		diff += decStep >> 2
	}

	diff += decStep >> 3

	if nibble&8 != 0 {
		diff = -diff
	}

	decPred += diff

	if decPred > math.MaxInt16 {
		decPred = math.MaxInt16
	} else if decPred < math.MinInt16 {
		decPred = math.MinInt16
	}

	decIndex += indexTable[nibble]
	if decIndex < 0 {
		decIndex = 0
	} else if decIndex > len(stepTable)-1 {
		decIndex = len(stepTable) - 1
	}
	decStep = stepTable[decIndex]

	return decPred
}