/*
 * Copyright (c) 2013, the Dart project authors.
 * 
 * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 * 
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.dart.engine.internal.cache;

import com.google.dart.engine.context.AnalysisException;
import com.google.dart.engine.element.HtmlElement;
import com.google.dart.engine.element.angular.AngularComponentElement;
import com.google.dart.engine.error.AnalysisError;
import com.google.dart.engine.html.ast.HtmlUnit;
import com.google.dart.engine.internal.element.angular.AngularApplication;
import com.google.dart.engine.source.Source;
import com.google.dart.engine.source.SourceKind;

import java.util.ArrayList;

/**
 * Instances of the class {@code HtmlEntryImpl} implement an {@link HtmlEntry}.
 * 
 * @coverage dart.engine
 */
public class HtmlEntryImpl extends SourceEntryImpl implements HtmlEntry {
  /**
   * The state of the cached parsed (but not resolved) HTML unit.
   */
  private CacheState parsedUnitState = CacheState.INVALID;

  /**
   * The parsed HTML unit, or {@code null} if the parsed HTML unit is not currently cached.
   */
  private HtmlUnit parsedUnit;

  /**
   * The state of the cached resolved HTML unit.
   */
  private CacheState resolvedUnitState = CacheState.INVALID;

  /**
   * The resolved HTML unit, or {@code null} if the resolved HTML unit is not currently cached.
   */
  private HtmlUnit resolvedUnit;

  /**
   * The state of the cached parse errors.
   */
  private CacheState parseErrorsState = CacheState.INVALID;

  /**
   * The errors produced while scanning and parsing the HTML, or {@code null} if the errors are not
   * currently cached.
   */
  private AnalysisError[] parseErrors = AnalysisError.NO_ERRORS;

  /**
   * The state of the cached resolution errors.
   */
  private CacheState resolutionErrorsState = CacheState.INVALID;

  /**
   * The errors produced while resolving the HTML, or {@code null} if the errors are not currently
   * cached.
   */
  private AnalysisError[] resolutionErrors = AnalysisError.NO_ERRORS;

  /**
   * The state of the cached list of referenced libraries.
   */
  private CacheState referencedLibrariesState = CacheState.INVALID;

  /**
   * The list of libraries referenced in the HTML, or {@code null} if the list is not currently
   * cached. Note that this list does not include libraries defined directly within the HTML file.
   */
  private Source[] referencedLibraries = Source.EMPTY_ARRAY;

  /**
   * The state of the cached HTML element.
   */
  private CacheState elementState = CacheState.INVALID;

  /**
   * The element representing the HTML file, or {@code null} if the element is not currently cached.
   */
  private HtmlElement element;

  /**
   * The state of the {@link #angularApplication}.
   */
  private CacheState angularApplicationState = CacheState.VALID;

  /**
   * Information about the Angular Application this unit is used in.
   */
  private AngularApplication angularApplication;

  /**
   * The state of the {@link #angularEntry}.
   */
  private CacheState angularEntryState = CacheState.INVALID;

  /**
   * Information about the Angular Application this unit is entry point for.
   */
  private AngularApplication angularEntry = null;

  /**
   * The state of the {@link #angularComponent}.
   */
  private CacheState angularComponentState = CacheState.VALID;

  /**
   * Information about the {@link AngularComponentElement} this unit is used as template for.
   */
  private AngularComponentElement angularComponent = null;

  /**
   * The state of the Angular resolution errors.
   */
  private CacheState angularErrorsState = CacheState.INVALID;

  /**
   * The hints produced while performing Angular resolution, or an empty array if the error are not
   * currently cached.
   */
  private AnalysisError[] angularErrors = AnalysisError.NO_ERRORS;

  /**
   * The state of the cached hints.
   */
  private CacheState hintsState = CacheState.INVALID;

  /**
   * The hints produced while auditing the compilation unit, or an empty array if the hints are not
   * currently cached.
   */
  private AnalysisError[] hints = AnalysisError.NO_ERRORS;

  /**
   * The state of the Polymer elements.
   */
  private CacheState polymerBuildErrorsState = CacheState.INVALID;

  /**
   * The hints produced while performing Polymer HTML elements building, or an empty array if the
   * error are not currently cached.
   */
  private AnalysisError[] polymerBuildErrors = AnalysisError.NO_ERRORS;

  /**
   * The state of the Polymer resolution errors.
   */
  private CacheState polymerResolutionErrorsState = CacheState.INVALID;

  /**
   * The hints produced while performing Polymer resolution, or an empty array if the error are not
   * currently cached.
   */
  private AnalysisError[] polymerResolutionErrors = AnalysisError.NO_ERRORS;

  /**
   * Initialize a newly created cache entry to be empty.
   */
  public HtmlEntryImpl() {
    super();
  }

  /**
   * Flush any AST structures being maintained by this entry.
   */
  public void flushAstStructures() {
    if (parsedUnitState == CacheState.VALID) {
      parsedUnitState = CacheState.FLUSHED;
      parsedUnit = null;
    }
    if (resolvedUnitState == CacheState.VALID) {
      resolvedUnitState = CacheState.FLUSHED;
      resolvedUnit = null;
    }
    if (angularEntryState == CacheState.VALID) {
      angularEntryState = CacheState.FLUSHED;
    }
    if (angularErrorsState == CacheState.VALID) {
      angularErrorsState = CacheState.FLUSHED;
    }
  }

  @Override
  public AnalysisError[] getAllErrors() {
    ArrayList<AnalysisError> errors = new ArrayList<AnalysisError>();
    if (parseErrors != null) {
      for (AnalysisError error : parseErrors) {
        errors.add(error);
      }
    }
    if (resolutionErrors != null) {
      for (AnalysisError error : resolutionErrors) {
        errors.add(error);
      }
    }
    if (angularErrors != null) {
      for (AnalysisError error : angularErrors) {
        errors.add(error);
      }
    }
    if (hints != null) {
      for (AnalysisError error : hints) {
        errors.add(error);
      }
    }
    if (polymerBuildErrors != null) {
      for (AnalysisError error : polymerBuildErrors) {
        errors.add(error);
      }
    }
    if (polymerResolutionErrors != null) {
      for (AnalysisError error : polymerResolutionErrors) {
        errors.add(error);
      }
    }
    if (errors.size() == 0) {
      return AnalysisError.NO_ERRORS;
    }
    return errors.toArray(new AnalysisError[errors.size()]);
  }

  @Override
  public HtmlUnit getAnyParsedUnit() {
    if (parsedUnitState == CacheState.VALID) {
//      parsedUnitAccessed = true;
      return parsedUnit;
    }
    if (resolvedUnitState == CacheState.VALID) {
//      resovledUnitAccessed = true;
      return resolvedUnit;
    }
    return null;
  }

  @Override
  public SourceKind getKind() {
    return SourceKind.HTML;
  }

  @Override
  public CacheState getState(DataDescriptor<?> descriptor) {
    if (descriptor == ANGULAR_APPLICATION) {
      return angularApplicationState;
    } else if (descriptor == ANGULAR_COMPONENT) {
      return angularComponentState;
    } else if (descriptor == ANGULAR_ENTRY) {
      return angularEntryState;
    } else if (descriptor == ANGULAR_ERRORS) {
      return angularErrorsState;
    } else if (descriptor == ELEMENT) {
      return elementState;
    } else if (descriptor == PARSE_ERRORS) {
      return parseErrorsState;
    } else if (descriptor == PARSED_UNIT) {
      return parsedUnitState;
    } else if (descriptor == RESOLVED_UNIT) {
      return resolvedUnitState;
    } else if (descriptor == REFERENCED_LIBRARIES) {
      return referencedLibrariesState;
    } else if (descriptor == RESOLUTION_ERRORS) {
      return resolutionErrorsState;
    } else if (descriptor == HINTS) {
      return hintsState;
    } else if (descriptor == POLYMER_BUILD_ERRORS) {
      return polymerBuildErrorsState;
    } else if (descriptor == POLYMER_RESOLUTION_ERRORS) {
      return polymerResolutionErrorsState;
    }
    return super.getState(descriptor);
  }

  @Override
  @SuppressWarnings("unchecked")
  public <E> E getValue(DataDescriptor<E> descriptor) {
    if (descriptor == ANGULAR_APPLICATION) {
      return (E) angularApplication;
    } else if (descriptor == ANGULAR_COMPONENT) {
      return (E) angularComponent;
    } else if (descriptor == ANGULAR_ENTRY) {
      return (E) angularEntry;
    } else if (descriptor == ANGULAR_ERRORS) {
      return (E) angularErrors;
    } else if (descriptor == ELEMENT) {
      return (E) element;
    } else if (descriptor == PARSE_ERRORS) {
      return (E) parseErrors;
    } else if (descriptor == PARSED_UNIT) {
      return (E) parsedUnit;
    } else if (descriptor == RESOLVED_UNIT) {
      return (E) resolvedUnit;
    } else if (descriptor == REFERENCED_LIBRARIES) {
      return (E) referencedLibraries;
    } else if (descriptor == RESOLUTION_ERRORS) {
      return (E) resolutionErrors;
    } else if (descriptor == HINTS) {
      return (E) hints;
    } else if (descriptor == POLYMER_BUILD_ERRORS) {
      return (E) polymerBuildErrors;
    } else if (descriptor == POLYMER_RESOLUTION_ERRORS) {
      return (E) polymerResolutionErrors;
    }
    return super.getValue(descriptor);
  }

  @Override
  public HtmlEntryImpl getWritableCopy() {
    HtmlEntryImpl copy = new HtmlEntryImpl();
    copy.copyFrom(this);
    return copy;
  }

  @Override
  public void invalidateAllInformation() {
    super.invalidateAllInformation();

    parseErrors = AnalysisError.NO_ERRORS;
    parseErrorsState = CacheState.INVALID;
    parsedUnit = null;
    parsedUnitState = CacheState.INVALID;
    resolvedUnit = null;
    resolvedUnitState = CacheState.INVALID;

    invalidateAllResolutionInformation(true);
  }

  /**
   * Invalidate all of the resolution information associated with the HTML file.
   * 
   * @param invalidateUris true if the cached results of converting URIs to source files should also
   *          be invalidated.
   */
  public void invalidateAllResolutionInformation(boolean invalidateUris) {
    angularEntry = null;
    angularEntryState = CacheState.INVALID;

    angularErrors = AnalysisError.NO_ERRORS;
    angularErrorsState = CacheState.INVALID;

    polymerBuildErrors = AnalysisError.NO_ERRORS;
    polymerBuildErrorsState = CacheState.INVALID;

    polymerResolutionErrors = AnalysisError.NO_ERRORS;
    polymerResolutionErrorsState = CacheState.INVALID;

    element = null;
    elementState = CacheState.INVALID;

    resolutionErrors = AnalysisError.NO_ERRORS;
    resolutionErrorsState = CacheState.INVALID;

    hints = AnalysisError.NO_ERRORS;
    hintsState = CacheState.INVALID;

    if (invalidateUris) {
      referencedLibraries = Source.EMPTY_ARRAY;
      referencedLibrariesState = CacheState.INVALID;
    }
  }

  @Override
  public void recordContentError(AnalysisException exception) {
    super.recordContentError(exception);
    recordParseError(exception);
  }

  /**
   * Record that an error was encountered while attempting to parse the source associated with this
   * entry.
   * 
   * @param exception the exception that shows where the error occurred
   */
  public void recordParseError(AnalysisException exception) {
    // If the scanning and parsing of HTML are separated, the following line can be removed.
    recordScanError(exception);

    parseErrors = AnalysisError.NO_ERRORS;
    parseErrorsState = CacheState.ERROR;

    parsedUnit = null;
    parsedUnitState = CacheState.ERROR;

    referencedLibraries = Source.EMPTY_ARRAY;
    referencedLibrariesState = CacheState.ERROR;

    recordResolutionError(exception);
  }

  /**
   * Record that an error was encountered while attempting to resolve the source associated with
   * this entry.
   * 
   * @param exception the exception that shows where the error occurred
   */
  public void recordResolutionError(AnalysisException exception) {
    setException(exception);

    angularErrors = AnalysisError.NO_ERRORS;
    angularErrorsState = CacheState.ERROR;

    resolvedUnit = null;
    resolvedUnitState = CacheState.ERROR;

    element = null;
    elementState = CacheState.ERROR;

    resolutionErrors = AnalysisError.NO_ERRORS;
    resolutionErrorsState = CacheState.ERROR;

    hints = AnalysisError.NO_ERRORS;
    hintsState = CacheState.ERROR;

    polymerBuildErrors = AnalysisError.NO_ERRORS;
    polymerBuildErrorsState = CacheState.ERROR;

    polymerResolutionErrors = AnalysisError.NO_ERRORS;
    polymerResolutionErrorsState = CacheState.ERROR;
  }

  @Override
  public void setState(DataDescriptor<?> descriptor, CacheState state) {
    if (descriptor == ANGULAR_APPLICATION) {
      angularApplication = updatedValue(state, angularApplication, null);
      angularApplicationState = state;
    } else if (descriptor == ANGULAR_COMPONENT) {
      angularComponent = updatedValue(state, angularComponent, null);
      angularComponentState = state;
    } else if (descriptor == ANGULAR_ENTRY) {
      angularEntry = updatedValue(state, angularEntry, null);
      angularEntryState = state;
    } else if (descriptor == ANGULAR_ERRORS) {
      angularErrors = updatedValue(state, angularErrors, null);
      angularErrorsState = state;
    } else if (descriptor == ELEMENT) {
      element = updatedValue(state, element, null);
      elementState = state;
    } else if (descriptor == PARSE_ERRORS) {
      parseErrors = updatedValue(state, parseErrors, null);
      parseErrorsState = state;
    } else if (descriptor == PARSED_UNIT) {
      parsedUnit = updatedValue(state, parsedUnit, null);
      parsedUnitState = state;
    } else if (descriptor == RESOLVED_UNIT) {
      resolvedUnit = updatedValue(state, resolvedUnit, null);
      resolvedUnitState = state;
    } else if (descriptor == REFERENCED_LIBRARIES) {
      referencedLibraries = updatedValue(state, referencedLibraries, Source.EMPTY_ARRAY);
      referencedLibrariesState = state;
    } else if (descriptor == RESOLUTION_ERRORS) {
      resolutionErrors = updatedValue(state, resolutionErrors, AnalysisError.NO_ERRORS);
      resolutionErrorsState = state;
    } else if (descriptor == HINTS) {
      hints = updatedValue(state, hints, AnalysisError.NO_ERRORS);
      hintsState = state;
    } else if (descriptor == POLYMER_BUILD_ERRORS) {
      polymerBuildErrors = updatedValue(state, polymerBuildErrors, null);
      polymerBuildErrorsState = state;
    } else if (descriptor == POLYMER_RESOLUTION_ERRORS) {
      polymerResolutionErrors = updatedValue(state, polymerResolutionErrors, null);
      polymerResolutionErrorsState = state;
    } else {
      super.setState(descriptor, state);
    }
  }

  @Override
  public <E> void setValue(DataDescriptor<E> descriptor, E value) {
    if (descriptor == ANGULAR_APPLICATION) {
      countTransitionToValid(descriptor, angularApplicationState);
      angularApplication = (AngularApplication) value;
      angularApplicationState = CacheState.VALID;
    } else if (descriptor == ANGULAR_COMPONENT) {
      countTransitionToValid(descriptor, angularComponentState);
      angularComponent = (AngularComponentElement) value;
      angularComponentState = CacheState.VALID;
    } else if (descriptor == ANGULAR_ENTRY) {
      countTransitionToValid(descriptor, angularEntryState);
      angularEntry = (AngularApplication) value;
      angularEntryState = CacheState.VALID;
    } else if (descriptor == ANGULAR_ERRORS) {
      countTransitionToValid(descriptor, angularErrorsState);
      angularErrors = (AnalysisError[]) value;
      angularErrorsState = CacheState.VALID;
    } else if (descriptor == ELEMENT) {
      countTransitionToValid(descriptor, elementState);
      element = (HtmlElement) value;
      elementState = CacheState.VALID;
    } else if (descriptor == PARSE_ERRORS) {
      countTransitionToValid(descriptor, parseErrorsState);
      parseErrors = (AnalysisError[]) value;
      parseErrorsState = CacheState.VALID;
    } else if (descriptor == PARSED_UNIT) {
      countTransitionToValid(descriptor, parsedUnitState);
      parsedUnit = (HtmlUnit) value;
      parsedUnitState = CacheState.VALID;
    } else if (descriptor == RESOLVED_UNIT) {
      countTransitionToValid(descriptor, resolvedUnitState);
      resolvedUnit = (HtmlUnit) value;
      resolvedUnitState = CacheState.VALID;
    } else if (descriptor == REFERENCED_LIBRARIES) {
      countTransitionToValid(descriptor, referencedLibrariesState);
      referencedLibraries = value == null ? Source.EMPTY_ARRAY : (Source[]) value;
      referencedLibrariesState = CacheState.VALID;
    } else if (descriptor == RESOLUTION_ERRORS) {
      countTransitionToValid(descriptor, resolutionErrorsState);
      resolutionErrors = (AnalysisError[]) value;
      resolutionErrorsState = CacheState.VALID;
    } else if (descriptor == HINTS) {
      countTransitionToValid(descriptor, hintsState);
      hints = (AnalysisError[]) value;
      hintsState = CacheState.VALID;
    } else if (descriptor == POLYMER_BUILD_ERRORS) {
      countTransitionToValid(descriptor, polymerBuildErrorsState);
      polymerBuildErrors = (AnalysisError[]) value;
      polymerBuildErrorsState = CacheState.VALID;
    } else if (descriptor == POLYMER_RESOLUTION_ERRORS) {
      countTransitionToValid(descriptor, polymerResolutionErrorsState);
      polymerResolutionErrors = (AnalysisError[]) value;
      polymerResolutionErrorsState = CacheState.VALID;
    } else {
      super.setValue(descriptor, value);
    }
  }

  @Override
  protected void copyFrom(SourceEntryImpl entry) {
    super.copyFrom(entry);
    HtmlEntryImpl other = (HtmlEntryImpl) entry;
    angularApplicationState = other.angularApplicationState;
    angularApplication = other.angularApplication;
    angularComponentState = other.angularComponentState;
    angularComponent = other.angularComponent;
    angularEntryState = other.angularEntryState;
    angularEntry = other.angularEntry;
    angularErrorsState = other.angularErrorsState;
    angularErrors = other.angularErrors;
    parseErrorsState = other.parseErrorsState;
    parseErrors = other.parseErrors;
    parsedUnitState = other.parsedUnitState;
    parsedUnit = other.parsedUnit;
    resolvedUnitState = other.resolvedUnitState;
    resolvedUnit = other.resolvedUnit;
    referencedLibrariesState = other.referencedLibrariesState;
    referencedLibraries = other.referencedLibraries;
    resolutionErrorsState = other.resolutionErrorsState;
    resolutionErrors = other.resolutionErrors;
    elementState = other.elementState;
    element = other.element;
    hintsState = other.hintsState;
    hints = other.hints;
    polymerBuildErrorsState = other.polymerBuildErrorsState;
    polymerBuildErrors = other.polymerBuildErrors;
    polymerResolutionErrorsState = other.polymerResolutionErrorsState;
    polymerResolutionErrors = other.polymerResolutionErrors;
  }

  @Override
  protected boolean hasErrorState() {
    return super.hasErrorState() || parsedUnitState == CacheState.ERROR
        || resolvedUnitState == CacheState.ERROR || parseErrorsState == CacheState.ERROR
        || resolutionErrorsState == CacheState.ERROR
        || referencedLibrariesState == CacheState.ERROR || elementState == CacheState.ERROR
        || angularErrorsState == CacheState.ERROR || hintsState == CacheState.ERROR
        || polymerBuildErrorsState == CacheState.ERROR
        || polymerResolutionErrorsState == CacheState.ERROR;
  }

  @Override
  protected boolean writeDiffOn(StringBuilder builder, SourceEntry oldEntry) {
    boolean needsSeparator = super.writeDiffOn(builder, oldEntry);
    if (!(oldEntry instanceof HtmlEntryImpl)) {
      if (needsSeparator) {
        builder.append("; ");
      }
      builder.append("entry type changed; was " + oldEntry.getClass().getName());
      return true;
    }
    needsSeparator = writeStateDiffOn(
        builder,
        needsSeparator,
        oldEntry,
        PARSE_ERRORS,
        "parseErrors");
    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, PARSED_UNIT, "parsedUnit");
    needsSeparator = writeStateDiffOn(
        builder,
        needsSeparator,
        oldEntry,
        RESOLVED_UNIT,
        "resolvedUnit");
    needsSeparator = writeStateDiffOn(
        builder,
        needsSeparator,
        oldEntry,
        RESOLUTION_ERRORS,
        "resolutionErrors");
    needsSeparator = writeStateDiffOn(
        builder,
        needsSeparator,
        oldEntry,
        REFERENCED_LIBRARIES,
        "referencedLibraries");
    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, ELEMENT, "element");
    needsSeparator = writeStateDiffOn(
        builder,
        needsSeparator,
        oldEntry,
        ANGULAR_APPLICATION,
        "angularApplicationState");
    needsSeparator = writeStateDiffOn(
        builder,
        needsSeparator,
        oldEntry,
        ANGULAR_COMPONENT,
        "angularComponent");
    needsSeparator = writeStateDiffOn(
        builder,
        needsSeparator,
        oldEntry,
        ANGULAR_ENTRY,
        "angularEntry");
    needsSeparator = writeStateDiffOn(
        builder,
        needsSeparator,
        oldEntry,
        ANGULAR_ERRORS,
        "angularErrors");
    needsSeparator = writeStateDiffOn(
        builder,
        needsSeparator,
        oldEntry,
        POLYMER_BUILD_ERRORS,
        "polymerBuildErrors");
    needsSeparator = writeStateDiffOn(
        builder,
        needsSeparator,
        oldEntry,
        POLYMER_RESOLUTION_ERRORS,
        "polymerResolutionErrors");
    return needsSeparator;
  }

  @Override
  protected void writeOn(StringBuilder builder) {
    builder.append("Html: ");
    super.writeOn(builder);
    builder.append("; parseErrors = ");
    builder.append(parseErrorsState);
    builder.append("; parsedUnit = ");
    builder.append(parsedUnitState);
    builder.append("; resolvedUnit = ");
    builder.append(resolvedUnitState);
    builder.append("; resolutionErrors = ");
    builder.append(resolutionErrorsState);
    builder.append("; referencedLibraries = ");
    builder.append(referencedLibrariesState);
    builder.append("; element = ");
    builder.append(elementState);
    builder.append("; angularApplication = ");
    builder.append(angularApplicationState);
    builder.append("; angularComponent = ");
    builder.append(angularComponentState);
    builder.append("; angularEntry = ");
    builder.append(angularEntryState);
    builder.append("; angularErrors = ");
    builder.append(angularErrorsState);
    builder.append("; polymerBuildErrors = ");
    builder.append(polymerBuildErrorsState);
    builder.append("; polymerResolutionErrors = ");
    builder.append(polymerResolutionErrorsState);
  }
}