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

package dev.metaschema.core.metapath;

import java.io.IOException;
import java.io.UncheckedIOException;
import java.net.URI;
import java.time.Clock;
import java.time.Duration;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.util.ArrayDeque;
import java.util.Collections;
import java.util.Deque;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

import dev.metaschema.core.configuration.DefaultConfiguration;
import dev.metaschema.core.configuration.IConfiguration;
import dev.metaschema.core.configuration.IMutableConfiguration;
import dev.metaschema.core.metapath.function.CalledContext;
import dev.metaschema.core.metapath.function.DateTimeFunctionException;
import dev.metaschema.core.metapath.function.IFunction;
import dev.metaschema.core.metapath.function.IFunction.FunctionProperty;
import dev.metaschema.core.metapath.item.ISequence;
import dev.metaschema.core.metapath.item.atomic.IDayTimeDurationItem;
import dev.metaschema.core.metapath.item.node.IDocumentNodeItem;
import dev.metaschema.core.model.IUriResolver;
import dev.metaschema.core.qname.IEnhancedQName;
import dev.metaschema.core.util.ObjectUtils;
import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;

// TODO: add support for in-scope namespaces
/**
 * The implementation of a Metapath
 * <a href="https://www.w3.org/TR/xpath-31/#eval_context">dynamic context</a>.
 */
public class DynamicContext {

  @NonNull
  private final Map<Integer, ISequence<?>> letVariableMap;
  @NonNull
  private final SharedState sharedState;
  @Nullable
  private final FocusContext focusContext;
  @NonNull
  private final Deque<IExpression> executionStack;

  /**
   * Construct a new dynamic context with a default static context.
   */
  public DynamicContext() {
    this(StaticContext.instance());
  }

  /**
   * Construct a new Metapath dynamic context using the provided static context.
   *
   * @param staticContext
   *          the Metapath static context
   */
  public DynamicContext(@NonNull StaticContext staticContext) {
    this.letVariableMap = new ConcurrentHashMap<>();
    this.sharedState = new SharedState(staticContext);
    this.focusContext = null;
    this.executionStack = new ArrayDeque<>();
  }

  private DynamicContext(@NonNull DynamicContext context) {
    this(context, context.focusContext);
  }

  private DynamicContext(@NonNull DynamicContext context, @Nullable FocusContext focusContext) {
    this.letVariableMap = new ConcurrentHashMap<>(context.letVariableMap);
    this.sharedState = context.sharedState;
    this.focusContext = focusContext;
    // Copy parent's stack so error traces show full call chain
    this.executionStack = new ArrayDeque<>(context.executionStack);
  }

  private static class SharedState {
    @NonNull
    private final StaticContext staticContext;
    @NonNull
    private final ZonedDateTime currentDateTime;
    @NonNull
    private final Map<URI, IDocumentNodeItem> availableDocuments;
    @NonNull
    private final Map<CalledContext, ISequence<?>> functionResultCache;
    @Nullable
    private CachingLoader documentLoader;
    @NonNull
    private final IMutableConfiguration<MetapathEvaluationFeature<?>> configuration;
    @NonNull
    private ZoneId implicitTimeZone;

    public SharedState(@NonNull StaticContext staticContext) {
      this.staticContext = staticContext;

      Clock clock = Clock.systemDefaultZone();

      this.implicitTimeZone = ObjectUtils.notNull(clock.getZone());

      this.currentDateTime = ObjectUtils.notNull(ZonedDateTime.now(clock));
      this.availableDocuments = new ConcurrentHashMap<>();
      this.functionResultCache = new ConcurrentHashMap<>();
      this.configuration = new DefaultConfiguration<>();
      this.configuration.enableFeature(MetapathEvaluationFeature.METAPATH_EVALUATE_PREDICATES);
    }
  }

  /**
   * Generate a new dynamic context that is a copy of this dynamic context.
   * <p>
   * This method can be used to create a new sub-context where changes can be made
   * without affecting this context. This is useful for setting information that
   * is only used in a limited evaluation sub-scope, such as for handling variable
   * assignment.
   * <p>
   * The focus context from this context is preserved in the new sub-context,
   * allowing nested expressions to access the enclosing focus (e.g., for
   * {@code position()} and {@code last()} calls within variable binding scopes).
   *
   * @return a new dynamic context
   */
  @NonNull
  public DynamicContext subContext() {
    return new DynamicContext(this);
  }

  /**
   * Generate a new dynamic context with the specified focus context.
   * <p>
   * This method is used by predicate expressions to establish a new focus for
   * evaluating predicates. The focus context provides the information needed by
   * {@code fn:position()} and {@code fn:last()}.
   *
   * @param focusContext
   *          the focus context for the new sub-context
   * @return a new dynamic context with the specified focus context
   */
  @NonNull
  public DynamicContext subContext(@NonNull FocusContext focusContext) {
    return new DynamicContext(this, focusContext);
  }

  /**
   * Get the focus context for this dynamic context.
   * <p>
   * The focus context contains the context item, position, and size as defined in
   * the <a href="https://www.w3.org/TR/xpath-31/#eval_context">XPath 3.1
   * evaluation context</a>.
   *
   * @return the focus context, or {@code null} if no focus context is established
   */
  @Nullable
  public FocusContext getFocusContext() {
    return focusContext;
  }

  /**
   * Get the static context associated with this dynamic context.
   *
   * @return the associated static context
   */
  @NonNull
  public StaticContext getStaticContext() {
    return sharedState.staticContext;
  }

  /**
   * Get the default time zone used for evaluation.
   *
   * @return the time zone identifier object
   */
  @NonNull
  public ZoneId getImplicitTimeZone() {
    return sharedState.implicitTimeZone;
  }

  /**
   * Get the default time zone used for evaluation.
   *
   * @return the time zone identifier object
   */
  @NonNull
  public IDayTimeDurationItem getImplicitTimeZoneAsDayTimeDuration() {
    LocalDateTime referenceDateTime = MetapathConstants.REFERENCE_DATE_TIME.asLocalDateTime();
    ZonedDateTime reference = referenceDateTime.atZone(getImplicitTimeZone());
    ZonedDateTime referenceZ = referenceDateTime.atZone(ZoneOffset.UTC);

    return IDayTimeDurationItem.valueOf(ObjectUtils.notNull(
        Duration.between(
            reference,
            referenceZ)));
  }

  /**
   * Set the implicit timezone to the provided value.
   * <p>
   * Note: This value should only be adjusted when the context is first created.
   * Once the context is used, this value is expected to be stable.
   *
   * @param timezone
   *          the timezone to use
   */
  public void setImplicitTimeZone(@NonNull ZoneId timezone) {
    sharedState.implicitTimeZone = timezone;
  }

  /**
   * Set the implicit timezone to the provided value.
   * <p>
   * Note: This value should only be adjusted when the context is first created.
   * Once the context is used, this value is expected to be stable.
   *
   * @param offset
   *          the offset which must be &gt;= -PT14H and &lt;= PT13H
   * @throws DateTimeFunctionException
   *           with the code
   *           {@link DateTimeFunctionException#INVALID_TIME_ZONE_VALUE_ERROR} if
   *           the offset is &lt; -PT14H or &gt; PT14H
   */
  public void setImplicitTimeZone(@NonNull IDayTimeDurationItem offset) {
    setImplicitTimeZone(offset.asZoneOffset());
  }

  /**
   * Get the current date and time.
   *
   * @return the current date and time
   */
  @NonNull
  public ZonedDateTime getCurrentDateTime() {
    return sharedState.currentDateTime;
  }

  /**
   * Get the mapping of loaded documents from the document URI to the document
   * node.
   *
   * @return the map of document URIs to document nodes
   */
  @SuppressWarnings("null")
  @NonNull
  public Map<URI, IDocumentNodeItem> getAvailableDocuments() {
    return Collections.unmodifiableMap(sharedState.availableDocuments);
  }

  /**
   * Get the document loader assigned to this dynamic context.
   *
   * @return the loader
   * @throws ContextAbsentDynamicMetapathException
   *           if a document loader is not configured for this dynamic context
   */
  @NonNull
  public IDocumentLoader getDocumentLoader() {
    IDocumentLoader retval = sharedState.documentLoader;
    if (retval == null) {
      throw new UnsupportedOperationException(
          "No document loader configured for the dynamic context. Use setDocumentLoader(loader) to confgure one.");
    }
    return retval;
  }

  /**
   * Assign a document loader to this dynamic context.
   *
   * @param documentLoader
   *          the document loader to assign
   */
  public void setDocumentLoader(@NonNull IDocumentLoader documentLoader) {
    this.sharedState.documentLoader = new CachingLoader(documentLoader);
  }

  /**
   * Get the cached function call result for evaluating a function that has the
   * property {@link FunctionProperty#DETERMINISTIC}.
   *
   * @param callingContext
   *          the function calling context information that distinguishes the call
   *          from any other call
   * @return the cached result sequence for the function call
   */
  @Nullable
  public ISequence<?> getCachedResult(@NonNull CalledContext callingContext) {
    return sharedState.functionResultCache.get(callingContext);
  }

  /**
   * Cache a function call result for a that has the property
   * {@link FunctionProperty#DETERMINISTIC}.
   *
   * @param callingContext
   *          the calling context information that distinguishes the call from any
   *          other call
   * @param result
   *          the function call result
   */
  public void cacheResult(@NonNull CalledContext callingContext, @NonNull ISequence<?> result) {
    ISequence<?> old = sharedState.functionResultCache.put(callingContext, result);
    assert old == null;
  }

  /**
   * Used to disable the evaluation of predicate expressions during Metapath
   * evaluation.
   * <p>
   * This can be useful for determining the potential targets identified by a
   * Metapath expression as a partial evaluation, without evaluating that these
   * targets match the predicate.
   *
   * @return this dynamic context
   */
  @NonNull
  public DynamicContext disablePredicateEvaluation() {
    this.sharedState.configuration.disableFeature(MetapathEvaluationFeature.METAPATH_EVALUATE_PREDICATES);
    return this;
  }

  /**
   * Used to enable the evaluation of predicate expressions during Metapath
   * evaluation.
   * <p>
   * This is the default behavior if unchanged.
   *
   * @return this dynamic context
   */
  @NonNull
  public DynamicContext enablePredicateEvaluation() {
    this.sharedState.configuration.enableFeature(MetapathEvaluationFeature.METAPATH_EVALUATE_PREDICATES);
    return this;
  }

  /**
   * Get the Metapath evaluation configuration.
   *
   * @return the configuration
   */
  @NonNull
  public IConfiguration<MetapathEvaluationFeature<?>> getConfiguration() {
    return sharedState.configuration;
  }

  /**
   * Get the sequence value assigned to a let variable with the provided qualified
   * name.
   *
   * @param name
   *          the variable qualified name
   * @return the non-null variable value
   * @throws DynamicMetapathException
   *           of the variable has not been assigned or if the variable value is
   *           {@code null}
   */
  @NonNull
  public ISequence<?> getVariableValue(@NonNull IEnhancedQName name) {
    ISequence<?> retval = letVariableMap.get(name.getIndexPosition());
    if (retval == null) {
      throw new StaticMetapathException(
          StaticMetapathException.NOT_DEFINED,
          String.format("Variable '%s' not defined in the dynamic context.", name))
              .registerEvaluationContext(this);
    }
    return retval;
  }

  /**
   * Get the function with the provided name and arity.
   *
   * @param name
   *          the requested function's qualified name
   * @param arity
   *          the number of arguments in the requested function
   * @return the function
   * @throws StaticMetapathException
   *           with the code {@link StaticMetapathException#NO_FUNCTION_MATCH} if
   *           a matching function was not found
   */
  @NonNull
  public IFunction lookupFunction(@NonNull IEnhancedQName name, int arity) {
    return getStaticContext().lookupFunction(name, arity);
  }

  /**
   * Bind the variable {@code name} to the sequence {@code value}.
   *
   * @param name
   *          the name of the variable to bind
   * @param boundValue
   *          the value to bind to the variable
   * @return this dynamic context
   */
  @NonNull
  public DynamicContext bindVariableValue(@NonNull IEnhancedQName name, @NonNull ISequence<?> boundValue) {
    letVariableMap.put(name.getIndexPosition(), boundValue);
    return this;
  }

  /**
   * Push the current expression under evaluation to the execution queue.
   *
   * @param expression
   *          the expression to push
   */
  public void pushExecutionStack(@NonNull IExpression expression) {
    this.executionStack.push(expression);
  }

  /**
   * Pop the expression that was under evaluation from the execution queue.
   *
   * @param expression
   *          the expected expression to be popped
   */
  public void popExecutionStack(@NonNull IExpression expression) {
    IExpression popped = this.executionStack.pop();
    if (!expression.equals(popped)) {
      throw new IllegalStateException("Popped expression does not match expected expression");
    }
  }

  /**
   * Return a copy of the current execution stack.
   *
   * @return the execution stack
   */
  @NonNull
  public Deque<IExpression> getExecutionStack() {
    return new ArrayDeque<>(this.executionStack);
  }

  /**
   * Provides a formatted stack trace.
   *
   * @return the formatted stack trace
   */
  @NonNull
  public String formatExecutionStackTrace() {
    return ObjectUtils.notNull(getExecutionStack().stream()
        .map(IExpression::toCSTString)
        .collect(Collectors.joining("\n-> ")));
  }

  private class CachingLoader implements IDocumentLoader {
    @NonNull
    private final IDocumentLoader proxy;

    public CachingLoader(@NonNull IDocumentLoader proxy) {
      this.proxy = proxy;
    }

    @Override
    public IUriResolver getUriResolver() {
      return new ContextUriResolver();
    }

    @Override
    public void setUriResolver(@NonNull IUriResolver resolver) {
      // we delegate to the document loader proxy, so the resolver should be set there
      throw new UnsupportedOperationException("Set the resolver on the proxy");
    }

    @NonNull
    protected IDocumentLoader getProxiedDocumentLoader() {
      return proxy;
    }

    @Override
    public IDocumentNodeItem loadAsNodeItem(URI uri) throws IOException {
      URI normalizedUri = uri.normalize();
      try {
        return sharedState.availableDocuments.computeIfAbsent(normalizedUri, key -> {
          try {
            return getProxiedDocumentLoader().loadAsNodeItem(key);
          } catch (IOException e) {
            throw new UncheckedIOException(e);
          }
        });
      } catch (UncheckedIOException e) {
        throw e.getCause();
      }
    }

    public class ContextUriResolver implements IUriResolver {

      /**
       * {@inheritDoc}
       * <p>
       * This method first resolves the provided URI against the static context's base
       * URI.
       */
      @Override
      public URI resolve(URI uri) {
        URI baseUri = getStaticContext().getBaseUri();

        URI resolvedUri;
        if (baseUri == null) {
          resolvedUri = uri;
        } else {
          resolvedUri = ObjectUtils.notNull(baseUri.resolve(uri));
        }

        IUriResolver resolver = getProxiedDocumentLoader().getUriResolver();
        return resolver == null ? resolvedUri : resolver.resolve(resolvedUri);
      }
    }
  }
}