/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  com.l7tech.gateway.common.audit.Audit
 *  com.l7tech.gateway.common.audit.AuditDetailMessage
 *  com.l7tech.gateway.common.audit.LoggingAudit
 *  com.l7tech.gateway.common.audit.MessageProcessingMessages
 *  com.l7tech.gateway.common.audit.SystemMessages
 *  com.l7tech.gateway.common.service.PublishedService
 *  com.l7tech.gateway.common.transport.ResolutionConfiguration
 *  com.l7tech.message.Message
 *  com.l7tech.message.SoapKnob
 *  com.l7tech.objectmodel.FindException
 *  com.l7tech.objectmodel.Goid
 *  com.l7tech.util.Functions$TernaryThrows
 *  com.l7tech.util.Pair
 *  org.jetbrains.annotations.Nullable
 *  org.springframework.beans.factory.InitializingBean
 *  org.springframework.context.ApplicationEvent
 */
package com.l7tech.server.service.resolution;

import com.l7tech.gateway.common.audit.Audit;
import com.l7tech.gateway.common.audit.AuditDetailMessage;
import com.l7tech.gateway.common.audit.LoggingAudit;
import com.l7tech.gateway.common.audit.MessageProcessingMessages;
import com.l7tech.gateway.common.audit.SystemMessages;
import com.l7tech.gateway.common.service.PublishedService;
import com.l7tech.gateway.common.transport.ResolutionConfiguration;
import com.l7tech.message.Message;
import com.l7tech.message.SoapKnob;
import com.l7tech.objectmodel.FindException;
import com.l7tech.objectmodel.Goid;
import com.l7tech.server.event.EntityClassEvent;
import com.l7tech.server.service.resolution.CaseInsensitiveUriResolver;
import com.l7tech.server.service.resolution.NonUniqueServiceResolutionException;
import com.l7tech.server.service.resolution.Result;
import com.l7tech.server.service.resolution.ServiceResolutionException;
import com.l7tech.server.service.resolution.ServiceResolutionHelper;
import com.l7tech.server.service.resolution.ServiceResolver;
import com.l7tech.server.service.resolution.SoapActionResolver;
import com.l7tech.server.service.resolution.UriResolver;
import com.l7tech.server.service.resolution.UrnResolver;
import com.l7tech.server.service.resolution.d;
import com.l7tech.server.transport.ResolutionConfigurationManager;
import com.l7tech.server.util.PostStartupApplicationListener;
import com.l7tech.util.Functions;
import com.l7tech.util.Pair;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.jetbrains.annotations.Nullable;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationEvent;

public class ServiceResolutionManager
implements PostStartupApplicationListener,
InitializingBean {
    private static final Logger a;
    private final ResolutionConfigurationManager b;
    private final String c;
    private final Collection<ServiceResolver> d;
    private final Collection<ServiceResolver> e;
    private final Collection<ServiceResolver> f;
    private static final String[] g;

    public ServiceResolutionManager(ResolutionConfigurationManager resolutionConfigurationManager, String string, Collection<ServiceResolver> collection, Collection<ServiceResolver> collection2) {
        this.b = resolutionConfigurationManager;
        this.c = string;
        this.d = Collections.unmodifiableCollection(new ArrayList<ServiceResolver>(collection));
        this.e = Collections.unmodifiableCollection(new ArrayList<ServiceResolver>(collection2));
        ArrayList<ServiceResolver> arrayList = new ArrayList<ServiceResolver>();
        arrayList.addAll(this.d);
        arrayList.addAll(this.e);
        this.f = Collections.unmodifiableCollection(arrayList);
    }

    public void setServiceResolutionHelper(ServiceResolutionHelper serviceResolutionHelper) {
        this.f.forEach(serviceResolver -> serviceResolver.setServiceResolutionHelper(serviceResolutionHelper));
    }

    public PublishedService resolve(Audit audit, Message message, ServiceResolutionListener serviceResolutionListener, Collection<PublishedService> collection) throws ServiceResolutionException {
        PublishedService publishedService;
        block43: {
            boolean[] blArray;
            block42: {
                block40: {
                    block41: {
                        try {
                            if (collection.isEmpty()) {
                                audit.logAndAudit((AuditDetailMessage)MessageProcessingMessages.SERVICE_CACHE_NO_SERVICES);
                                return null;
                            }
                        }
                        catch (ServiceResolutionException serviceResolutionException) {
                            throw ServiceResolutionManager.a(serviceResolutionException);
                        }
                        blArray = new boolean[]{false};
                        d d10 = new d(this, serviceResolutionListener, blArray, message);
                        collection = this.a(audit, new HashMap<String, Object>(), d10, collection, true);
                        try {
                            if (collection == null) {
                                return null;
                            }
                        }
                        catch (ServiceResolutionException serviceResolutionException) {
                            throw ServiceResolutionManager.a(serviceResolutionException);
                        }
                        try {
                            if (collection.isEmpty()) {
                                audit.logAndAudit((AuditDetailMessage)MessageProcessingMessages.SERVICE_CACHE_NO_MATCH);
                                return null;
                            }
                        }
                        catch (ServiceResolutionException serviceResolutionException) {
                            throw ServiceResolutionManager.a(serviceResolutionException);
                        }
                        try {
                            try {
                                try {
                                    try {
                                        if (collection.size() <= 1) break block40;
                                        if (serviceResolutionListener == null) break block41;
                                    }
                                    catch (ServiceResolutionException serviceResolutionException) {
                                        throw ServiceResolutionManager.a(serviceResolutionException);
                                    }
                                    if (blArray[0]) break block41;
                                }
                                catch (ServiceResolutionException serviceResolutionException) {
                                    throw ServiceResolutionManager.a(serviceResolutionException);
                                }
                                blArray[0] = true;
                                if (serviceResolutionListener.notifyMessageBodyAccess(message, collection)) break block41;
                            }
                            catch (ServiceResolutionException serviceResolutionException) {
                                throw ServiceResolutionManager.a(serviceResolutionException);
                            }
                            return null;
                        }
                        catch (ServiceResolutionException serviceResolutionException) {
                            throw ServiceResolutionManager.a(serviceResolutionException);
                        }
                    }
                    if (!ServiceResolutionManager.a(message)) {
                        collection = ServiceResolutionManager.a(collection);
                    }
                }
                try {
                    if (collection.size() != 1) {
                        audit.logAndAudit((AuditDetailMessage)MessageProcessingMessages.SERVICE_CACHE_MULTI);
                        return null;
                    }
                }
                catch (ServiceResolutionException serviceResolutionException) {
                    throw ServiceResolutionManager.a(serviceResolutionException);
                }
                publishedService = collection.iterator().next();
                try {
                    try {
                        if (publishedService.isSoap() && !publishedService.isLaxResolution()) break block42;
                    }
                    catch (ServiceResolutionException serviceResolutionException) {
                        throw ServiceResolutionManager.a(serviceResolutionException);
                    }
                    return publishedService;
                }
                catch (ServiceResolutionException serviceResolutionException) {
                    throw ServiceResolutionManager.a(serviceResolutionException);
                }
            }
            try {
                try {
                    try {
                        if (serviceResolutionListener == null || blArray[0]) break block43;
                    }
                    catch (ServiceResolutionException serviceResolutionException) {
                        throw ServiceResolutionManager.a(serviceResolutionException);
                    }
                    if (serviceResolutionListener.notifyMessageBodyAccess(message, collection)) break block43;
                }
                catch (ServiceResolutionException serviceResolutionException) {
                    throw ServiceResolutionManager.a(serviceResolutionException);
                }
                return null;
            }
            catch (ServiceResolutionException serviceResolutionException) {
                throw ServiceResolutionManager.a(serviceResolutionException);
            }
        }
        try {
            if (message.getKnob(SoapKnob.class) == null) {
                audit.logAndAudit((AuditDetailMessage)MessageProcessingMessages.SERVICE_CACHE_NOT_SOAP);
                return null;
            }
        }
        catch (ServiceResolutionException serviceResolutionException) {
            throw ServiceResolutionManager.a(serviceResolutionException);
        }
        try {
            if (serviceResolutionListener != null) {
                serviceResolutionListener.notifyMessageValidation(message, publishedService);
            }
        }
        catch (ServiceResolutionException serviceResolutionException) {
            throw ServiceResolutionManager.a(serviceResolutionException);
        }
        for (ServiceResolver serviceResolver : this.e) {
            HashMap<String, Object> hashMap = new HashMap<String, Object>();
            serviceResolver.populateResolutionParameters(message, hashMap);
            Result result = serviceResolver.resolve(hashMap, collection);
            try {
                if (!result.getMatches().isEmpty()) continue;
                audit.logAndAudit((AuditDetailMessage)MessageProcessingMessages.SERVICE_CACHE_OPERATION_MISMATCH, new String[]{publishedService.getName(), publishedService.getId()});
                return null;
            }
            catch (ServiceResolutionException serviceResolutionException) {
                throw ServiceResolutionManager.a(serviceResolutionException);
            }
        }
        audit.logAndAudit((AuditDetailMessage)MessageProcessingMessages.SERVICE_CACHE_RESOLVED, new String[]{publishedService.getName(), publishedService.getId()});
        return publishedService;
    }

    public Collection<PublishedService> resolve(@Nullable String string, @Nullable String string2, @Nullable String string3, Collection<PublishedService> collection) throws ServiceResolutionException {
        block16: {
            try {
                if (collection.isEmpty()) {
                    return Collections.emptySet();
                }
            }
            catch (ServiceResolutionException serviceResolutionException) {
                throw ServiceResolutionManager.a(serviceResolutionException);
            }
            HashMap<String, Object> hashMap = new HashMap<String, Object>();
            try {
                if (string != null) {
                    hashMap.put(UriResolver.class.getName() + g[2], string);
                    hashMap.put(CaseInsensitiveUriResolver.class.getName() + g[6], string.toLowerCase());
                }
            }
            catch (ServiceResolutionException serviceResolutionException) {
                throw ServiceResolutionManager.a(serviceResolutionException);
            }
            try {
                if (string2 != null) {
                    hashMap.put(SoapActionResolver.class.getName() + g[6], string2);
                }
            }
            catch (ServiceResolutionException serviceResolutionException) {
                throw ServiceResolutionManager.a(serviceResolutionException);
            }
            try {
                if (string3 != null) {
                    hashMap.put(UrnResolver.class.getName() + g[6], string3);
                }
            }
            catch (ServiceResolutionException serviceResolutionException) {
                throw ServiceResolutionManager.a(serviceResolutionException);
            }
            collection = this.a((Audit)new LoggingAudit(a), hashMap, null, collection, true);
            try {
                try {
                    if (collection != null && !collection.isEmpty()) break block16;
                }
                catch (ServiceResolutionException serviceResolutionException) {
                    throw ServiceResolutionManager.a(serviceResolutionException);
                }
                return Collections.emptySet();
            }
            catch (ServiceResolutionException serviceResolutionException) {
                throw ServiceResolutionManager.a(serviceResolutionException);
            }
        }
        return collection;
    }

    public void notifyServiceCreated(Audit audit, PublishedService publishedService) {
        for (ServiceResolver serviceResolver : this.f) {
            try {
                try {
                    if (publishedService.isDisabled()) {
                        serviceResolver.serviceDeleted(publishedService);
                        continue;
                    }
                }
                catch (ServiceResolutionException serviceResolutionException) {
                    throw ServiceResolutionManager.a(serviceResolutionException);
                }
                serviceResolver.serviceCreated(publishedService);
            }
            catch (ServiceResolutionException serviceResolutionException) {
                audit.logAndAudit((AuditDetailMessage)SystemMessages.SERVICE_WSDL_ERROR, new String[]{publishedService.displayName(), serviceResolutionException.getMessage()}, (Throwable)serviceResolutionException);
            }
        }
    }

    public void notifyServiceUpdated(Audit audit, PublishedService publishedService) {
        for (ServiceResolver serviceResolver : this.f) {
            try {
                try {
                    if (publishedService.isDisabled()) {
                        serviceResolver.serviceDeleted(publishedService);
                        continue;
                    }
                }
                catch (ServiceResolutionException serviceResolutionException) {
                    throw ServiceResolutionManager.a(serviceResolutionException);
                }
                serviceResolver.serviceUpdated(publishedService);
            }
            catch (ServiceResolutionException serviceResolutionException) {
                audit.logAndAudit((AuditDetailMessage)SystemMessages.SERVICE_WSDL_ERROR, new String[]{publishedService.displayName(), serviceResolutionException.getMessage()}, (Throwable)serviceResolutionException);
            }
        }
    }

    public void notifyServiceDeleted(PublishedService publishedService) {
        for (ServiceResolver serviceResolver : this.f) {
            serviceResolver.serviceDeleted(publishedService);
        }
    }

    public void checkResolution(PublishedService publishedService, Collection<PublishedService> collection) throws ServiceResolutionException {
        ServiceResolver serviceResolver2;
        Collection<Map<String, Object>> collection2 = Collections.singleton(Collections.emptyMap());
        for (ServiceResolver serviceResolver2 : this.d) {
            collection2 = serviceResolver2.generateResolutionParameters(publishedService, collection2);
        }
        ArrayList arrayList = new ArrayList();
        serviceResolver2 = new LoggingAudit(a);
        for (Map<String, Object> map : collection2) {
            String[] stringArray = g;
            map.put(UriResolver.class.getName() + stringArray[3], Boolean.TRUE);
            map.put(CaseInsensitiveUriResolver.class.getName() + stringArray[5], Boolean.TRUE);
            Collection<PublishedService> collection3 = this.a((Audit)serviceResolver2, map, null, collection, false);
            try {
                if (collection3 == null) {
                    continue;
                }
            }
            catch (ServiceResolutionException serviceResolutionException) {
                throw ServiceResolutionManager.a(serviceResolutionException);
            }
            for (PublishedService publishedService2 : collection3) {
                try {
                    if (Goid.equals((Goid)publishedService2.getGoid(), (Goid)publishedService.getGoid())) continue;
                    arrayList.add(new Pair(map, (Object)publishedService2));
                }
                catch (ServiceResolutionException serviceResolutionException) {
                    throw ServiceResolutionManager.a(serviceResolutionException);
                }
            }
        }
        try {
            if (!arrayList.isEmpty()) {
                throw new NonUniqueServiceResolutionException(arrayList);
            }
        }
        catch (ServiceResolutionException serviceResolutionException) {
            throw ServiceResolutionManager.a(serviceResolutionException);
        }
    }

    public void onApplicationEvent(ApplicationEvent applicationEvent) {
        EntityClassEvent entityClassEvent;
        if (applicationEvent instanceof EntityClassEvent && ResolutionConfiguration.class.equals((entityClassEvent = (EntityClassEvent)applicationEvent).getEntityClass())) {
            this.b();
        }
    }

    public void afterPropertiesSet() throws Exception {
        this.b();
    }

    Collection<ServiceResolver> a() {
        return this.f;
    }

    private Collection<PublishedService> a(Audit audit, Map<String, Object> map, Functions.TernaryThrows<Boolean, ServiceResolver, Map<String, Object>, Collection<PublishedService>, ServiceResolutionException> ternaryThrows, Collection<PublishedService> collection, boolean bl2) throws ServiceResolutionException {
        for (ServiceResolver serviceResolver : this.d) {
            int n2;
            Set<PublishedService> set;
            block17: {
                block16: {
                    try {
                        try {
                            if (ternaryThrows == null || ((Boolean)ternaryThrows.call((Object)serviceResolver, map, collection)).booleanValue()) break block16;
                        }
                        catch (ServiceResolutionException serviceResolutionException) {
                            throw ServiceResolutionManager.a(serviceResolutionException);
                        }
                        return null;
                    }
                    catch (ServiceResolutionException serviceResolutionException) {
                        throw ServiceResolutionManager.a(serviceResolutionException);
                    }
                }
                Result result = serviceResolver.resolve(map, collection);
                try {
                    if (result == Result.NOT_APPLICABLE) {
                        continue;
                    }
                }
                catch (ServiceResolutionException serviceResolutionException) {
                    throw ServiceResolutionManager.a(serviceResolutionException);
                }
                try {
                    if (result == Result.NO_MATCH) {
                        audit.logAndAudit((AuditDetailMessage)MessageProcessingMessages.SERVICE_CACHE_FAILED_EARLY, new String[]{serviceResolver.getSimpleName()});
                        return null;
                    }
                }
                catch (ServiceResolutionException serviceResolutionException) {
                    throw ServiceResolutionManager.a(serviceResolutionException);
                }
                set = result.getMatches();
                n2 = set.size();
                try {
                    if (!bl2 || n2 != 1) break block17;
                }
                catch (ServiceResolutionException serviceResolutionException) {
                    throw ServiceResolutionManager.a(serviceResolutionException);
                }
                audit.logAndAudit((AuditDetailMessage)MessageProcessingMessages.SERVICE_CACHE_RESOLVED_EARLY, new String[]{serviceResolver.getSimpleName()});
                collection = set;
                break;
            }
            try {
                if (n2 == 0) {
                    audit.logAndAudit((AuditDetailMessage)MessageProcessingMessages.SERVICE_CACHE_FAILED_EARLY, new String[]{serviceResolver.getSimpleName()});
                    return null;
                }
            }
            catch (ServiceResolutionException serviceResolutionException) {
                throw ServiceResolutionManager.a(serviceResolutionException);
            }
            collection = set;
        }
        return collection;
    }

    private static boolean a(Message message) throws ServiceResolutionException {
        try {
            return message.isSoap();
        }
        catch (Exception exception) {
            throw new ServiceResolutionException(g[0], exception);
        }
    }

    private static Collection<PublishedService> a(Collection<PublishedService> collection) {
        collection = new HashSet<PublishedService>(collection);
        Iterator<PublishedService> iterator = collection.iterator();
        while (iterator.hasNext()) {
            PublishedService publishedService = iterator.next();
            if (!publishedService.isSoap() || publishedService.isLaxResolution()) continue;
            iterator.remove();
        }
        return collection;
    }

    private void b() {
        String[] stringArray = g;
        a.config(stringArray[1] + this.c + stringArray[7]);
        try {
            ResolutionConfiguration resolutionConfiguration = (ResolutionConfiguration)this.b.findByUniqueName(this.c);
            if (resolutionConfiguration != null) {
                for (ServiceResolver serviceResolver : this.f) {
                    serviceResolver.configure(resolutionConfiguration);
                }
            }
        }
        catch (FindException findException) {
            a.log(Level.WARNING, g[4]);
        }
    }

    /*
     * Unable to fully structure code
     */
    static {
        block10: {
            block9: {
                var5 = new String[8];
                var3_1 = 0;
                var2_2 = "3g6,&K\n\u0012fw*/ZO\u0014d> /\u000e]\u000el#&/\\\n\u000bl$=+IOF`$n\u0019ak6\"4l;!+JC\bnw</]E\n\u007f2<jME\bo>)?\\K\u0012`8 j\t\u0006H\u007f6\"?K\nHl//)Ze\be.%#{%!8\u000eF\th3'$I\n\u0014l$!&XO\u0014)4!$HC\u0001|%/>GE\b'\nHl//)Ze\be.";
                var4_3 = "3g6,&K\n\u0012fw*/ZO\u0014d> /\u000e]\u000el#&/\\\n\u000bl$=+IOF`$n\u0019ak6\"4l;!+JC\bnw</]E\n\u007f2<jME\bo>)?\\K\u0012`8 j\t\u0006H\u007f6\"?K\nHl//)Ze\be.%#{%!8\u000eF\th3'$I\n\u0014l$!&XO\u0014)4!$HC\u0001|%/>GE\b'\nHl//)Ze\be.".length();
                var1_4 = 43;
                var0_5 = -1;
lbl7:
                // 2 sources

                while (true) {
                    v0 = 61;
                    v1 = ++var0_5;
                    v2 = var2_2.substring(v1, v1 + var1_4);
                    v3 = -1;
                    break block9;
                    break;
                }
lbl13:
                // 1 sources

                while (true) {
                    var5[var3_1++] = ServiceResolutionManager.a(v0, ServiceResolutionManager.a(v2));
                    if ((var0_5 += var1_4) < var4_3) {
                        var1_4 = var2_2.charAt(var0_5);
                        ** continue;
                    }
                    var2_2 = "2\u0005LXE1\u0002;]";
                    var4_3 = "2\u0005LXE1\u0002;]".length();
                    var1_4 = 6;
                    var0_5 = -1;
lbl22:
                    // 2 sources

                    while (true) {
                        v0 = 71;
                        v4 = ++var0_5;
                        v2 = var2_2.substring(v4, v4 + var1_4);
                        v3 = 0;
                        break block9;
                        break;
                    }
                    break;
                }
lbl28:
                // 1 sources

                while (true) {
                    var5[var3_1++] = ServiceResolutionManager.a(v0, ServiceResolutionManager.a(v2));
                    if ((var0_5 += var1_4) < var4_3) {
                        var1_4 = var2_2.charAt(var0_5);
                        ** continue;
                    }
                    break block10;
                    break;
                }
            }
            switch (v3) {
                default: {
                    ** continue;
                }
                ** case 0:
lbl39:
                // 1 sources

                ** continue;
            }
        }
        ServiceResolutionManager.g = var5;
        ServiceResolutionManager.a = Logger.getLogger(ServiceResolutionManager.class.getName());
    }

    private static ServiceResolutionException a(ServiceResolutionException serviceResolutionException) {
        return serviceResolutionException;
    }

    private static char[] a(String string) {
        char[] cArray = string.toCharArray();
        if (cArray.length < 2) {
            cArray = cArray;
            cArray[0] = (char)(cArray[0] ^ 0x17);
        }
        return cArray;
    }

    /*
     * Handled impossible loop by duplicating code
     * Enabled aggressive block sorting
     */
    private static String a(int n2, char[] cArray) {
        char[] cArray2;
        block11: {
            int n3;
            int n4;
            int n5;
            block10: {
                n5 = n2;
                cArray2 = cArray;
                n4 = cArray.length;
                n3 = 0;
                if (!true) break block10;
                n4 = n4;
                if (n4 <= n3) break block11;
            }
            do {
                n5 = n5;
                cArray2 = cArray2;
                int n6 = n3;
                cArray2[n6] = (char)(cArray2[n6] ^ (n5 ^ (switch (n3 % 7) {
                    case 0 -> 91;
                    case 1 -> 52;
                    case 2 -> 106;
                    case 3 -> 115;
                    case 4 -> 119;
                    case 5 -> 19;
                    default -> 23;
                })));
                ++n3;
                n4 = n4;
            } while (n4 > n3);
        }
        return new String(cArray2).intern();
    }

    public static interface ServiceResolutionListener {
        public boolean notifyMessageBodyAccess(Message var1, Collection<PublishedService> var2);

        public void notifyMessageValidation(Message var1, PublishedService var2);
    }
}