package serial

import (
	"errors"
	"fmt"
	"log"
)

const (
	MaxIndex = block

	letters = 26
	numbers = 900                                   // 100–999
	block   = letters * letters * letters * numbers // 26^3 * 900
)

func Encode(code string) (uint32, error) {
	log.Printf("code: %v", code)
	// Verwacht formaat: L1L2-NNN-L3-C  => lengte 10, posities: 0,1,3,4,5,7,9
	if len(code) != 10 || code[2] != '-' || code[6] != '-' || code[8] != '-' {
		return 0, errors.New("invalid format, expected LL-NNN-L-C")
	}

	l1, l2, l3 := code[0], code[1], code[7]
	n1, n2, n3 := code[3], code[4], code[5]

	// letters checken
	// forbidden alleen op l1,l2
	// nummer parsen uit code[3:6]

	L1 := uint32(l1 - 'A')
	L2 := uint32(l2 - 'A')
	L3 := uint32(l3 - 'A')
	num := uint32(n1*100 + n2*10 + n3)
	N := num - 100

	idx := uint32((((L1*letters+L2)*letters + L3) * numbers) + N)

	if code[9] != checksumLetter(idx) {
		return 0, errors.New("invalid checksum")
	}

	log.Printf("idx: %v", idx)
	return idx, nil
}

func Decode(idx uint32) (string, error) {
	log.Printf("idx: %v", idx)
	if idx >= block {
		return "", errors.New("index out of range")
	}

	x := int(idx)

	L1 := x / (letters * letters * numbers)
	r1 := x % (letters * letters * numbers)

	L2 := r1 / (letters * numbers)
	r2 := r1 % (letters * numbers)

	L3 := r2 / numbers
	N := r2 % numbers

	l1 := byte('A' + L1)
	l2 := byte('A' + L2)
	l3 := byte('A' + L3)

	if IsForbiddenPair(l1, l2) {
		return "", errors.New("forbidden letter combination")
	}

	c := checksumLetter(idx)

	code := fmt.Sprintf("%c%c-%03d-%c-%c", l1, l2, N+100, l3, c)

	log.Printf("code: %v", code)
	return code, nil
}

func checksumLetter(idx uint32) byte {
	return byte('A' + idx%26)
}

func IsForbiddenPair(l1, l2 byte) bool {
	return false
}