package encoding
 
import (
    "strings"
    "testing"
)
 
func isASCIIUpper(c byte) bool {
    return 'A' <= c && c <= 'Z'
}
 
func jsonSnakeCase(s string) string {
    var b []byte
    for i := 0; i < len(s); i++ { // proto identifiers are always ASCII
        c := s[i]
        if isASCIIUpper(c) {
            b = append(b, '_')
            c += 'a' - 'A' // convert to lowercase
        }
        b = append(b, c)
    }
    return string(b)
}
 
func jsonSnakeCase2(s string) string {
    var builder strings.Builder
    builder.Grow(len(s))
 
    for i := 0; i < len(s); i++ { // proto identifiers are always ASCII
        c := s[i]
        if isASCIIUpper(c) {
            builder.WriteByte('_')
            c += 'a' - 'A' // convert to lowercase
        }
        builder.WriteByte(c)
    }
 
    return builder.String()
}
 
func TestJsonSnakeCase(t *testing.T) {
    tests := []struct {
        input string
    }{
        {"MyVariableName"},
        {"myVariableName"},
        {"JSONParser"},
        {"HTTPRequest"},
        {"URLShortener"},
        {"snake_case"},
        {"Mixed_snakeCase"},
        {"aB"},
        {"AB"},
        {"X"},
        {""},
        {"abc_hh2HelloWorld"},
    }
 
    for _, tt := range tests {
        result := jsonSnakeCase(tt.input)
        result3 := jsonSnakeCase2(tt.input)
        if result != result3 {
            t.Errorf("got different result")
        }
    }
}
 
var camelCase = "helloWorldGoKatos"
 
func Benchmark_jsonSnakeCase(b *testing.B) {
    b.Run("jsonSnakeCase", func(b *testing.B) {
        b.ReportAllocs()
 
        for i := 0; i < b.N; i++ {
            jsonSnakeCase(camelCase)
        }
    })
 
    b.Run("jsonSnakeCase2", func(b *testing.B) {
        b.ReportAllocs()
 
        for i := 0; i < b.N; i++ {
            jsonSnakeCase2(camelCase)
        }
    })
}
 
func jsonCamelCase(s string) string {
    var b []byte
    var wasUnderscore bool
    for i := 0; i < len(s); i++ { // proto identifiers are always ASCII
        c := s[i]
        if c != '_' {
            if wasUnderscore && isASCIILower(c) {
                c -= 'a' - 'A' // convert to uppercase
            }
            b = append(b, c)
        }
        wasUnderscore = c == '_'
    }
    return string(b)
}
 
func isASCIILower(c byte) bool {
    return 'a' <= c && c <= 'z'
}
 
func jsonCamelCase2(s string) string {
    var builder strings.Builder
    builder.Grow(len(s))
 
    wasUnderscore := false
    for i := 0; i < len(s); i++ { // proto identifiers are always ASCIIS
        c := s[i]
        if c != '_' {
            if wasUnderscore && isASCIILower(c) {
                c -= 'a' - 'A' // convert to uppercase
            }
            builder.WriteByte(c)
        }
        wasUnderscore = c == '_'
    }
 
    return builder.String()
}
 
func TestJsonCamelCase(t *testing.T) {
    tests := []struct {
        input string
    }{
        {"MyVariableName"},
        {"myVariableName"},
        {"JSONParser"},
        {"snake_case"},
        {"Mixed_snakeCase"},
        {"a_B"},
        {"A_B"},
        {"X_"},
        {"x_"},
        {"x_y"},
        {""},
        {"abc_hh2HelloWorld"},
    }
 
    for _, tt := range tests {
        result := jsonSnakeCase(tt.input)
        result3 := jsonSnakeCase2(tt.input)
        if result != result3 {
            t.Errorf("got different result")
        }
    }
}
 
var snakeCase = "hello_world_go_kratos"
 
func Benchmark_jsonCamelCase(b *testing.B) {
    b.Run("jsonCameCase", func(b *testing.B) {
        b.ReportAllocs()
 
        for i := 0; i < b.N; i++ {
            jsonCamelCase(snakeCase)
        }
    })
 
    b.Run("jsonCamelCase2", func(b *testing.B) {
        b.ReportAllocs()
 
        for i := 0; i < b.N; i++ {
            jsonCamelCase2(snakeCase)
        }
    })
}