package main

import (
	"flag"
	"fmt"
	"os"
	"path/filepath"
	"time"

	"code.tczkiot.com/wlw/srdb"
	"github.com/shopspring/decimal"
)

// ========== 嵌套结构体定义 ==========

// Location 位置信息（嵌套结构体）
type Location struct {
	Country  string  `json:"country"`
	Province string  `json:"province"`
	City     string  `json:"city"`
	Address  string  `json:"address"`
	Lat      float64 `json:"lat"`
	Lng      float64 `json:"lng"`
}

// NetworkConfig 网络配置（嵌套结构体）
type NetworkConfig struct {
	SSID       string `json:"ssid"`
	Password   string `json:"password"`
	IPAddress  string `json:"ip_address"`
	Gateway    string `json:"gateway"`
	DNS        string `json:"dns"`
	UseStaticIP bool  `json:"use_static_ip"`
}

// Sensor 传感器信息（用于切片）
type Sensor struct {
	Type         string  `json:"type"`           // 传感器类型
	Model        string  `json:"model"`          // 型号
	Value        float64 `json:"value"`          // 当前值
	Unit         string  `json:"unit"`           // 单位
	MinValue     float64 `json:"min_value"`      // 最小值
	MaxValue     float64 `json:"max_value"`      // 最大值
	Precision    int     `json:"precision"`      // 精度
	SamplingRate int     `json:"sampling_rate"`  // 采样率
	Enabled      bool    `json:"enabled"`        // 是否启用
}

// MaintenanceRecord 维护记录（用于切片）
type MaintenanceRecord struct {
	Date        string `json:"date"`         // 维护日期
	Technician  string `json:"technician"`   // 技术员
	Type        string `json:"type"`         // 维护类型
	Description string `json:"description"`  // 描述
	Cost        float64 `json:"cost"`        // 费用
	NextDate    string `json:"next_date"`    // 下次维护日期
}

// ========== 主结构体定义 ==========

// ComplexDevice 复杂设备记录（包含所有复杂场景）
type ComplexDevice struct {
	// ========== 基本字段 ==========
	DeviceID string `srdb:"device_id;indexed;comment:设备ID"`
	Name     string `srdb:"name;comment:设备名称"`
	Model    string `srdb:"model;comment:设备型号"`

	// ========== Nullable 字段（指针类型）==========
	SerialNumber *string           `srdb:"serial_number;nullable;comment:序列号（可选）"`
	Manufacturer *string           `srdb:"manufacturer;nullable;comment:制造商（可选）"`
	Description  *string           `srdb:"description;nullable;comment:描述（可选）"`
	WarrantyEnd  *time.Time        `srdb:"warranty_end;nullable;comment:保修截止日期（可选）"`
	LastMaintenance *time.Time     `srdb:"last_maintenance;nullable;comment:上次维护时间（可选）"`
	MaxPower     *float32          `srdb:"max_power;nullable;comment:最大功率（可选）"`
	Weight       *float64          `srdb:"weight;nullable;comment:重量（可选）"`
	Voltage      *int32            `srdb:"voltage;nullable;comment:电压（可选）"`
	Price        *decimal.Decimal  `srdb:"price;nullable;comment:价格（可选）"`

	// ========== 所有基本类型 ==========
	// 有符号整数
	Signal       int   `srdb:"signal;comment:信号强度"`
	ErrorCode    int8  `srdb:"error_code;comment:错误码"`
	Temperature  int16 `srdb:"temperature;comment:温度（℃*10）"`
	Counter      int32 `srdb:"counter;comment:计数器"`
	TotalBytes   int64 `srdb:"total_bytes;comment:总字节数"`

	// 无符号整数
	Flags        uint   `srdb:"flags;comment:标志位"`
	Status       uint8  `srdb:"status;comment:状态码"`
	Port         uint16 `srdb:"port;comment:端口号"`
	SessionID    uint32 `srdb:"session_id;comment:会话ID"`
	Timestamp    uint64 `srdb:"timestamp;comment:时间戳"`

	// 浮点数
	Humidity     float32 `srdb:"humidity;comment:湿度"`
	Latitude     float64 `srdb:"latitude;comment:纬度"`
	Longitude    float64 `srdb:"longitude;comment:经度"`

	// 布尔
	IsOnline     bool `srdb:"is_online;indexed;comment:是否在线"`
	IsActivated  bool `srdb:"is_activated;comment:是否激活"`

	// 特殊类型
	BatteryLevel byte            `srdb:"battery_level;comment:电池电量"`
	Grade        rune            `srdb:"grade;comment:等级"`
	TotalPrice   decimal.Decimal `srdb:"total_price;comment:总价"`
	CreatedAt    time.Time       `srdb:"created_at;comment:创建时间"`
	Uptime       time.Duration   `srdb:"uptime;comment:运行时长"`

	// ========== 嵌套结构体（Object）==========
	Location      Location      `srdb:"location;comment:位置信息（嵌套结构体）"`
	NetworkConfig NetworkConfig `srdb:"network_config;comment:网络配置（嵌套结构体）"`

	// ========== 结构体切片（Array）==========
	Sensors           []Sensor            `srdb:"sensors;comment:传感器列表（结构体切片）"`
	MaintenanceRecords []MaintenanceRecord `srdb:"maintenance_records;comment:维护记录（结构体切片）"`

	// ========== 基本类型切片 ==========
	Tags              []string  `srdb:"tags;comment:标签列表"`
	AlertCodes        []int32   `srdb:"alert_codes;comment:告警代码列表"`
	HistoryReadings   []float64 `srdb:"history_readings;comment:历史读数"`

	// ========== 简单 Map（Object）==========
	Metadata          map[string]any `srdb:"metadata;comment:元数据"`
	CustomSettings    map[string]any `srdb:"custom_settings;comment:自定义设置"`
}

func main() {
	// 命令行参数
	dataDir := flag.String("dir", "./data", "数据存储目录")
	clean := flag.Bool("clean", false, "运行前清理数据目录")
	flag.Parse()

	fmt.Println("=============================================================")
	fmt.Println("  SRDB 复杂类型系统演示（Nullable + 嵌套结构体 + 结构体切片）")
	fmt.Println("=============================================================\n")

	// 准备数据目录
	absDir, err := filepath.Abs(*dataDir)
	if err != nil {
		fmt.Printf("❌ 无效的目录路径: %v\n", err)
		os.Exit(1)
	}

	if *clean {
		fmt.Printf("🧹 清理数据目录: %s\n", absDir)
		os.RemoveAll(absDir)
	}

	fmt.Printf("📁 数据目录: %s\n\n", absDir)

	// ========== 步骤 1: 从结构体生成 Schema ==========
	fmt.Println("【步骤 1】从结构体自动生成 Schema")
	fmt.Println("─────────────────────────────────────────────────────")

	fields, err := srdb.StructToFields(ComplexDevice{})
	if err != nil {
		fmt.Printf("❌ 失败: %v\n", err)
		os.Exit(1)
	}

	fmt.Printf("✅ 成功生成 %d 个字段\n\n", len(fields))

	// 统计字段类型
	nullableCount := 0
	objectCount := 0
	arrayCount := 0
	for _, field := range fields {
		if field.Nullable {
			nullableCount++
		}
		if field.Type.String() == "object" {
			objectCount++
		}
		if field.Type.String() == "array" {
			arrayCount++
		}
	}

	fmt.Println("字段统计:")
	fmt.Printf("  • 总字段数: %d\n", len(fields))
	fmt.Printf("  • Nullable 字段: %d 个（使用指针）\n", nullableCount)
	fmt.Printf("  • Object 字段: %d 个（结构体/map）\n", objectCount)
	fmt.Printf("  • Array 字段: %d 个（切片）\n", arrayCount)

	// ========== 步骤 2: 创建表 ==========
	fmt.Println("\n【步骤 2】创建数据表")
	fmt.Println("─────────────────────────────────────────────────────")

	table, err := srdb.OpenTable(&srdb.TableOptions{
		Dir:    absDir,
		Name:   "complex_devices",
		Fields: fields,
	})
	if err != nil {
		fmt.Printf("❌ 创建表失败: %v\n", err)
		os.Exit(1)
	}
	defer table.Close()
	fmt.Println("✅ 表 'complex_devices' 创建成功")

	// ========== 步骤 3: 插入完整数据 ==========
	fmt.Println("\n【步骤 3】插入测试数据")
	fmt.Println("─────────────────────────────────────────────────────")

	// 准备辅助变量
	serialNum := "SN-2025-001-ALPHA"
	manufacturer := "智能科技有限公司"
	description := "高性能工业级环境监测站，支持多种传感器接入"
	warrantyEnd := time.Now().AddDate(3, 0, 0) // 3年保修
	lastMaint := time.Now().Add(-30 * 24 * time.Hour) // 30天前维护
	maxPower := float32(500.5)
	weight := 12.5
	voltage := int32(220)
	price := decimal.NewFromFloat(9999.99)

	// 数据1: 完整填充（包含所有 Nullable 字段）
	device1 := map[string]any{
		// 基本字段
		"device_id": "COMPLEX-DEV-001",
		"name":      "智能环境监测站 Pro",
		"model":     "ENV-MONITOR-PRO-X1",

		// Nullable 字段（全部有值）
		"serial_number":    serialNum,
		"manufacturer":     manufacturer,
		"description":      description,
		"warranty_end":     warrantyEnd,
		"last_maintenance": lastMaint,
		"max_power":        maxPower,
		"weight":           weight,
		"voltage":          voltage,
		"price":            price,

		// 基本类型
		"signal":      -55,
		"error_code":  int8(0),
		"temperature": int16(235), // 23.5°C
		"counter":     int32(12345),
		"total_bytes": int64(1024 * 1024 * 500),
		"flags":       uint(0x0F),
		"status":      uint8(200),
		"port":        uint16(8080),
		"session_id":  uint32(987654321),
		"timestamp":   uint64(time.Now().Unix()),
		"humidity":    float32(65.5),
		"latitude":    39.904200,
		"longitude":   116.407396,
		"is_online":   true,
		"is_activated": true,
		"battery_level": byte(85),
		"grade":       rune('S'),
		"total_price": decimal.NewFromFloat(15999.99),
		"created_at":  time.Now(),
		"uptime":      72 * time.Hour,

		// 嵌套结构体
		"location": Location{
			Country:  "中国",
			Province: "北京市",
			City:     "朝阳区",
			Address:  "建国路88号",
			Lat:      39.904200,
			Lng:      116.407396,
		},
		"network_config": NetworkConfig{
			SSID:        "SmartDevice-5G",
			Password:    "******",
			IPAddress:   "192.168.1.100",
			Gateway:     "192.168.1.1",
			DNS:         "8.8.8.8",
			UseStaticIP: true,
		},

		// 结构体切片
		"sensors": []Sensor{
			{
				Type:         "temperature",
				Model:        "DHT22",
				Value:        23.5,
				Unit:         "°C",
				MinValue:     -40.0,
				MaxValue:     80.0,
				Precision:    1,
				SamplingRate: 1000,
				Enabled:      true,
			},
			{
				Type:         "humidity",
				Model:        "DHT22",
				Value:        65.5,
				Unit:         "%",
				MinValue:     0.0,
				MaxValue:     100.0,
				Precision:    1,
				SamplingRate: 1000,
				Enabled:      true,
			},
			{
				Type:         "pressure",
				Model:        "BMP280",
				Value:        1013.25,
				Unit:         "hPa",
				MinValue:     300.0,
				MaxValue:     1100.0,
				Precision:    2,
				SamplingRate: 500,
				Enabled:      true,
			},
		},
		"maintenance_records": []MaintenanceRecord{
			{
				Date:        "2024-12-01",
				Technician:  "张工",
				Type:        "定期维护",
				Description: "清洁传感器、检查线路、更新固件",
				Cost:        500.00,
				NextDate:    "2025-03-01",
			},
			{
				Date:        "2024-09-15",
				Technician:  "李工",
				Type:        "故障维修",
				Description: "更换损坏的温度传感器",
				Cost:        800.00,
				NextDate:    "2024-12-01",
			},
		},

		// 基本类型切片
		"tags":             []string{"industrial", "outdoor", "monitoring", "iot", "smart-city"},
		"alert_codes":      []int32{1001, 2003, 3005, 4002},
		"history_readings": []float64{23.1, 23.3, 23.5, 23.7, 23.9, 24.0},

		// Map
		"metadata": map[string]any{
			"install_date": "2024-01-15",
			"firmware_version": "v2.3.1",
			"hardware_revision": "Rev-C",
			"certification": []string{"CE", "FCC", "RoHS"},
		},
		"custom_settings": map[string]any{
			"auto_calibrate": true,
			"report_interval": 60,
			"alert_threshold": 85.0,
			"debug_mode": false,
		},
	}

	err = table.Insert(device1)
	if err != nil {
		fmt.Printf("❌ 插入数据1失败: %v\n", err)
		os.Exit(1)
	}
	fmt.Println("✅ 数据1插入成功: " + device1["name"].(string))
	fmt.Println("   包含: 9个Nullable字段（全部有值）")
	fmt.Println("   包含: 2个嵌套结构体 + 2个结构体切片")

	// Debug: 检查插入后的记录数
	count1, _ := table.Query().Rows()
	c1 := 0
	for count1.Next() {
		c1++
	}
	count1.Close()
	fmt.Printf("   🔍 插入后表中有 %d 条记录\n", c1)

	// 数据2: 部分 Nullable 字段为 nil
	device2 := map[string]any{
		// 基本字段
		"device_id": "COMPLEX-DEV-002",
		"name":      "简易温湿度传感器",
		"model":     "TEMP-SENSOR-LITE",

		// Nullable 字段（部分为 nil）
		"serial_number":    "SN-2025-002-BETA",
		"manufacturer":     "普通传感器公司",
		"description":      nil, // NULL
		"warranty_end":     nil, // NULL
		"last_maintenance": nil, // NULL
		"max_power":        nil, // NULL
		"weight":           nil, // NULL
		"voltage":          nil, // NULL
		"price":            nil, // NULL

		// 基本类型
		"signal":      -70,
		"error_code":  int8(0),
		"temperature": int16(220),
		"counter":     int32(500),
		"total_bytes": int64(1024 * 1024 * 10),
		"flags":       uint(0x03),
		"status":      uint8(100),
		"port":        uint16(8081),
		"session_id":  uint32(123456789),
		"timestamp":   uint64(time.Now().Unix()),
		"humidity":    float32(55.0),
		"latitude":    39.900000,
		"longitude":   116.400000,
		"is_online":   false,
		"is_activated": true,
		"battery_level": byte(30),
		"grade":       rune('B'),
		"total_price": decimal.NewFromFloat(299.99),
		"created_at":  time.Now().Add(-7 * 24 * time.Hour),
		"uptime":      168 * time.Hour,

		// 嵌套结构体
		"location": Location{
			Country:  "中国",
			Province: "上海市",
			City:     "浦东新区",
			Address:  "世纪大道123号",
			Lat:      31.235929,
			Lng:      121.506058,
		},
		"network_config": NetworkConfig{
			SSID:        "SmartDevice-2.4G",
			Password:    "******",
			IPAddress:   "192.168.1.101",
			Gateway:     "192.168.1.1",
			DNS:         "114.114.114.114",
			UseStaticIP: false,
		},

		// 结构体切片（较少的元素）
		"sensors": []Sensor{
			{
				Type:         "temperature",
				Model:        "DS18B20",
				Value:        22.0,
				Unit:         "°C",
				MinValue:     -55.0,
				MaxValue:     125.0,
				Precision:    0,
				SamplingRate: 500,
				Enabled:      true,
			},
		},
		"maintenance_records": []MaintenanceRecord{},

		// 基本类型切片
		"tags":             []string{"indoor", "basic"},
		"alert_codes":      []int32{},
		"history_readings": []float64{21.5, 21.8, 22.0},

		// Map
		"metadata": map[string]any{
			"install_date": "2025-01-01",
			"firmware_version": "v1.0.0",
		},
		"custom_settings": map[string]any{
			"report_interval": 120,
		},
	}

	err = table.Insert(device2)
	if err != nil {
		fmt.Printf("❌ 插入数据2失败: %v\n", err)
		os.Exit(1)
	}
	fmt.Println("✅ 数据2插入成功: " + device2["name"].(string))
	fmt.Println("   包含: 9个Nullable字段（6个为nil）")
	fmt.Println("   包含: 较少的结构体切片元素")

	// Debug: 检查插入后的记录数
	count2, _ := table.Query().Rows()
	c2 := 0
	for count2.Next() {
		c2++
	}
	count2.Close()
	fmt.Printf("   🔍 插入后表中有 %d 条记录\n", c2)

	// 数据3: 所有 Nullable 字段为 nil
	device3 := map[string]any{
		// 基本字段
		"device_id": "COMPLEX-DEV-003",
		"name":      "最小配置设备",
		"model":     "MIN-CONFIG",

		// Nullable 字段（全部为 nil）
		"serial_number":    nil,
		"manufacturer":     nil,
		"description":      nil,
		"warranty_end":     nil,
		"last_maintenance": nil,
		"max_power":        nil,
		"weight":           nil,
		"voltage":          nil,
		"price":            nil,

		// 基本类型（最小值/默认值）
		"signal":      -90,
		"error_code":  int8(-1),
		"temperature": int16(0),
		"counter":     int32(0),
		"total_bytes": int64(0),
		"flags":       uint(0),
		"status":      uint8(0),
		"port":        uint16(0),
		"session_id":  uint32(0),
		"timestamp":   uint64(0),
		"humidity":    float32(0.0),
		"latitude":    0.0,
		"longitude":   0.0,
		"is_online":   false,
		"is_activated": false,
		"battery_level": byte(0),
		"grade":       rune('C'),
		"total_price": decimal.Zero,
		"created_at":  time.Unix(0, 0),
		"uptime":      0 * time.Second,

		// 嵌套结构体（空值）
		"location": Location{},
		"network_config": NetworkConfig{},

		// 结构体切片（空切片）
		"sensors":             []Sensor{},
		"maintenance_records": []MaintenanceRecord{},

		// 基本类型切片（空切片）
		"tags":             []string{},
		"alert_codes":      []int32{},
		"history_readings": []float64{},

		// Map（空map）
		"metadata":        map[string]any{},
		"custom_settings": map[string]any{},
	}

	err = table.Insert(device3)
	if err != nil {
		fmt.Printf("❌ 插入数据3失败: %v\n", err)
		os.Exit(1)
	}
	fmt.Println("✅ 数据3插入成功: " + device3["name"].(string))
	fmt.Println("   包含: 9个Nullable字段（全部为nil）")
	fmt.Println("   包含: 所有切片为空")

	// Debug: 检查插入后的记录数
	count3, _ := table.Query().Rows()
	c3 := 0
	for count3.Next() {
		c3++
	}
	count3.Close()
	fmt.Printf("   🔍 插入后表中有 %d 条记录\n", c3)

	// ========== 步骤 4: 查询并展示 ==========
	fmt.Println("\n【步骤 4】查询并验证数据")
	fmt.Println("─────────────────────────────────────────────────────")

	// Debug: 直接检查表的记录数
	debugRows, _ := table.Query().Rows()
	debugCount := 0
	for debugRows.Next() {
		debugCount++
	}
	debugRows.Close()
	fmt.Printf("🔍 调试: 表中实际有 %d 条记录\n\n", debugCount)

	rows, err := table.Query().OrderBy("_seq").Rows()
	if err != nil {
		fmt.Printf("❌ 查询失败: %v\n", err)
		os.Exit(1)
	}
	defer rows.Close()

	count := 0
	for rows.Next() {
		row := rows.Row()
		data := row.Data()
		count++

		fmt.Printf("\n╔══════════════════ 设备 #%d (seq=%d) ══════════════════╗\n", count, row.Seq())
		fmt.Printf("║ ID: %-53s ║\n", data["device_id"])
		fmt.Printf("║ 名称: %-51s ║\n", data["name"])
		fmt.Printf("║ 型号: %-51s ║\n", data["model"])

		// Nullable 字段展示
		fmt.Printf("╟────────────────── Nullable 字段 ─────────────────────╢\n")

		if data["serial_number"] != nil {
			fmt.Printf("║ 序列号: %-47s ║\n", data["serial_number"])
		} else {
			fmt.Printf("║ 序列号: <未设置>%40s ║\n", "")
		}

		if data["manufacturer"] != nil {
			fmt.Printf("║ 制造商: %-47s ║\n", data["manufacturer"])
		} else {
			fmt.Printf("║ 制造商: <未设置>%40s ║\n", "")
		}

		if data["price"] != nil {
			price := data["price"].(decimal.Decimal)
			fmt.Printf("║ 价格: ¥%-47s ║\n", price.StringFixed(2))
		} else {
			fmt.Printf("║ 价格: <未设置>%42s ║\n", "")
		}

		if data["warranty_end"] != nil {
			warrantyEnd := data["warranty_end"].(time.Time)
			fmt.Printf("║ 保修截止: %-43s ║\n", warrantyEnd.Format("2006-01-02"))
		} else {
			fmt.Printf("║ 保修截止: <未设置>%38s ║\n", "")
		}

		// 嵌套结构体展示
		fmt.Printf("╟───────────────── 嵌套结构体 ─────────────────────╢\n")

		location := data["location"].(map[string]any)
		fmt.Printf("║ 位置: %s %s %s%*s ║\n",
			location["country"], location["province"], location["city"],
			37-len(fmt.Sprint(location["country"], location["province"], location["city"])), "")
		fmt.Printf("║       地址: %-43v ║\n", location["address"])

		networkCfg := data["network_config"].(map[string]any)
		fmt.Printf("║ 网络: SSID=%v, IP=%v%*s ║\n",
			networkCfg["ssid"], networkCfg["ip_address"],
			27-len(fmt.Sprint(networkCfg["ssid"], networkCfg["ip_address"])), "")

		// 结构体切片展示
		fmt.Printf("╟───────────────── 结构体切片 ──────────────────────╢\n")

		sensors := data["sensors"].([]any)
		fmt.Printf("║ 传感器数量: %d 个%39s ║\n", len(sensors), "")
		for i, s := range sensors {
			sensor := s.(map[string]any)
			fmt.Printf("║   [%d] %s: %.1f %s (型号: %s)%*s ║\n",
				i+1, sensor["type"], sensor["value"], sensor["unit"], sensor["model"],
				20-len(fmt.Sprint(sensor["type"], sensor["model"])), "")
		}

		maintRecords := data["maintenance_records"].([]any)
		fmt.Printf("║ 维护记录: %d 条%40s ║\n", len(maintRecords), "")
		for i, m := range maintRecords {
			maint := m.(map[string]any)
			fmt.Printf("║   [%d] %s - %s (¥%.2f)%*s ║\n",
				i+1, maint["date"], maint["type"], maint["cost"],
				22-len(fmt.Sprint(maint["date"], maint["type"])), "")
		}

		// 基本类型切片
		fmt.Printf("╟───────────────── 基本类型切片 ────────────────────╢\n")

		tags := data["tags"].([]any)
		fmt.Printf("║ 标签: %d 个 %v%*s ║\n",
			len(tags), tags,
			45-len(fmt.Sprint(tags)), "")

		fmt.Println("╚═════════════════════════════════════════════════════════╝")
	}

	if count != 3 {
		fmt.Printf("\n❌ 预期 3 条记录，实际 %d 条\n", count)
		os.Exit(1)
	}

	// ========== 总结 ==========
	fmt.Println("\n\n=============================================================")
	fmt.Println("  ✅ 所有复杂类型测试通过！")
	fmt.Println("=============================================================")
	fmt.Println("\n📊 功能验证:")
	fmt.Println("  ✓ Nullable 字段（指针类型）")
	fmt.Println("    - 数据1: 9个Nullable字段全部有值")
	fmt.Println("    - 数据2: 9个Nullable字段部分为nil")
	fmt.Println("    - 数据3: 9个Nullable字段全部为nil")
	fmt.Println("\n  ✓ 嵌套结构体（Object）")
	fmt.Println("    - Location: 6个字段的位置信息结构体")
	fmt.Println("    - NetworkConfig: 6个字段的网络配置结构体")
	fmt.Println("\n  ✓ 结构体切片（Array of Struct）")
	fmt.Println("    - Sensors: 传感器列表（每个9个字段）")
	fmt.Println("    - MaintenanceRecords: 维护记录列表（每个6个字段）")
	fmt.Println("\n  ✓ 基本类型切片")
	fmt.Println("    - []string: 标签列表")
	fmt.Println("    - []int32: 告警代码列表")
	fmt.Println("    - []float64: 历史读数")
	fmt.Println("\n  ✓ Map类型")
	fmt.Println("    - metadata: 元数据信息")
	fmt.Println("    - custom_settings: 自定义设置")
	fmt.Println("\n💡 关键特性:")
	fmt.Println("  • 指针类型自动识别为Nullable")
	fmt.Println("  • 嵌套结构体自动转JSON")
	fmt.Println("  • 结构体切片自动序列化")
	fmt.Println("  • nil值正确处理和展示")
	fmt.Println("  • 空切片和空map正确存储")
	fmt.Printf("\n📁 数据已保存到: %s\n", absDir)
}