/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  com.l7tech.gateway.common.audit.AuditFactory
 *  com.l7tech.gateway.common.service.PublishedService
 *  com.l7tech.gateway.common.transport.ResolutionConfiguration
 *  com.l7tech.message.Message
 */
package com.l7tech.server.service.resolution;

import com.l7tech.gateway.common.audit.AuditFactory;
import com.l7tech.gateway.common.service.PublishedService;
import com.l7tech.gateway.common.transport.ResolutionConfiguration;
import com.l7tech.message.Message;
import com.l7tech.server.service.resolution.Result;
import com.l7tech.server.service.resolution.ServiceResolutionException;
import com.l7tech.server.service.resolution.ServiceResolver;
import com.l7tech.server.service.resolution.UriResolver;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;

public class RequirePathResolver
extends ServiceResolver<Void> {
    private final AtomicBoolean b = new AtomicBoolean(false);

    public RequirePathResolver(AuditFactory auditFactory) {
        super(auditFactory);
    }

    @Override
    public void configure(ResolutionConfiguration resolutionConfiguration) {
        super.configure(resolutionConfiguration);
        this.b.set(resolutionConfiguration.isPathRequired());
    }

    @Override
    public Result resolve(Map<String, Object> map, Collection<PublishedService> collection) throws ServiceResolutionException {
        try {
            if (!map.containsKey(this.PROP_VALUE)) {
                return Result.NOT_APPLICABLE;
            }
        }
        catch (ServiceResolutionException serviceResolutionException) {
            throw RequirePathResolver.a(serviceResolutionException);
        }
        HashSet<PublishedService> hashSet = new HashSet<PublishedService>();
        for (PublishedService publishedService : collection) {
            try {
                if (publishedService.getRoutingUri() == null) continue;
                hashSet.add(publishedService);
            }
            catch (ServiceResolutionException serviceResolutionException) {
                throw RequirePathResolver.a(serviceResolutionException);
            }
        }
        return new Result(hashSet);
    }

    @Override
    public void populateResolutionParameters(Message message, Map<String, Object> map) throws ServiceResolutionException {
        try {
            if (this.a(message)) {
                map.put(this.PROP_VALUE, null);
            }
        }
        catch (ServiceResolutionException serviceResolutionException) {
            throw RequirePathResolver.a(serviceResolutionException);
        }
    }

    @Override
    public boolean usesMessageContent() {
        return false;
    }

    @Override
    protected List<Void> buildTargetValues(PublishedService publishedService) throws ServiceResolutionException {
        return Collections.emptyList();
    }

    @Override
    protected void updateServiceValues(PublishedService publishedService, List<Void> list) {
    }

    private boolean a(Message message) {
        return this.b.get() && UriResolver.canResolveByURI(message);
    }

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