netdata/netdata

// SPDX-License-Identifier: GPL-3.0-or-later

package stm

import (
    "fmt"
    "log"
    "reflect"
    "strconv"
    "strings"
)

const (
    fieldTagName = "stm"
    structKey    = "STMKey"
)

type (
    Value interface {
        WriteTo(rv map[string]int64, key string, mul, div int)
    }
)

// ToMap converts struct to a map[string]int64 based on 'stm' tags
func ToMap(s ...interface{}) map[string]int64 {
    rv := map[string]int64{}
    for _, v := range s {
        value := reflect.Indirect(reflect.ValueOf(v))
        toMap(value, rv, "", 1, 1)
    }
    return rv
}

func toMap(value reflect.Value, rv map[string]int64, key string, mul, div int) {
    if !value.IsValid() {
        log.Panicf("value is not valid key=%s", key)
    }
    if value.CanInterface() {
        val, ok := value.Interface().(Value)
        if ok {
            val.WriteTo(rv, key, mul, div)
            return
        }
    }
    switch value.Kind() {
    case reflect.Ptr:
        convertPtr(value, rv, key, mul, div)
    case reflect.Struct:
        convertStruct(value, rv, key)
    case reflect.Array, reflect.Slice:
        convertArraySlice(value, rv, key, mul, div)
    case reflect.Map:
        convertMap(value, rv, key, mul, div)
    case reflect.Bool:
        convertBool(value, rv, key)
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        convertInteger(value, rv, key, mul, div)
    case reflect.Float32, reflect.Float64:
        convertFloat(value, rv, key, mul, div)
    case reflect.Interface:
        convertInterface(value, rv, key, mul, div)
    default:
        log.Panicf("unsupported data type: %v", value.Kind())
    }
}

func convertPtr(value reflect.Value, rv map[string]int64, key string, mul, div int) {
    if !value.IsNil() {
        toMap(value.Elem(), rv, key, mul, div)
    }
}

func convertStruct(value reflect.Value, rv map[string]int64, key string) {
    t := value.Type()
    k := value.FieldByName(structKey)
    if k.Kind() == reflect.String {
        key = joinPrefix(key, k.String())
    }
    for i := 0; i < t.NumField(); i++ {
        ft := t.Field(i)
        tag, ok := ft.Tag.Lookup(fieldTagName)
        if !ok || ft.Name == structKey {
            continue
        }
        value := value.Field(i)
        prefix, mul, div := parseTag(tag)
        toMap(value, rv, joinPrefix(key, prefix), mul, div)
    }
}

func convertMap(value reflect.Value, rv map[string]int64, key string, mul, div int) {
    if value.IsNil() {
        log.Panicf("value is nil key=%s", key)
    }
    for _, k := range value.MapKeys() {
        toMap(value.MapIndex(k), rv, joinPrefix(key, k.String()), mul, div)
    }
}

func convertArraySlice(value reflect.Value, rv map[string]int64, key string, mul, div int) {
    for i := 0; i < value.Len(); i++ {
        toMap(value.Index(i), rv, key, mul, div)
    }
}

func convertBool(value reflect.Value, rv map[string]int64, key string) {
    if _, ok := rv[key]; ok {
        log.Panic("duplicate key: ", key)
    }
    if value.Bool() {
        rv[key] = 1
    } else {
        rv[key] = 0
    }
}

func convertInteger(value reflect.Value, rv map[string]int64, key string, mul, div int) {
    if _, ok := rv[key]; ok {
        log.Panic("duplicate key: ", key)
    }
    intVal := value.Int()
    rv[key] = intVal * int64(mul) / int64(div)
}

func convertFloat(value reflect.Value, rv map[string]int64, key string, mul, div int) {
    if _, ok := rv[key]; ok {
        log.Panic("duplicate key: ", key)
    }
    floatVal := value.Float()
    rv[key] = int64(floatVal * float64(mul) / float64(div))
}

func convertInterface(value reflect.Value, rv map[string]int64, key string, mul, div int) {
    fv := reflect.ValueOf(value.Interface())
    toMap(fv, rv, key, mul, div)
}

func joinPrefix(prefix, key string) string {
    if prefix == "" {
        return key
    }
    if key == "" {
        return prefix
    }
    return prefix + "_" + key
}

func parseTag(tag string) (prefix string, mul int, div int) {
    tokens := strings.Split(tag, ",")
    mul = 1
    div = 1
    var err error
    switch len(tokens) {
    case 3:
        div, err = strconv.Atoi(tokens[2])
        if err != nil {
            log.Panic(err)
        }
        fallthrough
    case 2:
        mul, err = strconv.Atoi(tokens[1])
        if err != nil {
            log.Panic(err)
        }
        fallthrough
    case 1:
        prefix = tokens[0]
    default:
        log.Panic(fmt.Errorf("invalid tag format: %s", tag))
    }
    return
}