/*******************************************************************************
 * Copyright (c) 2010 BSI Business Systems Integration AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     BSI Business Systems Integration AG - initial API and implementation
 ******************************************************************************/
package org.eclipse.scout.sdk.util.internal.typecache;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaElementDelta;
import org.eclipse.jdt.core.IRegion;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.scout.commons.CollectionUtility;
import org.eclipse.scout.sdk.util.internal.SdkUtilActivator;
import org.eclipse.scout.sdk.util.jdt.JdtEvent;
import org.eclipse.scout.sdk.util.type.TypeUtility;
import org.eclipse.scout.sdk.util.typecache.ICachedTypeHierarchy;
import org.eclipse.scout.sdk.util.typecache.ICachedTypeHierarchyResult;
import org.eclipse.scout.sdk.util.typecache.IHierarchyCache;
import org.eclipse.scout.sdk.util.typecache.ITypeHierarchy;
import org.eclipse.scout.sdk.util.typecache.TypeHierarchyConstraints;

public final class HierarchyCache implements IHierarchyCache {

  private static final HierarchyCache INSTANCE = new HierarchyCache();

  private final Map<Object, ICacheableTypeHierarchyResult> m_cachedHierarchyResults;

  public static HierarchyCache getInstance() {
    return INSTANCE;
  }

  private HierarchyCache() {
    m_cachedHierarchyResults = new HashMap<Object, ICacheableTypeHierarchyResult>();
  }

  @Override
  public synchronized void dispose() {
    invalidateAll(); // to ensure the resources are released.
    m_cachedHierarchyResults.clear();
  }

  public synchronized List<ICacheableTypeHierarchyResult> getAllCachedHierarchies() {
    return getHierarchiesSafe();
  }

  @Override
  public ICachedTypeHierarchyResult getProjectContextTypeHierarchy(TypeHierarchyConstraints constraints) {
    ICacheableTypeHierarchyResult h = null;
    synchronized (this) {
      h = m_cachedHierarchyResults.get(constraints);
      if (h != null && !TypeUtility.exists(h.getBaseType())) {
        h.invalidate();
        m_cachedHierarchyResults.remove(constraints);
        h = null;
      }
      if (h == null) {
        h = new ProjectContextTypeHierarchyResult(constraints);
        m_cachedHierarchyResults.put(constraints, h);
      }
    }
    return h;
  }

  @Override
  public ICachedTypeHierarchy getTypeHierarchy(IType type) {
    if (!TypeUtility.exists(type) || !type.getJavaProject().exists()) {
      throw new IllegalArgumentException("type does not exist!");
    }
    ICacheableTypeHierarchyResult hierarchy = null;
    synchronized (this) {
      hierarchy = m_cachedHierarchyResults.get(type);
      if (hierarchy != null && (!TypeUtility.exists(hierarchy.getBaseType()) || !TypeUtility.exists(hierarchy.getBaseType().getJavaProject()))) {
        // discard old create new
        hierarchy.invalidate();
        m_cachedHierarchyResults.remove(type);
        hierarchy = null;
      }
      if (hierarchy == null) {
        hierarchy = new CachedTypeHierarchy(type);
        m_cachedHierarchyResults.put(type, hierarchy);
      }
    }
    return (ICachedTypeHierarchy) hierarchy;
  }

  @Override
  public ICachedTypeHierarchy getPrimaryTypeHierarchy(IType type) {
    if (type != null && TypeUtility.exists(type.getDeclaringType())) {
      throw new IllegalArgumentException("type '" + type.getFullyQualifiedName() + "' must be a primary type.");
    }
    return new CachedPrimaryTypeHierarchy(getTypeHierarchy(type));
  }

  synchronized void removeCachedHierarchy(IType type) {
    m_cachedHierarchyResults.remove(type);
  }

  synchronized void replaceCachedHierarchy(Object oldKey, Object newKey, ICacheableTypeHierarchyResult hierarchyToAdd) {
    m_cachedHierarchyResults.remove(oldKey);
    m_cachedHierarchyResults.put(newKey, hierarchyToAdd);
  }

  @Override
  public ITypeHierarchy getLocalTypeHierarchy(IRegion region) {
    try {
      return new TypeHierarchy(null, JavaCore.newTypeHierarchy(region, null, null));
    }
    catch (JavaModelException e) {
      if (!e.isDoesNotExist()) {
        SdkUtilActivator.logWarning("could not build hierarchy of region '" + region + "'.", e);
      }
    }
    return null;
  }

  @Override
  public ITypeHierarchy getSupertypeHierarchy(IType type) {
    if (!TypeUtility.exists(type)) {
      return null;
    }
    try {
      return new TypeHierarchy(type, type.newSupertypeHierarchy(null));
    }
    catch (JavaModelException e) {
      SdkUtilActivator.logWarning("could not build super hierarchy '" + type.getFullyQualifiedName() + "'.", e);
    }
    return null;
  }

  @Override
  public synchronized void invalidateAll() {
    List<ICacheableTypeHierarchyResult> hierarchies = getHierarchiesSafe(); // get a copy to prevent ConcurrentModificationException
    for (ICacheableTypeHierarchyResult h : hierarchies) {
      if (h.isCreated()) {
        h.invalidate();
      }
    }
  }

  private synchronized List<ICacheableTypeHierarchyResult> getHierarchiesSafe() {
    return CollectionUtility.arrayList(m_cachedHierarchyResults.values());
  }

  private void handleTypeChange(IType t, ITypeHierarchy superTypeHierarchy) {
    if (superTypeHierarchy != null) {
      List<ICacheableTypeHierarchyResult> hierarchies = getHierarchiesSafe();
      Set<IType> superTypes = superTypeHierarchy.getAllSupertypes(t);
      for (ICacheableTypeHierarchyResult h : hierarchies) {
        if (h.isCreated() && h.contains(t) != h.isTypeAccepted(t, superTypes)) {
          h.invalidate();
        }
      }
    }
  }

  private void handleTypeRemoved(IType type) {
    List<ICacheableTypeHierarchyResult> hierarchies = getHierarchiesSafe();
    for (ICacheableTypeHierarchyResult h : hierarchies) {
      if (h.isCreated() && h.contains(type)) {
        h.invalidate();
      }
    }
  }

  private void handleJavaElementRemoved(IJavaElement element) {
    if (element.getElementType() < IJavaElement.TYPE) {
      List<ICacheableTypeHierarchyResult> hierarchies = getHierarchiesSafe();
      for (ICacheableTypeHierarchyResult h : hierarchies) {
        if (h.isCreated()) {
          if (TypeUtility.isAncestor(element, h.getBaseType())) {
            h.invalidate();
          }
          else {
            for (IType candidate : h) {
              if (TypeUtility.isAncestor(element, candidate)) {
                h.invalidate();
                break;
              }
            }
          }
        }
      }
    }
    else if (element.getElementType() == IJavaElement.TYPE) {
      handleTypeRemoved((IType) element);
    }
  }

  private void handleCompilationUnitChanged(ICompilationUnit icu) {
    if (!TypeUtility.exists(icu)) {
      return;
    }

    IRegion region = JavaCore.newRegion();
    region.add(icu);
    try {
      ITypeHierarchy hierarchy = getLocalTypeHierarchy(region);
      if (hierarchy != null) {
        for (IType t : icu.getTypes()) {
          reqTypeChangedFromExternal(t, hierarchy);
        }
      }
    }
    catch (JavaModelException e) {
      SdkUtilActivator.logWarning("could not find types in compilation unit '" + icu.getElementName() + "'.", e);
    }
  }

  private void reqTypeChangedFromExternal(IType type, ITypeHierarchy hierarchy) {
    handleTypeChange(type, hierarchy);
    try {
      for (IType subType : type.getTypes()) {
        reqTypeChangedFromExternal(subType, hierarchy);
      }
    }
    catch (JavaModelException e) {
      SdkUtilActivator.logWarning("could not find subtypes of type '" + type.getElementName() + "'.", e);
    }
  }

  /**
   * will be notified before events are passed through the event listener list from {@link JavaResourceChangedEmitter}
   */
  void elementChanged(JdtEvent e) {
    switch (e.getEventType()) {
      case IJavaElementDelta.ADDED:
      case IJavaElementDelta.CHANGED: {
        if (e.getElementType() == IJavaElement.TYPE && e.getDeclaringType() == null) {
          handleTypeChange((IType) e.getElement(), e.getSuperTypeHierarchy());
        }
        else if (e.getElementType() == IJavaElement.COMPILATION_UNIT) {
          handleCompilationUnitChanged((ICompilationUnit) e.getElement());
        }
        else if (e.getElementType() == IJavaElement.JAVA_PROJECT) {
          if ((e.getFlags() & IJavaElementDelta.F_OPENED) != 0 || e.getFlags() == 0) {
            // a new java project has been created/imported/opened/added in the workspace
            invalidateAll();
          }
          else if ((e.getFlags() & IJavaElementDelta.F_CLOSED) != 0) {
            // a project has been closed
            handleJavaElementRemoved(e.getElement());
          }
        }
        else if (e.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT) {
          if ((e.getFlags() & (IJavaElementDelta.F_ADDED_TO_CLASSPATH | IJavaElementDelta.F_REMOVED_FROM_CLASSPATH | IJavaElementDelta.F_ARCHIVE_CONTENT_CHANGED | IJavaElementDelta.F_REORDER)) != 0 || e.getFlags() == 0) {
            // the classpath has been changed
            invalidateAll();
          }
        }
        break;
      }
      case IJavaElementDelta.REMOVED: {
        if (TypeUtility.exists(e.getElement().getParent())) {
          handleJavaElementRemoved(e.getElement());
        }
        break;
      }
      case JavaResourceChangedEmitter.CHANGED_EXTERNAL:
        if (e.getElementType() == IJavaElement.COMPILATION_UNIT) {
          handleCompilationUnitChanged((ICompilationUnit) e.getElement());
        }
        else if (e.getElementType() == IJavaElement.TYPE) {
          handleTypeChange((IType) e.getElement(), e.getSuperTypeHierarchy());
        }
        break;
    }
  }
}