package transdb

import (
	"git.mleku.dev/iskra"
	"git.smesh.lol/iskradb/lattice"
)

// JA verb class codes stored in Bcooccur at MakeKey(lang, CoordVerbClass, dictForm).
const (
	VerbClassUnknown uint8 = 0
	VerbClassV1      uint8 = 1
	VerbClassV1S     uint8 = 2
	VerbClassV5K     uint8 = 3
	VerbClassV5KS    uint8 = 4
	VerbClassV5G     uint8 = 5
	VerbClassV5S     uint8 = 6
	VerbClassV5M     uint8 = 7
	VerbClassV5N     uint8 = 8
	VerbClassV5B     uint8 = 9
	VerbClassV5R     uint8 = 10
	VerbClassV5T     uint8 = 11
	VerbClassV5U     uint8 = 12
	VerbClassV5Aru   uint8 = 13
	VerbClassVS      uint8 = 14
	VerbClassVK      uint8 = 15
)

// VerbClassCode maps a JMdict POS string to a numeric code.
func VerbClassCode(s string) uint8 {
	switch s {
	case "v1":      return VerbClassV1
	case "v1-s":    return VerbClassV1S
	case "v5k":     return VerbClassV5K
	case "v5k-s":   return VerbClassV5KS
	case "v5g":     return VerbClassV5G
	case "v5s":     return VerbClassV5S
	case "v5m":     return VerbClassV5M
	case "v5n":     return VerbClassV5N
	case "v5b":     return VerbClassV5B
	case "v5r", "v5r-i", "v5aru": return VerbClassV5R
	case "v5t":     return VerbClassV5T
	case "v5u", "v5u-s":          return VerbClassV5U
	case "vs", "vs-i", "vs-s", "vs-c": return VerbClassVS
	case "vk":      return VerbClassVK
	}
	return VerbClassUnknown
}

// VerbClassStr maps a numeric code back to the canonical JMdict POS string.
func VerbClassStr(code uint8) string {
	switch code {
	case VerbClassV1:    return "v1"
	case VerbClassV1S:   return "v1-s"
	case VerbClassV5K:   return "v5k"
	case VerbClassV5KS:  return "v5k-s"
	case VerbClassV5G:   return "v5g"
	case VerbClassV5S:   return "v5s"
	case VerbClassV5M:   return "v5m"
	case VerbClassV5N:   return "v5n"
	case VerbClassV5B:   return "v5b"
	case VerbClassV5R:   return "v5r"
	case VerbClassV5T:   return "v5t"
	case VerbClassV5U:   return "v5u"
	case VerbClassV5Aru: return "v5aru"
	case VerbClassVS:    return "vs"
	case VerbClassVK:    return "vk"
	}
	return ""
}

// RegisterVerbClass stores a verb class code via iskra.RegisterClassRecord.
func RegisterVerbClass(tree *lattice.Tree, pool *[]byte, lang uint8, dictForm string, code uint8) {
	iskra.RegisterClassRecord(tree, pool, lang, dictForm, code)
}

// GetVerbClass retrieves the stored verb class string for a dict form.
func GetVerbClass(tree *lattice.Tree, lang uint8, dictForm string) (string, bool) {
	code, ok := iskra.GetClassCode(tree, lang, dictForm)
	if !ok {
		return "", false
	}
	s := VerbClassStr(code)
	if s == "" {
		return "", false
	}
	return s, true
}

// InflectJA computes a JA verb surface form from dictForm + class + morph state.
func InflectJA(dictForm, verbClass string, state uint8) string {
	if state == 0 {
		return dictForm
	}
	forms := BuildVerbForms(dictForm, verbClass)
	if f, ok := forms[state]; ok {
		return f
	}
	return ""
}

// InflectJAFromTree uses the stored verb class to compute the inflected form.
func InflectJAFromTree(tree *lattice.Tree, lang uint8, dictForm string, state uint8) string {
	class, ok := GetVerbClass(tree, lang, dictForm)
	if !ok {
		return ""
	}
	return InflectJA(dictForm, class, state)
}

// jaInflectFunc is the JA implementation of iskra.InflectFunc.
// Registered with iskra so InflectFromTree works for LangJA.
var jaInflectFuncRegistered = false

func ensureJAInflectRegistered() {
	if jaInflectFuncRegistered {
		return
	}
	iskra.RegisterInflectFunc(LangJA, func(dictForm string, classCode uint8, state uint8) string {
		return InflectJA(dictForm, VerbClassStr(classCode), state)
	})
	jaInflectFuncRegistered = true
}