package at.gv.egiz.eaaf.modules.pvp2.impl.metadata;


import java.time.Instant;

import org.opensaml.core.criterion.EntityIdCriterion;
import org.opensaml.saml.metadata.resolver.RefreshableMetadataResolver;
import org.opensaml.saml.metadata.resolver.filter.MetadataFilter;
import org.opensaml.saml.metadata.resolver.impl.AbstractMetadataResolver;
import org.opensaml.saml.saml2.metadata.EntityDescriptor;

import at.gv.egiz.eaaf.modules.pvp2.api.metadata.IPvp2MetadataProvider;
import at.gv.egiz.eaaf.modules.pvp2.api.metadata.IRefreshableMetadataProvider;
import lombok.extern.slf4j.Slf4j;
import net.shibboleth.utilities.java.support.resolver.CriteriaSet;
import net.shibboleth.utilities.java.support.resolver.ResolverException;

@Slf4j
public class PvpMetadataResolverAdapter implements IPvp2MetadataProvider, IRefreshableMetadataProvider {

  private final RefreshableMetadataResolver internalProvider;

  public PvpMetadataResolverAdapter(RefreshableMetadataResolver provider) {
    this.internalProvider = provider;
  }

  @Override
  public void refresh() throws ResolverException {
    internalProvider.refresh();

  }

  @Override
  public Instant getLastRefresh() {
    return internalProvider.getLastRefresh();

  }

  @Override
  public Instant getLastUpdate() {
    return internalProvider.getLastUpdate();
  }

  @Override
  public boolean isRequireValidMetadata() {
    return internalProvider.isRequireValidMetadata();

  }

  @Override
  public void setRequireValidMetadata(boolean requireValidMetadata) {
    internalProvider.setRequireValidMetadata(requireValidMetadata);

  }

  @Override
  public MetadataFilter getMetadataFilter() {
    return internalProvider.getMetadataFilter();

  }

  @Override
  public void setMetadataFilter(MetadataFilter newFilter) {
    internalProvider.setMetadataFilter(newFilter);

  }

  @Override
  public Iterable<EntityDescriptor> resolve(CriteriaSet criteria) throws ResolverException {
    return internalProvider.resolve(criteria);
  }

  @Override
  public EntityDescriptor resolveSingle(CriteriaSet criteria) throws ResolverException {
    return internalProvider.resolveSingle(criteria);

  }

  @Override
  public String getId() {
    return internalProvider.getId();
  }

  @Override
  public EntityDescriptor getEntityDescriptor(String entityId) throws ResolverException {
    final CriteriaSet criteria = new CriteriaSet();
    criteria.add(new EntityIdCriterion(entityId));
    return internalProvider.resolveSingle(criteria);

  }

  @Override
  public Instant getLastSuccessfulRefresh() {
    return internalProvider.getLastSuccessfulRefresh();
  }

  @Override
  public Boolean wasLastRefreshSuccess() {
    return internalProvider.wasLastRefreshSuccess();
  }

  @Override
  public boolean refreshMetadataProvider(String entityID) {
    try {
      log.trace("Refeshing metadata-provider: {} ... ", getId());
      internalProvider.refresh();
      return true;

    } catch (final ResolverException e) {
      log.warn("Refreshing of metadata-provider: {} failed. Reason: {}",
          getId(), e.getMessage());
      return false;

    }
  }

  @Override
  public void doDestroy() {
    if (internalProvider instanceof AbstractMetadataResolver) {
      ((AbstractMetadataResolver) internalProvider).destroy();

    } else {
      log.info("MetadataResolver: {} does not support destroying",
          internalProvider.getClass().getName());

    }
  }

  public Throwable getLastFailureCause() {
    return internalProvider.getLastFailureCause();
    
  }

}