package wfa

import (
	"math"
	"unicode/utf8"
)

func SafeMin(values []int, idx int) int {
	return values[idx]
}

func SafeMax(values []int, idx int) int {
	return values[idx]
}

func SafeArgMax(valids []bool, values []int) (bool, int) {
	hasValid := false
	maxIndex := 0
	maxValue := math.MinInt
	for i := 0; i < len(valids); i++ {
		if valids[i] && values[i] > maxValue {
			hasValid = true
			maxIndex = i
			maxValue = values[i]
		}
	}
	if hasValid {
		return true, maxIndex
	} else {
		return false, 0
	}
}

func SafeArgMin(valids []bool, values []int) (bool, int) {
	hasValid := false
	minIndex := 0
	minValue := math.MaxInt
	for i := 0; i < len(valids); i++ {
		if valids[i] && values[i] < minValue {
			hasValid = true
			minIndex = i
			minValue = values[i]
		}
	}
	if hasValid {
		return true, minIndex
	} else {
		return false, 0
	}
}

func Reverse(s string) string {
	size := len(s)
	buf := make([]byte, size)
	for start := 0; start < size; {
		r, n := utf8.DecodeRuneInString(s[start:])
		start += n
		utf8.EncodeRune(buf[size-start:], r)
	}
	return string(buf)
}

func Splice(s string, c rune, idx int) string {
	return s[:idx] + string(c) + s[idx:]
}

func NextLoHi(M WavefrontComponent, I WavefrontComponent, D WavefrontComponent, score int, penalties Penalty) (int, int) {
	x := penalties.X
	o := penalties.O
	e := penalties.E

	a_ok, a_lo, a_hi := M.GetLoHi(score - x)
	b_ok, b_lo, b_hi := M.GetLoHi(score - o - e)
	c_ok, c_lo, c_hi := I.GetLoHi(score - e)
	d_ok, d_lo, d_hi := D.GetLoHi(score - e)

	ok_lo, idx := SafeArgMin(
		[]bool{a_ok, b_ok, c_ok, d_ok},
		[]int{a_lo, b_lo, c_lo, d_lo},
	)
	lo := SafeMin([]int{a_lo, b_lo, c_lo, d_lo}, idx) - 1

	ok_hi, idx := SafeArgMax(
		[]bool{a_ok, b_ok, c_ok, d_ok},
		[]int{a_hi, b_hi, c_hi, d_hi},
	)
	hi := SafeMax([]int{a_hi, b_hi, c_hi, d_hi}, idx) + 1

	if ok_lo && ok_hi {
		M.SetLoHi(score, lo, hi)
		I.SetLoHi(score, lo, hi)
		D.SetLoHi(score, lo, hi)
	}
	return lo, hi
}

func NextI(M WavefrontComponent, I WavefrontComponent, score int, k int, penalties Penalty) {
	o := penalties.O
	e := penalties.E

	a_ok, a := M.GetVal(score-o-e, k-1)
	b_ok, b := I.GetVal(score-e, k-1)

	ok, nextITraceback := SafeArgMax([]bool{a_ok, b_ok}, []int{a, b})
	nextIVal := SafeMax([]int{a, b}, nextITraceback) + 1 // important that the +1 is here
	if ok {
		I.SetVal(score, k, nextIVal)
		I.SetTraceback(score, k, []traceback{OpenIns, ExtdIns}[nextITraceback])
	}
}

func NextD(M WavefrontComponent, D WavefrontComponent, score int, k int, penalties Penalty) {
	o := penalties.O
	e := penalties.E

	a_ok, a := M.GetVal(score-o-e, k+1)
	b_ok, b := D.GetVal(score-e, k+1)

	ok, nextDTraceback := SafeArgMax(
		[]bool{a_ok, b_ok},
		[]int{a, b},
	)
	nextDVal := SafeMax([]int{a, b}, nextDTraceback) // nothing special
	if ok {
		D.SetVal(score, k, nextDVal)
		D.SetTraceback(score, k, []traceback{OpenDel, ExtdDel}[nextDTraceback])
	}
}

func NextM(M WavefrontComponent, I WavefrontComponent, D WavefrontComponent, score int, k int, penalties Penalty) {
	x := penalties.X

	a_ok, a := M.GetVal(score-x, k)
	a++ // important to have +1 here
	b_ok, b := I.GetVal(score, k)
	c_ok, c := D.GetVal(score, k)

	ok, nextMTraceback := SafeArgMax([]bool{a_ok, b_ok, c_ok}, []int{a, b, c})
	nextMVal := SafeMax([]int{a, b, c}, nextMTraceback)

	if ok {
		M.SetVal(score, k, nextMVal)
		M.SetTraceback(score, k, []traceback{Sub, Ins, Del}[nextMTraceback])
	}
}