package dinetrpc

import (
	"strings"
	"unicode"
)

const DinetRPCVersion1 = 1

var ClassMethod_JSON_name map[int32]string
var ClassMethod_JSON_value map[string]int32

var Errno_descr = map[int32]string{
	int32(Errno_Ok):        "Ok",
	int32(Errno_OpNotSupp): "Operation not supported",
}

func init() {
	ClassMethod_JSON_name = make(map[int32]string)
	for idx, name := range ClassMethod_name {
		ClassMethod_JSON_name[idx] = classMethodJSONString(name)
	}

	ClassMethod_JSON_value = make(map[string]int32)
	for idx, name := range ClassMethod_name {
		ClassMethod_JSON_value[classMethodJSONString(name)] = idx
	}
}

// Convert camelcase protobuf ClassMethod enum name into into DI-Net RPC semicolon separated
func classMethodJSONString(name string) string {
	var words []string
	l := 0
	for s := name; s != ""; s = s[l:] {
		l = strings.IndexFunc(s[1:], unicode.IsUpper) + 1
		if l <= 0 {
			l = len(s)
		}
		words = append(words, strings.ToLower(s[:l]))
	}
	return strings.Join(words, ":")
}

func ClassMethodJSONString(cm ClassMethod) string {
	s, ok := ClassMethod_JSON_name[int32(cm)]
	if !ok {
		s = ClassMethod_JSON_name[int32(ClassMethod_UnknownUnknown)]
	}
	return s
}

func ClassMethodFromJSONString(s string) ClassMethod {
	enum, ok := ClassMethod_JSON_value[s]
	if ok {
		return ClassMethod(enum)
	}
	return ClassMethod_UnknownUnknown
}

func ErrorFromErrno(errno Errno) *Error {
	descr, ok := Errno_descr[int32(errno)]
	if !ok {
		return nil
	}
	return &Error{Code: errno, Descr: descr}
}

func (r *HeaderMsg) Validate() bool {
	if r == nil {
		return false
	}
	if r.DinetRPC != DinetRPCVersion1 {
		return false
	}
	if r.Time == 0 {
		return false
	}
	deviceUIDLen := len(r.DeviceUID)
	if deviceUIDLen > 0 && deviceUIDLen != 32 {
		return false
	}
	return true
}