package go_lib

import (
	"encoding/json"
	"reflect"
)

func JsonEncode(data interface{}) (string, error) {
	bytes, err := json.Marshal(data)
	if err != nil {
		return "", err
	}
	return string(bytes), nil
}

func JsonDecode(jsonStr string) (interface{}, error) {
	var result interface{}
	err := json.Unmarshal([]byte(jsonStr), &result)
	return result, err
}

func JsonDecodeArray(jsonStr string) ([]interface{}, error) {
	var result []interface{}
	err := json.Unmarshal([]byte(jsonStr), &result)
	return result, err
}

func JsonDecodeMap(jsonStr string) (map[string]interface{}, error) {
	var result map[string]interface{}
	err := json.Unmarshal([]byte(jsonStr), &result)
	return result, err
}

func JsonDecodeStruct(jsonStr string, v interface{}) error {
	return json.Unmarshal([]byte(jsonStr), v)
}

func JsonEncodePretty(data interface{}) (string, error) {
	bytes, err := json.MarshalIndent(data, "", "  ")
	if err != nil {
		return "", err
	}
	return string(bytes), nil
}

func IsJson(str string) bool {
	var js interface{}
	return json.Unmarshal([]byte(str), &js) == nil
}

func IsJsonArray(str string) bool {
	var js []interface{}
	return json.Unmarshal([]byte(str), &js) == nil
}

func IsJsonObject(str string) bool {
	var js map[string]interface{}
	return json.Unmarshal([]byte(str), &js) == nil
}

func JsonGetValue(jsonStr, key string) (interface{}, error) {
	var data map[string]interface{}
	err := json.Unmarshal([]byte(jsonStr), &data)
	if err != nil {
		return nil, err
	}
	
	return data[key], nil
}

func JsonSetValue(jsonStr, key string, value interface{}) (string, error) {
	var data map[string]interface{}
	err := json.Unmarshal([]byte(jsonStr), &data)
	if err != nil {
		data = make(map[string]interface{})
	}
	
	data[key] = value
	
	bytes, err := json.Marshal(data)
	if err != nil {
		return "", err
	}
	return string(bytes), nil
}

func JsonDeleteKey(jsonStr, key string) (string, error) {
	var data map[string]interface{}
	err := json.Unmarshal([]byte(jsonStr), &data)
	if err != nil {
		return jsonStr, err
	}
	
	delete(data, key)
	
	bytes, err := json.Marshal(data)
	if err != nil {
		return "", err
	}
	return string(bytes), nil
}

func JsonMerge(json1, json2 string) (string, error) {
	var data1, data2 map[string]interface{}
	
	err := json.Unmarshal([]byte(json1), &data1)
	if err != nil {
		return "", err
	}
	
	err = json.Unmarshal([]byte(json2), &data2)
	if err != nil {
		return "", err
	}
	
	for key, value := range data2 {
		data1[key] = value
	}
	
	bytes, err := json.Marshal(data1)
	if err != nil {
		return "", err
	}
	return string(bytes), nil
}

func JsonKeys(jsonStr string) ([]string, error) {
	var data map[string]interface{}
	err := json.Unmarshal([]byte(jsonStr), &data)
	if err != nil {
		return nil, err
	}
	
	keys := make([]string, 0, len(data))
	for key := range data {
		keys = append(keys, key)
	}
	return keys, nil
}

func JsonValues(jsonStr string) ([]interface{}, error) {
	var data map[string]interface{}
	err := json.Unmarshal([]byte(jsonStr), &data)
	if err != nil {
		return nil, err
	}
	
	values := make([]interface{}, 0, len(data))
	for _, value := range data {
		values = append(values, value)
	}
	return values, nil
}

func JsonLength(jsonStr string) (int, error) {
	var data interface{}
	err := json.Unmarshal([]byte(jsonStr), &data)
	if err != nil {
		return 0, err
	}
	
	v := reflect.ValueOf(data)
	switch v.Kind() {
	case reflect.Array, reflect.Slice, reflect.Map:
		return v.Len(), nil
	default:
		return 0, nil
	}
}

func JsonHasKey(jsonStr, key string) bool {
	var data map[string]interface{}
	err := json.Unmarshal([]byte(jsonStr), &data)
	if err != nil {
		return false
	}
	
	_, exists := data[key]
	return exists
}

func JsonToStruct(jsonStr string, target interface{}) error {
	return json.Unmarshal([]byte(jsonStr), target)
}

func StructToJson(data interface{}) (string, error) {
	bytes, err := json.Marshal(data)
	if err != nil {
		return "", err
	}
	return string(bytes), nil
}

func JsonEscape(str string) string {
	bytes, _ := json.Marshal(str)
	result := string(bytes)
	return result[1 : len(result)-1]
}

func JsonUnescape(str string) (string, error) {
	var result string
	err := json.Unmarshal([]byte("\""+str+"\""), &result)
	return result, err
}

func ArrayToJson(arr interface{}) (string, error) {
	bytes, err := json.Marshal(arr)
	if err != nil {
		return "", err
	}
	return string(bytes), nil
}

func JsonToArray(jsonStr string) ([]interface{}, error) {
	var result []interface{}
	err := json.Unmarshal([]byte(jsonStr), &result)
	return result, err
}