import java.util.*;
import java.lang.*;
import java.io.*;
import java.lang.reflect.*;

// The main method must be in a class named "Main".
class Main {
    public static void main(String[] args) throws Exception {
        Persona persona = new Persona("Juan", 30, Arrays.asList("Fútbol", "Música", "Lectura"));

        // Serializar a JSON
        String json = JsonMapper.serialize(persona);
        System.out.println("JSON: " + json);

        // Deserializar a objeto
        Persona deserializado = JsonMapper.deserialize(json, Persona.class);
        System.out.println("Objeto: " + deserializado.nombre + ", " + deserializado.edad + ", " + deserializado.hobbies);
    }
}

class Persona {
    public String nombre;
    public int edad;
    public List<String> hobbies;

    public Persona() {} // Constructor necesario para la deserialización

    public Persona(String nombre, int edad, List<String> hobbies) {
        this.nombre = nombre;
        this.edad = edad;
        this.hobbies = hobbies;
    }
}


class JsonMapper {

    /** Serializa un objeto Java a su representación en JSON */
    public static String serialize(Object obj) throws IllegalAccessException {
        if (obj == null) return "null";

        Class<?> clazz = obj.getClass();

        // Manejo de tipos primitivos y Strings
        if (clazz == String.class) return "\"" + obj.toString() + "\"";
        if (clazz == Character.class) return "\"" + obj.toString() + "\"";
        if (Number.class.isAssignableFrom(clazz) || clazz == Boolean.class) return obj.toString();

        // Manejo de listas y colecciones
        if (obj instanceof Collection) {
            Collection<?> collection = (Collection<?>) obj;
            StringBuilder json = new StringBuilder("[");
            for (Object item : collection) {
                json.append(serialize(item)).append(",");
            }
            if (!collection.isEmpty()) json.deleteCharAt(json.length() - 1);
            json.append("]");
            return json.toString();
        }

        // Manejo de mapas
        if (obj instanceof Map) {
            Map<?, ?> map = (Map<?, ?>) obj;
            StringBuilder json = new StringBuilder("{");
            for (Map.Entry<?, ?> entry : map.entrySet()) {
                json.append("\"").append(entry.getKey().toString()).append("\":")
                        .append(serialize(entry.getValue())).append(",");
            }
            if (!map.isEmpty()) json.deleteCharAt(json.length() - 1);
            json.append("}");
            return json.toString();
        }

        // Manejo de objetos personalizados (POJOs)
        StringBuilder json = new StringBuilder("{");
        for (Field field : clazz.getDeclaredFields()) {
            field.setAccessible(true);
            Object value = field.get(obj);
            json.append("\"").append(field.getName()).append("\":")
                    .append(serialize(value)).append(",");
        }
        if (clazz.getDeclaredFields().length > 0) json.deleteCharAt(json.length() - 1);
        json.append("}");
        return json.toString();
    }

    /** Deserializa un JSON en un objeto de Java */
    public static <T> T deserialize(String json, Class<T> clazz) throws Exception {
        if (json == null || json.equals("null")) return null;

        // Manejo de tipos primitivos y String
        if (clazz == String.class) return clazz.cast(json.replaceAll("^\"|\"$", ""));
        if (clazz == int.class || clazz == Integer.class) return clazz.cast(Integer.parseInt(json));
        if (clazz == double.class || clazz == Double.class) return clazz.cast(Double.parseDouble(json));
        if (clazz == boolean.class || clazz == Boolean.class) return clazz.cast(Boolean.parseBoolean(json));

        // Manejo de listas (asumiendo que la clase tiene un constructor sin argumentos)
        if (clazz.isAssignableFrom(List.class)) {
            List<Object> list = new ArrayList<>();
            String innerJson = json.substring(1, json.length() - 1);
            String[] items = innerJson.split(",");
            for (String item : items) {
                list.add(item.replaceAll("^\"|\"$", ""));
            }
            return clazz.cast(list);
        }

        // Manejo de objetos personalizados
        T obj = clazz.getDeclaredConstructor().newInstance();
        json = json.substring(1, json.length() - 1); // Elimina { }
        String[] fields = json.split(",");

        for (String field : fields) {
            String[] keyValue = field.split(":");
            if (keyValue.length < 2) continue;
            String key = keyValue[0].replaceAll("^\"|\"$", "").trim();
            String value = keyValue[1].trim();

            Field objField = clazz.getDeclaredField(key);
            objField.setAccessible(true);

            if (objField.getType() == String.class) objField.set(obj, value.replaceAll("^\"|\"$", ""));
            else if (objField.getType() == int.class || objField.getType() == Integer.class)
                objField.set(obj, Integer.parseInt(value));
            else if (objField.getType() == double.class || objField.getType() == Double.class)
                objField.set(obj, Double.parseDouble(value));
            else if (objField.getType() == boolean.class || objField.getType() == Boolean.class)
                objField.set(obj, Boolean.parseBoolean(value));
        }

        return obj;
    }
}