/*******************************************************************************
 * Copyright (c) 2001, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.wst.xml.core.internal.validation.core;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.wst.validation.internal.operations.ValidatorManager;
import org.eclipse.wst.validation.internal.operations.WorkbenchContext;
import org.eclipse.wst.validation.internal.provisional.core.IMessage;


/**
 * A helper class for validation in the validation framework.
 * 
 * @author Ernest Mah (ernest@ca.ibm.com)
 * @author Lawrence Mandel, IBM
 */
public class Helper extends WorkbenchContext
{
  public static final String GET_PROJECT_FILES = "getAllFiles"; //$NON-NLS-1$
  public static final String GET_FILE = "getFile"; //$NON-NLS-1$
  //dw private static final IContainer[] NO_CONTAINERS = new IContainer[0];
  public static final String VALIDATION_MARKER = "org.eclipse.wst.validation.problemmarker"; //$NON-NLS-1$
  public static final String VALIDATION_MARKER_OWNER = "owner";   //$NON-NLS-1$

  /**
   * Constructor.
   */
  public Helper()
  {
    super();

    // the following will register the helper's symbolic methods
    Class [] args = new Class[1] ;
    args[0] = String.class ;  // a string argument denoting a specific JSP.
    
    registerModel(GET_FILE, "getFile", args);//$NON-NLS-1$
    registerModel(GET_PROJECT_FILES, "getFiles", args);//$NON-NLS-1$
  }

  /**
   * Get the IFile for the given filename.
   * 
   * @param filename The name of the file to retrieve.
   * @return An IFile representing the file specified or null if it can't be resolved.
   */
  public IFile getFile(String filename)
  {
    //    System.out.println("file name = " + filename);
    IResource res = getProject().findMember(filename, true); // true means include phantom resources
    if (res instanceof IFile) 
    {
      return (IFile) res;
    }
    return null;
  }
  
  /**
   * Get the collection of files from the project that are relevant for the
   * validator with the given class name.
   * 
   * @param validatorClassName The name of the validator class.
   * @return The collection of files relevant for the validator class specified.
   */
  public Collection getFiles(String validatorClassName)
  {
    IProject project = getProject();
    List files = new ArrayList();
    getFiles(files, project, validatorClassName);
    return files;
  }

  /**
   * Get the collection of files from the project that are relevant for the
   * validator with the given class name.
   * 
   * @param files The files relevant for the class name.
   * @param resource The resource to look for files in.
   * @param validatorClassName The name of the validator class.
   */
  protected void getFiles(Collection files, IContainer resource, String validatorClassName)
  {
    try
    {
      IResource [] resourceArray = resource.members(false);
      for (int i=0; i<resourceArray.length; i++)
      {       
        if (ValidatorManager.getManager().isApplicableTo(validatorClassName, resourceArray[i])) 
        {
          if (resourceArray[i] instanceof IFile) 
          {
            files.add(resourceArray[i]);
          }
        }
        if (resourceArray[i].getType() == IResource.FOLDER)
         getFiles(files,(IContainer)resourceArray[i], validatorClassName) ;
      }
    }
    catch (Exception e) {}
  }

  
/**
 * Return the name of the resource, without the project-specific information 
 * in front.
 *
 * This method is used by ValidationOperation to calculate the non-environment 
 * specific names of the files. Only the IWorkbenchContext implementation knows how 
 * much information to strip off of the IResource name. For example, if there is
 * an EJB Project named "MyEJBProject", and it uses the default names for the 
 * source and output folders, "source" and "ejbModule", respectively, then the
 * current implementation of EJB Helper knows how much of that structure is 
 * eclipse-specific. 
 *
 * Since the "source" folder contains Java source files, a portable name would
 * be the fully-qualified name of the Java class, without the eclipse-specific
 * project and folder names in front of the file name. The EJBHelper knows that 
 * everything up to the "source" folder, for example, can be removed, because, 
 * according to the definition of the EJB Project, everything contained
 * in the source folder is java source code. So if there is an IResource in an
 * EJB Project named "/MyEJBProject/source/com/ibm/myclasses/MyJavaFile.java",
 * this method would make this name portable by stripping off the
 * "/MyEJBProject/source", and returning "com/ibm/myclasses/MyJavaFile.java".
 *
 * The output of this method is used by the ValidationOperation, when it
 * is calculating the list of added/changed/deleted file names for incremental
 * validation. If getPortableName(IResource) returns null, that means
 * that the IWorkbenchContext's implementation does not support that particular
 * type of resource, and the resource should not be included in the array of
 * IFileDelta objects in the IValidator's "validate" method. 
 * 
 * @param resource The resource to get the name from.
 * @return The portable name of the resource.
 */
public String getPortableName(IResource resource)
  {
    //    System.out.println("get portablename for " + resource);
    return resource.getProjectRelativePath().toString();
  }

/**
 * When an IValidator associates a target object with an IMessage,
 * the WorkbenchReporter eventually resolves that target object
 * with an IResource. Sometimes more than one target object resolves
 * to the same IResource (usually the IProject, which is the default
 * IResource when an IFile cannot be found). This method is called,
 * by the WorkbenchReporter, so that the WorkbenchReporter can 
 * distinguish between the IMessages which are on the same IResource, 
 * but refer to different target objects. This is needed for the 
 * removeAllMessages(IValidator, Object) method, so that when one
 * target object removes all of its messages, that it doesn't remove
 * another target object's messages.
 *
 * This method may return null only if object is null. Otherwise, an
 * id which can uniquely identify a particular object must be returned.
 * The id needs to be unique only within one particular IValidator.
 * 
 * @param object The object from which to get the name.
 * @return The name of the object or null if the object is null.
 */
public String getTargetObjectName(Object object)
  {
    if (object == null) 
    {
      return null;
    }
    
    //    System.out.println("get targetname for " + object);
    return object.toString();
  }
  
  /**
   * Delete the markers of the specified type from the specified resource.
   * 
   * @param resource The resource to delete the markers from.
   * @param markerType The type of markers to delete from the resource.
   * @param attributeName The name of the attribute which the markers must have to be deleted.
   * @param attributeValue The value of the attribute corresponding to attributeName which the markers must have to be deleted.
   * @throws CoreException
   */
  public static void deleteMarkers(IResource resource, String markerType, final String attributeName, final Object attributeValue) throws CoreException
  {          
    final IMarker[] v400Markers = resource.findMarkers(IMarker.PROBLEM, false, IResource.DEPTH_INFINITE);
    final IMarker[] markers = resource.findMarkers(markerType, true, IResource.DEPTH_INFINITE);
    IWorkspaceRunnable op = new IWorkspaceRunnable() 
     {
       public void run(IProgressMonitor progressMonitor) throws CoreException 
       {    
         // this fixes defect 193406
         // here we remove markers that may have been added by the v400 code
         // hopefully the '.markers' metadata files will be removed for the V5 install
         // and this kludge will not be needed there
         for (int i = 0; i < v400Markers.length; i++)
         {
           IMarker marker = markers[i];           
           marker.delete();           
         }
    
         for (int i = 0; i < markers.length; i++) 
         {
           IMarker marker = markers[i];
           
           Object value = marker.getAttribute(attributeName);
           if (value != null &&
               value.equals(attributeValue)) 
           {
             marker.delete();
           }
         }
       }
     };
    
    try
    {
      ResourcesPlugin.getWorkspace().run(op, null);
    }
    catch (Exception e) { }
  }
  
  /**
   * Get the validation framework severity for the given severity.
   * 
   * @param severity The severity to convert to validation framework severity.
   * @return The validation framework severity for the given severity.
   */
  static public int getValidationFrameworkSeverity(int severity)
  {
    switch (severity)
    {
      case IMarker.SEVERITY_ERROR:
        return IMessage.HIGH_SEVERITY;
      case IMarker.SEVERITY_WARNING:
        return IMessage.NORMAL_SEVERITY;
      case IMarker.SEVERITY_INFO:
        return IMessage.LOW_SEVERITY;
    }
    return IMessage.LOW_SEVERITY;  
  }
}
