/*
 * SPDX-FileCopyrightText: none
 * SPDX-License-Identifier: CC0-1.0
 */

package dev.metaschema.core.qname;

import java.net.URI;
import java.util.Comparator;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

import dev.metaschema.core.util.ObjectUtils;
import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;
import nl.talsmasoftware.lazy4j.Lazy;

/**
 * Provides a cache for managing commonly reused qualified names, represented
 * using the {@link IEnhancedQName} interface.
 * <p>
 * The cache operations provided by this cache are thread safe.
 * <p>
 * A unique integer index value is assigned for each namespace and localname
 * pair. This index value can be used to retrieve the qualified name using the
 * {@link #get(int)} method. This allows the index value to be used in place of
 * the actual qualified name.
 * <p>
 * The {@link IEnhancedQName#getIndexPosition()} method can be used to get the
 * index value of a given qualified name.
 */
// FIXME: Consider the implications of this cache in a long running process.
// Using a global shared instance may result in a very large cache.
public final class QNameCache {

  private static final Comparator<IEnhancedQName> COMPARATOR
      = Comparator.comparingInt(IEnhancedQName::getIndexPosition);

  @NonNull
  private static final Lazy<QNameCache> INSTANCE = ObjectUtils.notNull(Lazy.of(QNameCache::new));

  @NonNull
  private final NamespaceCache namespaceCache;

  private final Map<Integer, QNameRecord> indexToQName = new ConcurrentHashMap<>();
  private final Map<Integer, Map<String, QNameRecord>> nsIndexToLocalNameToIndex = new ConcurrentHashMap<>();

  /**
   * The next available qualified-name index position.
   */
  private final AtomicInteger indexCounter = new AtomicInteger();

  /**
   * Get the singleton qualified name cache.
   *
   * @return the singleton instance
   */
  @NonNull
  public static QNameCache instance() {
    return ObjectUtils.notNull(INSTANCE.get());
  }

  private QNameCache() {
    // disable construction
    this(NamespaceCache.instance());
  }

  private QNameCache(@NonNull NamespaceCache nsCache) {
    this.namespaceCache = nsCache;
  }

  @NonNull
  private NamespaceCache getNamespaceCache() {
    return namespaceCache;
  }

  /**
   * Get a cached qualified name based on the provided namespace and name.
   * <p>
   * The qualified name will be added to the cache if it doesn't already exist.
   *
   * @param namespace
   *          the namespace for the new qualified name
   * @param name
   *          the local name for the new qualified name
   * @return the new cached qualified name or the existing cached name if it
   *         already exists in the cache
   */
  @NonNull
  public IEnhancedQName cachedQNameFor(@NonNull String namespace, @NonNull String name) {
    int namespacePosition = namespaceCache.indexOf(namespace);

    Map<String, QNameRecord> namespaceNames = nsIndexToLocalNameToIndex
        .computeIfAbsent(namespacePosition, key -> new ConcurrentHashMap<>());

    return ObjectUtils.notNull(namespaceNames.computeIfAbsent(name, key -> {
      assert key != null;
      QNameRecord record = new QNameRecord(namespacePosition, namespace, key);
      indexToQName.put(record.getIndexPosition(), record);
      return record;
    }));
  }

  /**
   * Get an existing qualified name from the cache based on the provided namespace
   * and name.
   *
   * @param namespace
   *          the namespace for the qualified name
   * @param name
   *          the local name for the qualified name
   * @return an optional containing the cached qualified name or a {@code null}
   *         value if the name does not exist in the cache
   */
  @NonNull
  Optional<IEnhancedQName> get(@NonNull String namespace, @NonNull String name) {
    Optional<Integer> nsPosition = namespaceCache.get(namespace);
    if (!nsPosition.isPresent()) {
      throw new IllegalArgumentException(
          String.format("The namespace '%s' is not recognized.", namespace));
    }

    Map<String, QNameRecord> namespaceNames = nsIndexToLocalNameToIndex.get(nsPosition.get());
    return ObjectUtils.notNull(Optional.ofNullable(
        namespaceNames == null
            ? null
            : namespaceNames.get(name)));
  }

  /**
   * Get an existing qualified name from the cache that is assigned to the
   * provided index value.
   * <p>
   * Note: There is a chance that an entry associated index value may not exist at
   * first, but subsequent calls may find an associated value in the future if one
   * is created with that value.
   *
   * @param index
   *          the index value for the qualified name
   * @return the cached qualified name or {@code null} if a cache entry does not
   *         exist for the index value
   */
  @Nullable
  public IEnhancedQName get(int index) {
    return indexToQName.get(index);
  }

  private final class QNameRecord implements IEnhancedQName {
    private final int qnameIndexPosition;
    private final int namespaceIndexPosition;
    @NonNull
    private final String namespace;
    @NonNull
    private final String localName;

    public QNameRecord(
        int namespaceIndexPosition,
        @NonNull String namespace,
        @NonNull String localName) {
      this.qnameIndexPosition = indexCounter.getAndIncrement();
      this.namespaceIndexPosition = namespaceIndexPosition;
      this.namespace = namespace;
      this.localName = localName;
    }

    @Override
    public int getIndexPosition() {
      return qnameIndexPosition;
    }

    @Override
    public URI getNamespaceAsUri() {
      return ObjectUtils.notNull(getNamespaceCache().getAsURI(namespaceIndexPosition).get());
    }

    @Override
    public String getNamespace() {
      return namespace;
    }

    @Override
    public String getLocalName() {
      return localName;
    }

    @Override
    public int hashCode() {
      return Objects.hashCode(qnameIndexPosition);
    }

    @Override
    public boolean equals(Object obj) {
      if (this == obj) {
        return true;
      }
      if (obj == null || getClass() != obj.getClass()) {
        return false;
      }
      QNameRecord other = (QNameRecord) obj;
      return Objects.equals(qnameIndexPosition, other.getIndexPosition());
    }

    @Override
    public int compareTo(IEnhancedQName other) {
      return COMPARATOR.compare(this, other);
    }

    @Override
    public String toString() {
      return toEQName();
    }
  }

}