package ixUtils

import (
	"encoding/json"
	"fmt"
	"io"
	"os"
)

/*
 * @Author: lixu lixu@puchigames.com
 * @Date: 2025-06-16 10:17:13
 * @LastEditors: lixu lixu@puchigames.com
 * @LastEditTime: 2025-06-16 10:17:20
 * @FilePath: /go-helper/utils/json.go
 * @Description: JSON处理工具函数，包含JSON编码、解码、格式化等功能
 */

// JsonEncode 将任意类型转换为JSON字符串
func JsonEncode(v interface{}) (string, error) {
	if v == nil {
		return "", fmt.Errorf("value is nil")
	}
	bytes, err := json.Marshal(v)
	if err != nil {
		return "", err
	}
	return string(bytes), nil
}

// JsonEncodePretty 将任意类型转换为格式化的JSON字符串
func JsonEncodePretty(v interface{}) (string, error) {
	if v == nil {
		return "", fmt.Errorf("value is nil")
	}
	bytes, err := json.MarshalIndent(v, "", "    ")
	if err != nil {
		return "", err
	}
	return string(bytes), nil
}

// JsonDecode 将JSON字符串解析为指定类型
func JsonDecode(data string, v interface{}) error {
	if data == "" {
		return fmt.Errorf("data is empty")
	}
	if v == nil {
		return fmt.Errorf("target interface is nil")
	}
	return json.Unmarshal([]byte(data), v)
}

// JsonEncodeFile 将数据序列化为JSON并写入文件
func JsonEncodeFile(v interface{}, filename string) error {
	if v == nil {
		return fmt.Errorf("value is nil")
	}
	if filename == "" {
		return fmt.Errorf("filename cannot be empty")
	}
	data, err := json.MarshalIndent(v, "", "    ")
	if err != nil {
		return err
	}
	return os.WriteFile(filename, data, 0644)
}

// JsonDecodeFile 从文件读取JSON并解析为指定类型
func JsonDecodeFile(filename string, v interface{}) error {
	if filename == "" {
		return fmt.Errorf("filename cannot be empty")
	}
	if v == nil {
		return fmt.Errorf("target interface is nil")
	}
	data, err := os.ReadFile(filename)
	if err != nil {
		return err
	}
	return json.Unmarshal(data, v)
}

// JsonEncodeStream 将数据序列化为JSON并写入io.Writer
func JsonEncodeStream(v interface{}, w io.Writer) error {
	if v == nil {
		return fmt.Errorf("value is nil")
	}
	if w == nil {
		return fmt.Errorf("writer is nil")
	}
	return json.NewEncoder(w).Encode(v)
}

// JsonDecodeStream 从io.Reader读取JSON并解析为指定类型
func JsonDecodeStream(r io.Reader, v interface{}) error {
	if r == nil {
		return fmt.Errorf("reader is nil")
	}
	if v == nil {
		return fmt.Errorf("target interface is nil")
	}
	return json.NewDecoder(r).Decode(v)
}

// IsValidJson 检查字符串是否为有效的JSON
func IsValidJson(str string) bool {
	if str == "" {
		return false
	}
	var js json.RawMessage
	return json.Unmarshal([]byte(str), &js) == nil
}

// JsonGetField 获取JSON字符串中指定字段的值
func JsonGetField(data string, field string) (interface{}, error) {
	if data == "" {
		return nil, fmt.Errorf("data is empty")
	}
	if field == "" {
		return nil, fmt.Errorf("field is empty")
	}
	var result map[string]interface{}
	if err := json.Unmarshal([]byte(data), &result); err != nil {
		return nil, err
	}
	if value, ok := result[field]; ok {
		return value, nil
	}
	return nil, fmt.Errorf("field %s not found", field)
}

// JsonSetField 设置JSON字符串中指定字段的值
func JsonSetField(data string, field string, value interface{}) (string, error) {
	if data == "" {
		return "", fmt.Errorf("data is empty")
	}
	if field == "" {
		return "", fmt.Errorf("field is empty")
	}
	var result map[string]interface{}
	if err := json.Unmarshal([]byte(data), &result); err != nil {
		return "", err
	}
	result[field] = value
	newData, err := json.Marshal(result)
	if err != nil {
		return "", err
	}
	return string(newData), nil
}

// JsonMerge 合并两个JSON字符串
func JsonMerge(json1, json2 string) (string, error) {
	if json1 == "" {
		return json2, nil
	}
	if json2 == "" {
		return json1, nil
	}

	var map1, map2 map[string]interface{}

	if err := json.Unmarshal([]byte(json1), &map1); err != nil {
		return "", err
	}
	if err := json.Unmarshal([]byte(json2), &map2); err != nil {
		return "", err
	}

	// 合并map
	for k, v := range map2 {
		map1[k] = v
	}

	result, err := json.Marshal(map1)
	if err != nil {
		return "", err
	}
	return string(result), nil
}

// ========== 强制转换版本（不返回错误） ==========

// MustJsonEncode 强制将任意类型转换为JSON字符串
func MustJsonEncode(v interface{}) string {
	result, _ := JsonEncode(v)
	return result
}

// MustJsonEncodePretty 强制将任意类型转换为格式化的JSON字符串
func MustJsonEncodePretty(v interface{}) string {
	result, _ := JsonEncodePretty(v)
	return result
}

// MustJsonDecode 强制解码JSON字符串到指定类型
func MustJsonDecode(data string, v interface{}) {
	JsonDecode(data, v)
}

// MustJsonEncodeFile 强制将对象编码为JSON并保存到文件
func MustJsonEncodeFile(v interface{}, filename string) {
	JsonEncodeFile(v, filename)
}

// MustJsonDecodeFile 强制从文件读取JSON并解码到指定类型
func MustJsonDecodeFile(filename string, v interface{}) {
	JsonDecodeFile(filename, v)
}

// MustJsonEncodeStream 强制将对象编码为JSON并写入流
func MustJsonEncodeStream(v interface{}, w io.Writer) {
	JsonEncodeStream(v, w)
}

// MustJsonDecodeStream 强制从流读取JSON并解码到指定类型
func MustJsonDecodeStream(r io.Reader, v interface{}) {
	JsonDecodeStream(r, v)
}

// MustJsonGetField 强制获取JSON字段值
func MustJsonGetField(data string, field string) interface{} {
	result, _ := JsonGetField(data, field)
	return result
}

// MustJsonSetField 强制设置JSON字段值
func MustJsonSetField(data string, field string, value interface{}) string {
	result, _ := JsonSetField(data, field, value)
	return result
}

// MustJsonMerge 强制合并两个JSON字符串
func MustJsonMerge(json1, json2 string) string {
	result, _ := JsonMerge(json1, json2)
	return result
}