// 
// Decompiled by Procyon v0.6.0
// 

package com.google.protobuf;

@CheckReturnValue
final class ManifestSchemaFactory implements SchemaFactory
{
    private final MessageInfoFactory messageInfoFactory;
    private static final MessageInfoFactory EMPTY_FACTORY;
    
    public ManifestSchemaFactory() {
        this(getDefaultMessageInfoFactory());
    }
    
    private ManifestSchemaFactory(final MessageInfoFactory messageInfoFactory) {
        this.messageInfoFactory = Internal.checkNotNull(messageInfoFactory, "messageInfoFactory");
    }
    
    @Override
    public <T> Schema<T> createSchema(final Class<T> messageType) {
        SchemaUtil.requireGeneratedMessage(messageType);
        final MessageInfo messageInfo = this.messageInfoFactory.messageInfoFor(messageType);
        if (messageInfo.isMessageSetWireFormat()) {
            return (Schema<T>)(useLiteRuntime(messageType) ? MessageSetSchema.newSchema(SchemaUtil.unknownFieldSetLiteSchema(), ExtensionSchemas.lite(), messageInfo.getDefaultInstance()) : MessageSetSchema.newSchema(SchemaUtil.unknownFieldSetFullSchema(), ExtensionSchemas.full(), messageInfo.getDefaultInstance()));
        }
        return newSchema(messageType, messageInfo);
    }
    
    private static <T> Schema<T> newSchema(final Class<T> messageType, final MessageInfo messageInfo) {
        return useLiteRuntime(messageType) ? MessageSchema.newSchema(messageType, messageInfo, NewInstanceSchemas.lite(), ListFieldSchemas.lite(), SchemaUtil.unknownFieldSetLiteSchema(), allowExtensions(messageInfo) ? ExtensionSchemas.lite() : null, MapFieldSchemas.lite()) : MessageSchema.newSchema(messageType, messageInfo, NewInstanceSchemas.full(), ListFieldSchemas.full(), SchemaUtil.unknownFieldSetFullSchema(), allowExtensions(messageInfo) ? ExtensionSchemas.full() : null, MapFieldSchemas.full());
    }
    
    private static boolean allowExtensions(final MessageInfo messageInfo) {
        switch (messageInfo.getSyntax()) {
            case PROTO3: {
                return false;
            }
            default: {
                return true;
            }
        }
    }
    
    private static MessageInfoFactory getDefaultMessageInfoFactory() {
        return new CompositeMessageInfoFactory(new MessageInfoFactory[] { GeneratedMessageInfoFactory.getInstance(), getDescriptorMessageInfoFactory() });
    }
    
    private static MessageInfoFactory getDescriptorMessageInfoFactory() {
        if (Android.assumeLiteRuntime) {
            return ManifestSchemaFactory.EMPTY_FACTORY;
        }
        try {
            final Class<?> clazz = Class.forName("com.google.protobuf.DescriptorMessageInfoFactory");
            return (MessageInfoFactory)clazz.getDeclaredMethod("getInstance", (Class<?>[])new Class[0]).invoke(null, new Object[0]);
        }
        catch (final Exception e) {
            return ManifestSchemaFactory.EMPTY_FACTORY;
        }
    }
    
    private static boolean useLiteRuntime(final Class<?> messageType) {
        return Android.assumeLiteRuntime || GeneratedMessageLite.class.isAssignableFrom(messageType);
    }
    
    static {
        EMPTY_FACTORY = new MessageInfoFactory() {
            @Override
            public boolean isSupported(final Class<?> clazz) {
                return false;
            }
            
            @Override
            public MessageInfo messageInfoFor(final Class<?> clazz) {
                throw new IllegalStateException("This should never be called.");
            }
        };
    }
    
    private static class CompositeMessageInfoFactory implements MessageInfoFactory
    {
        private MessageInfoFactory[] factories;
        
        CompositeMessageInfoFactory(final MessageInfoFactory... factories) {
            this.factories = factories;
        }
        
        @Override
        public boolean isSupported(final Class<?> clazz) {
            for (final MessageInfoFactory factory : this.factories) {
                if (factory.isSupported(clazz)) {
                    return true;
                }
            }
            return false;
        }
        
        @Override
        public MessageInfo messageInfoFor(final Class<?> clazz) {
            for (final MessageInfoFactory factory : this.factories) {
                if (factory.isSupported(clazz)) {
                    return factory.messageInfoFor(clazz);
                }
            }
            throw new UnsupportedOperationException("No factory is available for message type: " + clazz.getName());
        }
    }
}