package com.thoughtworks.xstream.converters.extended;

import com.thoughtworks.xstream.converters.ConversionException;
import com.thoughtworks.xstream.converters.Converter;
import com.thoughtworks.xstream.converters.MarshallingContext;
import com.thoughtworks.xstream.converters.UnmarshallingContext;
import com.thoughtworks.xstream.core.ClassLoaderReference;
import com.thoughtworks.xstream.core.util.Fields;
import com.thoughtworks.xstream.io.HierarchicalStreamReader;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.thoughtworks.xstream.mapper.Mapper;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;

/* loaded from: classes.dex */
public class DynamicProxyConverter implements Converter {
    private static final InvocationHandler DUMMY;
    private static final Field HANDLER;
    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$extended$DynamicProxyConverter;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$DynamicProxyMapper$DynamicProxy;
    static /* synthetic */ Class class$java$lang$reflect$InvocationHandler;
    static /* synthetic */ Class class$java$lang$reflect$Proxy;
    private ClassLoaderReference classLoaderReference;
    private Mapper mapper;

    static {
        Class cls = class$java$lang$reflect$Proxy;
        if (cls == null) {
            cls = class$("java.lang.reflect.Proxy");
            class$java$lang$reflect$Proxy = cls;
        }
        Class cls2 = class$java$lang$reflect$InvocationHandler;
        if (cls2 == null) {
            cls2 = class$("java.lang.reflect.InvocationHandler");
            class$java$lang$reflect$InvocationHandler = cls2;
        }
        HANDLER = Fields.locate(cls, cls2, false);
        DUMMY = new InvocationHandler() { // from class: com.thoughtworks.xstream.converters.extended.DynamicProxyConverter.1
            @Override // java.lang.reflect.InvocationHandler
            public Object invoke(Object obj, Method method, Object[] objArr) throws Throwable {
                return null;
            }
        };
    }

    /* JADX WARN: Illegal instructions before constructor call */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct code enable 'Show inconsistent code' option in preferences
    */
    public DynamicProxyConverter(com.thoughtworks.xstream.mapper.Mapper r2) {
        /*
            r1 = this;
            java.lang.Class r0 = com.thoughtworks.xstream.converters.extended.DynamicProxyConverter.class$com$thoughtworks$xstream$converters$extended$DynamicProxyConverter
            if (r0 != 0) goto Lc
            java.lang.String r0 = "com.thoughtworks.xstream.converters.extended.DynamicProxyConverter"
            java.lang.Class r0 = class$(r0)
            com.thoughtworks.xstream.converters.extended.DynamicProxyConverter.class$com$thoughtworks$xstream$converters$extended$DynamicProxyConverter = r0
        Lc:
            java.lang.ClassLoader r0 = r0.getClassLoader()
            r1.<init>(r2, r0)
            return
        */
        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.extended.DynamicProxyConverter.<init>(com.thoughtworks.xstream.mapper.Mapper):void");
    }

    private void addInterfacesToXml(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter) {
        for (Class<?> cls : obj.getClass().getInterfaces()) {
            hierarchicalStreamWriter.startNode("interface");
            hierarchicalStreamWriter.setValue(this.mapper.serializedClass(cls));
            hierarchicalStreamWriter.endNode();
        }
    }

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

    @Override // com.thoughtworks.xstream.converters.ConverterMatcher
    public boolean canConvert(Class cls) {
        if (cls != null) {
            Class cls2 = class$com$thoughtworks$xstream$mapper$DynamicProxyMapper$DynamicProxy;
            if (cls2 == null) {
                cls2 = class$("com.thoughtworks.xstream.mapper.DynamicProxyMapper$DynamicProxy");
                class$com$thoughtworks$xstream$mapper$DynamicProxyMapper$DynamicProxy = cls2;
            }
            if (cls.equals(cls2) || Proxy.isProxyClass(cls)) {
                return true;
            }
        }
        return false;
    }

    @Override // com.thoughtworks.xstream.converters.Converter
    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
        InvocationHandler invocationHandler = Proxy.getInvocationHandler(obj);
        addInterfacesToXml(obj, hierarchicalStreamWriter);
        hierarchicalStreamWriter.startNode("handler");
        String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("class");
        if (aliasForSystemAttribute != null) {
            hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute, this.mapper.serializedClass(invocationHandler.getClass()));
        }
        marshallingContext.convertAnother(invocationHandler);
        hierarchicalStreamWriter.endNode();
    }

    @Override // com.thoughtworks.xstream.converters.Converter
    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
        Class cls;
        String aliasForSystemAttribute;
        ArrayList arrayList = new ArrayList();
        while (true) {
            if (!hierarchicalStreamReader.hasMoreChildren()) {
                cls = null;
                break;
            }
            hierarchicalStreamReader.moveDown();
            String nodeName = hierarchicalStreamReader.getNodeName();
            if (!nodeName.equals("interface")) {
                if (nodeName.equals("handler") && (aliasForSystemAttribute = this.mapper.aliasForSystemAttribute("class")) != null) {
                    cls = this.mapper.realClass(hierarchicalStreamReader.getAttribute(aliasForSystemAttribute));
                    break;
                }
            } else {
                arrayList.add(this.mapper.realClass(hierarchicalStreamReader.getValue()));
            }
            hierarchicalStreamReader.moveUp();
        }
        if (cls == null) {
            throw new ConversionException("No InvocationHandler specified for dynamic proxy");
        }
        Class[] clsArr = new Class[arrayList.size()];
        arrayList.toArray(clsArr);
        Object newProxyInstance = HANDLER != null ? Proxy.newProxyInstance(this.classLoaderReference.getReference(), clsArr, DUMMY) : null;
        InvocationHandler invocationHandler = (InvocationHandler) unmarshallingContext.convertAnother(newProxyInstance, cls);
        hierarchicalStreamReader.moveUp();
        Field field = HANDLER;
        if (field == null) {
            return Proxy.newProxyInstance(this.classLoaderReference.getReference(), clsArr, invocationHandler);
        }
        Fields.write(field, newProxyInstance, invocationHandler);
        return newProxyInstance;
    }

    public DynamicProxyConverter(Mapper mapper, ClassLoaderReference classLoaderReference) {
        this.classLoaderReference = classLoaderReference;
        this.mapper = mapper;
    }

    public DynamicProxyConverter(Mapper mapper, ClassLoader classLoader) {
        this(mapper, new ClassLoaderReference(classLoader));
    }
}