JSON Serialization

import 'dart:convert';
import 'package:ack/ack.dart';

// Assume userSchema is defined (e.g., in schemas.mdx)
final userSchema = Ack.object({
  'name': Ack.string,
  'age': Ack.int.min(0),
  'email': Ack.string.email().nullable(),
}, required: ['name']);

void processApiResponse(String jsonString) {
  // 1. Decode JSON string into a Dart object.
  // Note: jsonDecode returns dynamic, so the structure is unknown initially.
  dynamic jsonData; 
  try {
    jsonData = jsonDecode(jsonString);
  } catch (e) {
    print('Failed to decode JSON: $e');
    return;
  }

  // 2. Validate the decoded data against your defined schema.
  final result = userSchema.validate(jsonData);

  if (result.isOk) {
    // Data structure and types are valid according to the schema.
    final validDataMap = result.getOrThrow();
    print('Valid JSON received: $validDataMap');
    
    // Optionally convert to a typed model (see next section)
    // final user = User.fromValidatedMap(validDataMap);

  } else {
    // Handle validation errors (see Error Handling guide)
    print('Invalid JSON data: ${result.getError()?.message}');
    // Log the full error for debugging if needed:
    // print('Error details: ${result.getError()}');
  }
}

// Example Usage
processApiResponse('{"name": "Alice", "age": 30, "email": "alice@example.com"}');
processApiResponse('{"name": "Bob", "age": -5}'); // Invalid: age fails min(0)
processApiResponse('{"age": 25}'); // Invalid: missing required field 'name'
processApiResponse('not valid json'); // Decoding error

// Assumed User model class
class User {
  final String name;
  final int? age;
  final String? email;

  User({required this.name, this.age, this.email});

  // Factory constructor to create User from a validated map
  factory User.fromValidatedMap(Map<String, dynamic> map) {
    // Assumes the map structure and types have already been 
    // validated by the Ack schema. Direct casting is safe here.
    return User(
      name: map['name'] as String, 
      age: map['age'] as int?, // Cast to nullable int
      email: map['email'] as String?,
    );
  }
}

// Inside the validation success block:
if (result.isOk) {
  final validDataMap = result.getOrThrow();
  // Convert map to User model
  final user = User.fromValidatedMap(validDataMap);
  print('Created User model: ${user.name}');
} 

// Assumes user.dart and user.schema.dart (generated) exist
import 'user.dart';
import 'user.schema.dart';

// Create schema instance (validation happens automatically)
final userSchemaInstance = UserSchema(jsonData);

if (userSchemaInstance.isValid) {
  // Access validated data through typed getters
  print('Name: ${userSchemaInstance.name}');
  print('Email: ${userSchemaInstance.email}');
  
  // Create model using your preferred pattern
  final user = User(
    name: userSchemaInstance.name,
    email: userSchemaInstance.email,
  );
  print('Created User model via generator: ${user.name}');
}

class User {
  // ... (properties and constructor as before)

  // Method to convert User instance to a Map
  Map<String, dynamic> toMap() {
    return {
      'name': name,
      'age': age,
      'email': email,
    };
  }
}

// Usage:
final user = User(name: 'Charlie', age: 40);
final userMap = user.toMap();
final jsonString = jsonEncode(userMap); // Encode map to JSON string
print('Serialized JSON: $jsonString');

// Assume userModelInstance is an instance of User
// 1. Convert Model to Map data using toMap()
final userData = userModelInstance.toMap();

// 2. Create Schema instance from Map
final userSchemaInstance = UserSchema(userData);
// 3. Convert Schema instance to Map
final userMap = userSchemaInstance.toMap();
// 4. Encode Map to JSON
final jsonString = jsonEncode(userMap);
print('Serialized JSON via generator: $jsonString');