package com.thoughtworks.xstream.converters.reflection;

import com.thoughtworks.xstream.converters.ConversionException;
import com.thoughtworks.xstream.converters.MarshallingContext;
import com.thoughtworks.xstream.converters.UnmarshallingContext;
import com.thoughtworks.xstream.converters.reflection.ReflectionProvider;
import com.thoughtworks.xstream.core.ClassLoaderReference;
import com.thoughtworks.xstream.core.JVM;
import com.thoughtworks.xstream.core.util.CustomObjectInputStream;
import com.thoughtworks.xstream.core.util.CustomObjectOutputStream;
import com.thoughtworks.xstream.core.util.Fields;
import com.thoughtworks.xstream.core.util.HierarchicalStreams;
import com.thoughtworks.xstream.io.ExtendedHierarchicalStreamWriterHelper;
import com.thoughtworks.xstream.io.HierarchicalStreamReader;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.thoughtworks.xstream.io.StreamException;
import com.thoughtworks.xstream.mapper.Mapper;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputValidation;
import java.io.ObjectStreamClass;
import java.io.ObjectStreamField;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/* loaded from: classes.dex */
public class SerializableConverter extends AbstractReflectionConverter {
    private static final String ATTRIBUTE_CLASS = "class";
    private static final String ATTRIBUTE_NAME = "name";
    private static final String ATTRIBUTE_SERIALIZATION = "serialization";
    private static final String ATTRIBUTE_VALUE_CUSTOM = "custom";
    private static final String ELEMENT_DEFAULT = "default";
    private static final String ELEMENT_FIELD = "field";
    private static final String ELEMENT_FIELDS = "fields";
    private static final String ELEMENT_NULL = "null";
    private static final String ELEMENT_UNSERIALIZABLE_PARENTS = "unserializable-parents";
    static /* synthetic */ Class class$java$io$Serializable;
    static /* synthetic */ Class class$java$lang$Object;
    private final ClassLoaderReference classLoaderReference;

    private static class UnserializableParentsReflectionProvider extends ReflectionProviderWrapper {
        public UnserializableParentsReflectionProvider(ReflectionProvider reflectionProvider) {
            super(reflectionProvider);
        }

        @Override // com.thoughtworks.xstream.converters.reflection.ReflectionProviderWrapper, com.thoughtworks.xstream.converters.reflection.ReflectionProvider
        public void visitSerializableFields(Object obj, final ReflectionProvider.Visitor visitor) {
            this.wrapped.visitSerializableFields(obj, new ReflectionProvider.Visitor() { // from class: com.thoughtworks.xstream.converters.reflection.SerializableConverter.UnserializableParentsReflectionProvider.1
                @Override // com.thoughtworks.xstream.converters.reflection.ReflectionProvider.Visitor
                public void visit(String str, Class cls, Class cls2, Object obj2) {
                    Class cls3 = SerializableConverter.class$java$io$Serializable;
                    if (cls3 == null) {
                        cls3 = SerializableConverter.class$("java.io.Serializable");
                        SerializableConverter.class$java$io$Serializable = cls3;
                    }
                    if (cls3.isAssignableFrom(cls2)) {
                        return;
                    }
                    visitor.visit(str, cls, cls2, obj2);
                }
            });
        }
    }

    public SerializableConverter(Mapper mapper, ReflectionProvider reflectionProvider, ClassLoaderReference classLoaderReference) {
        super(mapper, new UnserializableParentsReflectionProvider(reflectionProvider));
        this.classLoaderReference = classLoaderReference;
    }

    static /* synthetic */ Class class$(String str) {
        try {
            return Class.forName(str);
        } catch (ClassNotFoundException e) {
            throw new NoClassDefFoundError().initCause(e);
        }
    }

    private boolean isSerializable(Class cls) {
        if (cls == null) {
            return false;
        }
        Class cls2 = class$java$io$Serializable;
        if (cls2 == null) {
            cls2 = class$("java.io.Serializable");
            class$java$io$Serializable = cls2;
        }
        if (!cls2.isAssignableFrom(cls) || cls.isInterface()) {
            return false;
        }
        if (!this.serializationMembers.supportsReadObject(cls, true) && !this.serializationMembers.supportsWriteObject(cls, true)) {
            return false;
        }
        Iterator it = hierarchyFor(cls).iterator();
        while (it.hasNext()) {
            Class cls3 = class$java$io$Serializable;
            if (cls3 == null) {
                cls3 = class$("java.io.Serializable");
                class$java$io$Serializable = cls3;
            }
            if (!cls3.isAssignableFrom((Class) it.next())) {
                return canAccess(cls);
            }
        }
        return true;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public Object readField(ObjectStreamField objectStreamField, Class cls, Object obj) {
        return Fields.read(Fields.find(cls, objectStreamField.getName()), obj);
    }

    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
    public boolean canConvert(Class cls) {
        return JVM.canCreateDerivedObjectOutputStream() && isSerializable(cls);
    }

    @Override // com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter
    public void doMarshal(final Object obj, final HierarchicalStreamWriter hierarchicalStreamWriter, final MarshallingContext marshallingContext) {
        Class cls;
        String aliasForSystemAttribute;
        String aliasForSystemAttribute2;
        String aliasForSystemAttribute3 = this.mapper.aliasForSystemAttribute(ATTRIBUTE_SERIALIZATION);
        if (aliasForSystemAttribute3 != null) {
            hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute3, ATTRIBUTE_VALUE_CUSTOM);
        }
        final Class[] clsArr = new Class[1];
        final boolean[] zArr = {false};
        CustomObjectOutputStream.StreamCallback streamCallback = new CustomObjectOutputStream.StreamCallback() { // from class: com.thoughtworks.xstream.converters.reflection.SerializableConverter.1
            @Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
            public void close() {
                throw new UnsupportedOperationException("Objects are not allowed to call ObjectOutputStream.close() from writeObject()");
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
            public void defaultWriteObject() {
                String aliasForSystemAttribute4;
                ObjectStreamClass lookup = ObjectStreamClass.lookup(clsArr[0]);
                if (lookup == null) {
                    return;
                }
                boolean z = false;
                for (ObjectStreamField objectStreamField : lookup.getFields()) {
                    Object readField = SerializableConverter.this.readField(objectStreamField, clsArr[0], obj);
                    if (readField != null) {
                        if (!zArr[0]) {
                            hierarchicalStreamWriter.startNode(SerializableConverter.this.mapper.serializedClass(clsArr[0]));
                            zArr[0] = true;
                        }
                        if (!z) {
                            hierarchicalStreamWriter.startNode("default");
                            z = true;
                        }
                        if (SerializableConverter.this.mapper.shouldSerializeMember(clsArr[0], objectStreamField.getName())) {
                            Class<?> cls2 = readField.getClass();
                            ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, SerializableConverter.this.mapper.serializedMember(obj.getClass(), objectStreamField.getName()), cls2);
                            if (!cls2.equals(SerializableConverter.this.mapper.defaultImplementationOf(objectStreamField.getType())) && (aliasForSystemAttribute4 = SerializableConverter.this.mapper.aliasForSystemAttribute(SerializableConverter.ATTRIBUTE_CLASS)) != null) {
                                hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute4, SerializableConverter.this.mapper.serializedClass(cls2));
                            }
                            marshallingContext.convertAnother(readField);
                            hierarchicalStreamWriter.endNode();
                        }
                    }
                }
                if (zArr[0] && !z) {
                    hierarchicalStreamWriter.startNode("default");
                    hierarchicalStreamWriter.endNode();
                } else if (z) {
                    hierarchicalStreamWriter.endNode();
                }
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
            public void flush() {
                hierarchicalStreamWriter.flush();
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
            public void writeFieldsToStream(Map map) {
                String aliasForSystemAttribute4;
                ObjectStreamClass lookup = ObjectStreamClass.lookup(clsArr[0]);
                hierarchicalStreamWriter.startNode("default");
                for (String str : map.keySet()) {
                    if (SerializableConverter.this.mapper.shouldSerializeMember(clsArr[0], str)) {
                        ObjectStreamField field = lookup.getField(str);
                        Object obj2 = map.get(str);
                        if (field == null) {
                            throw new MissingFieldException(obj2.getClass().getName(), str);
                        }
                        if (obj2 != null) {
                            ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, SerializableConverter.this.mapper.serializedMember(obj.getClass(), str), obj2.getClass());
                            if (field.getType() != obj2.getClass() && !field.getType().isPrimitive() && (aliasForSystemAttribute4 = SerializableConverter.this.mapper.aliasForSystemAttribute(SerializableConverter.ATTRIBUTE_CLASS)) != null) {
                                hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute4, SerializableConverter.this.mapper.serializedClass(obj2.getClass()));
                            }
                            marshallingContext.convertAnother(obj2);
                            hierarchicalStreamWriter.endNode();
                        }
                    }
                }
                hierarchicalStreamWriter.endNode();
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
            public void writeToStream(Object obj2) {
                if (obj2 == null) {
                    hierarchicalStreamWriter.startNode(SerializableConverter.ELEMENT_NULL);
                    hierarchicalStreamWriter.endNode();
                } else {
                    ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, SerializableConverter.this.mapper.serializedClass(obj2.getClass()), obj2.getClass());
                    marshallingContext.convertAnother(obj2);
                    hierarchicalStreamWriter.endNode();
                }
            }
        };
        try {
            Iterator it = hierarchyFor(obj.getClass()).iterator();
            boolean z = false;
            while (it.hasNext()) {
                clsArr[0] = (Class) it.next();
                if (class$java$io$Serializable == null) {
                    cls = class$("java.io.Serializable");
                    class$java$io$Serializable = cls;
                } else {
                    cls = class$java$io$Serializable;
                }
                if (cls.isAssignableFrom(clsArr[0])) {
                    if (z) {
                        marshalUnserializableParent(hierarchicalStreamWriter, marshallingContext, obj);
                        z = false;
                    }
                    if (this.serializationMembers.supportsWriteObject(clsArr[0], false)) {
                        zArr[0] = true;
                        hierarchicalStreamWriter.startNode(this.mapper.serializedClass(clsArr[0]));
                        if (clsArr[0] != this.mapper.defaultImplementationOf(clsArr[0]) && (aliasForSystemAttribute = this.mapper.aliasForSystemAttribute(ATTRIBUTE_CLASS)) != null) {
                            hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute, clsArr[0].getName());
                        }
                        CustomObjectOutputStream customObjectOutputStream = CustomObjectOutputStream.getInstance(marshallingContext, streamCallback);
                        this.serializationMembers.callWriteObject(clsArr[0], obj, customObjectOutputStream);
                        customObjectOutputStream.popCallback();
                        hierarchicalStreamWriter.endNode();
                    } else if (this.serializationMembers.supportsReadObject(clsArr[0], false)) {
                        zArr[0] = true;
                        hierarchicalStreamWriter.startNode(this.mapper.serializedClass(clsArr[0]));
                        if (clsArr[0] != this.mapper.defaultImplementationOf(clsArr[0]) && (aliasForSystemAttribute2 = this.mapper.aliasForSystemAttribute(ATTRIBUTE_CLASS)) != null) {
                            hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute2, clsArr[0].getName());
                        }
                        streamCallback.defaultWriteObject();
                        hierarchicalStreamWriter.endNode();
                    } else {
                        zArr[0] = false;
                        streamCallback.defaultWriteObject();
                        if (zArr[0]) {
                            hierarchicalStreamWriter.endNode();
                        }
                    }
                } else {
                    z = true;
                }
            }
        } catch (IOException e) {
            throw new StreamException("Cannot write defaults", e);
        }
    }

    protected void doMarshalConditionally(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
        if (isSerializable(obj.getClass())) {
            doMarshal(obj, hierarchicalStreamWriter, marshallingContext);
        } else {
            super.doMarshal(obj, hierarchicalStreamWriter, marshallingContext);
        }
    }

    @Override // com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter
    public Object doUnmarshal(final Object obj, final HierarchicalStreamReader hierarchicalStreamReader, final UnmarshallingContext unmarshallingContext) {
        final Class[] clsArr = new Class[1];
        String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute(ATTRIBUTE_SERIALIZATION);
        if (aliasForSystemAttribute != null && !ATTRIBUTE_VALUE_CUSTOM.equals(hierarchicalStreamReader.getAttribute(aliasForSystemAttribute))) {
            throw new ConversionException("Cannot deserialize object with new readObject()/writeObject() methods");
        }
        CustomObjectInputStream.StreamCallback streamCallback = new CustomObjectInputStream.StreamCallback() { // from class: com.thoughtworks.xstream.converters.reflection.SerializableConverter.2
            @Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
            public void close() {
                throw new UnsupportedOperationException("Objects are not allowed to call ObjectInputStream.close() from readObject()");
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
            public void defaultReadObject() {
                Class defaultImplementationOf;
                if (SerializableConverter.this.serializationMembers.getSerializablePersistentFields(clsArr[0]) != null) {
                    readFieldsFromStream();
                    return;
                }
                if (hierarchicalStreamReader.hasMoreChildren()) {
                    hierarchicalStreamReader.moveDown();
                    if (!hierarchicalStreamReader.getNodeName().equals("default")) {
                        throw new ConversionException("Expected <default/> element in readObject() stream");
                    }
                    while (hierarchicalStreamReader.hasMoreChildren()) {
                        hierarchicalStreamReader.moveDown();
                        String realMember = SerializableConverter.this.mapper.realMember(clsArr[0], hierarchicalStreamReader.getNodeName());
                        if (SerializableConverter.this.mapper.shouldSerializeMember(clsArr[0], realMember)) {
                            String readClassAttribute = HierarchicalStreams.readClassAttribute(hierarchicalStreamReader, SerializableConverter.this.mapper);
                            if (readClassAttribute != null) {
                                defaultImplementationOf = SerializableConverter.this.mapper.realClass(readClassAttribute);
                            } else {
                                SerializableConverter serializableConverter = SerializableConverter.this;
                                defaultImplementationOf = serializableConverter.mapper.defaultImplementationOf(serializableConverter.reflectionProvider.getFieldType(obj, realMember, clsArr[0]));
                            }
                            SerializableConverter.this.reflectionProvider.writeField(obj, realMember, unmarshallingContext.convertAnother(obj, defaultImplementationOf), clsArr[0]);
                        }
                        hierarchicalStreamReader.moveUp();
                    }
                    hierarchicalStreamReader.moveUp();
                }
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
            public Map readFieldsFromStream() {
                Class type;
                HashMap hashMap = new HashMap();
                hierarchicalStreamReader.moveDown();
                if (hierarchicalStreamReader.getNodeName().equals(SerializableConverter.ELEMENT_FIELDS)) {
                    while (hierarchicalStreamReader.hasMoreChildren()) {
                        hierarchicalStreamReader.moveDown();
                        if (!hierarchicalStreamReader.getNodeName().equals(SerializableConverter.ELEMENT_FIELD)) {
                            throw new ConversionException("Expected <field/> element inside <field/>");
                        }
                        hashMap.put(hierarchicalStreamReader.getAttribute("name"), unmarshallingContext.convertAnother(obj, SerializableConverter.this.mapper.realClass(hierarchicalStreamReader.getAttribute(SerializableConverter.ATTRIBUTE_CLASS))));
                        hierarchicalStreamReader.moveUp();
                    }
                } else {
                    if (!hierarchicalStreamReader.getNodeName().equals("default")) {
                        throw new ConversionException("Expected <fields/> or <default/> element when calling ObjectInputStream.readFields()");
                    }
                    ObjectStreamClass lookup = ObjectStreamClass.lookup(clsArr[0]);
                    while (hierarchicalStreamReader.hasMoreChildren()) {
                        hierarchicalStreamReader.moveDown();
                        String realMember = SerializableConverter.this.mapper.realMember(clsArr[0], hierarchicalStreamReader.getNodeName());
                        if (SerializableConverter.this.mapper.shouldSerializeMember(clsArr[0], realMember)) {
                            String readClassAttribute = HierarchicalStreams.readClassAttribute(hierarchicalStreamReader, SerializableConverter.this.mapper);
                            if (readClassAttribute != null) {
                                type = SerializableConverter.this.mapper.realClass(readClassAttribute);
                            } else {
                                ObjectStreamField field = lookup.getField(realMember);
                                if (field == null) {
                                    throw new MissingFieldException(clsArr[0].getName(), realMember);
                                }
                                type = field.getType();
                            }
                            hashMap.put(realMember, unmarshallingContext.convertAnother(obj, type));
                        }
                        hierarchicalStreamReader.moveUp();
                    }
                }
                hierarchicalStreamReader.moveUp();
                return hashMap;
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
            public Object readFromStream() {
                hierarchicalStreamReader.moveDown();
                Object convertAnother = unmarshallingContext.convertAnother(obj, HierarchicalStreams.readClassType(hierarchicalStreamReader, SerializableConverter.this.mapper));
                hierarchicalStreamReader.moveUp();
                return convertAnother;
            }

            @Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
            public void registerValidation(final ObjectInputValidation objectInputValidation, int i) {
                unmarshallingContext.addCompletionCallback(new Runnable() { // from class: com.thoughtworks.xstream.converters.reflection.SerializableConverter.2.1
                    @Override // java.lang.Runnable
                    public void run() {
                        try {
                            objectInputValidation.validateObject();
                        } catch (InvalidObjectException e) {
                            throw new ObjectAccessException("Cannot validate object", e);
                        }
                    }
                }, i);
            }
        };
        while (hierarchicalStreamReader.hasMoreChildren()) {
            hierarchicalStreamReader.moveDown();
            String nodeName = hierarchicalStreamReader.getNodeName();
            if (nodeName.equals(ELEMENT_UNSERIALIZABLE_PARENTS)) {
                super.doUnmarshal(obj, hierarchicalStreamReader, unmarshallingContext);
            } else {
                String readClassAttribute = HierarchicalStreams.readClassAttribute(hierarchicalStreamReader, this.mapper);
                if (readClassAttribute == null) {
                    Mapper mapper = this.mapper;
                    clsArr[0] = mapper.defaultImplementationOf(mapper.realClass(nodeName));
                } else {
                    clsArr[0] = this.mapper.realClass(readClassAttribute);
                }
                if (this.serializationMembers.supportsReadObject(clsArr[0], false)) {
                    CustomObjectInputStream customObjectInputStream = CustomObjectInputStream.getInstance(unmarshallingContext, streamCallback, this.classLoaderReference);
                    this.serializationMembers.callReadObject(clsArr[0], obj, customObjectInputStream);
                    customObjectInputStream.popCallback();
                } else {
                    try {
                        streamCallback.defaultReadObject();
                    } catch (IOException e) {
                        throw new StreamException("Cannot read defaults", e);
                    }
                }
            }
            hierarchicalStreamReader.moveUp();
        }
        return obj;
    }

    protected Object doUnmarshalConditionally(Object obj, HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
        return isSerializable(obj.getClass()) ? doUnmarshal(obj, hierarchicalStreamReader, unmarshallingContext) : super.doUnmarshal(obj, hierarchicalStreamReader, unmarshallingContext);
    }

    protected List hierarchyFor(Class cls) {
        ArrayList arrayList = new ArrayList();
        while (true) {
            Class cls2 = class$java$lang$Object;
            if (cls2 == null) {
                cls2 = class$("java.lang.Object");
                class$java$lang$Object = cls2;
            }
            if (cls == cls2 || cls == null) {
                break;
            }
            arrayList.add(cls);
            cls = cls.getSuperclass();
        }
        Collections.reverse(arrayList);
        return arrayList;
    }

    protected void marshalUnserializableParent(HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext, Object obj) {
        hierarchicalStreamWriter.startNode(ELEMENT_UNSERIALIZABLE_PARENTS);
        super.doMarshal(obj, hierarchicalStreamWriter, marshallingContext);
        hierarchicalStreamWriter.endNode();
    }

    public SerializableConverter(Mapper mapper, ReflectionProvider reflectionProvider, ClassLoader classLoader) {
        this(mapper, reflectionProvider, new ClassLoaderReference(classLoader));
    }

    public SerializableConverter(Mapper mapper, ReflectionProvider reflectionProvider) {
        this(mapper, new UnserializableParentsReflectionProvider(reflectionProvider), new ClassLoaderReference(null));
    }
}