/*
 *
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
 *
 *  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 org.apache.royale.compiler.internal.embedding;

import java.io.File;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.apache.commons.io.FilenameUtils;

import org.apache.royale.compiler.common.ISourceLocation;
import org.apache.royale.compiler.definitions.IDefinition;
import org.apache.royale.compiler.definitions.IFunctionDefinition;
import org.apache.royale.compiler.definitions.IFunctionDefinition.FunctionClassification;
import org.apache.royale.compiler.definitions.IGetterDefinition;
import org.apache.royale.compiler.definitions.INamespaceDefinition;
import org.apache.royale.compiler.embedding.EmbedAttribute;
import org.apache.royale.compiler.embedding.IEmbedData;
import org.apache.royale.compiler.embedding.transcoders.ITranscoder;
import org.apache.royale.compiler.internal.definitions.ClassDefinition;
import org.apache.royale.compiler.internal.embedding.transcoders.DataTranscoder;
import org.apache.royale.compiler.internal.embedding.transcoders.ImageTranscoder;
import org.apache.royale.compiler.internal.embedding.transcoders.JPEGTranscoder;
import org.apache.royale.compiler.internal.embedding.transcoders.MovieTranscoder;
import org.apache.royale.compiler.internal.embedding.transcoders.PBJTranscoder;
import org.apache.royale.compiler.internal.embedding.transcoders.SoundTranscoder;
import org.apache.royale.compiler.internal.embedding.transcoders.TranscoderBase;
import org.apache.royale.compiler.internal.embedding.transcoders.XMLTranscoder;
import org.apache.royale.compiler.internal.projects.CompilerProject;
import org.apache.royale.compiler.internal.projects.ASProject;
import org.apache.royale.compiler.internal.projects.RoyaleProject;
import org.apache.royale.compiler.internal.projects.SourcePathManager;
import org.apache.royale.compiler.internal.scopes.ASScope;
import org.apache.royale.compiler.internal.workspaces.Workspace;
import org.apache.royale.compiler.problems.EmbedInvalidAttributeValueProblem;
import org.apache.royale.compiler.problems.EmbedNoSourceAttributeProblem;
import org.apache.royale.compiler.problems.EmbedQualityValueProblem;
import org.apache.royale.compiler.problems.EmbedScalingGridValueProblem;
import org.apache.royale.compiler.problems.EmbedSourceAttributeDoesNotExistProblem;
import org.apache.royale.compiler.problems.EmbedUnknownAttributeProblem;
import org.apache.royale.compiler.problems.EmbedUnknownMimeTypeProblem;
import org.apache.royale.compiler.problems.EmbedUnrecogniedFileTypeProblem;
import org.apache.royale.compiler.problems.FontEmbeddingNotSupported;
import org.apache.royale.compiler.problems.ICompilerProblem;
import org.apache.royale.compiler.projects.ICompilerProject;
import org.apache.royale.compiler.units.ICompilationUnit;
import org.apache.royale.swc.ISWCFileEntry;
import org.apache.royale.swf.ISWFConstants;
import org.apache.royale.utils.FilenameNormalization;
import org.apache.royale.utils.StringEncoder;

/**
 * This is the main class which contains all information extracted from embed
 * meta data.
 */
public class EmbedData implements IEmbedData
{
    private static final String EMBED_SWC_SEP = "|";

    public static class SkinClassInfo
    {
        public boolean needsIBorder;
        public boolean needsIFlexDisplayObject;
        public boolean royaleMovieClipOrSprite;

        public boolean needsBorderMetrics;
        public boolean needsMeasuredHeight;
        public boolean needsMeasuredWidth;

        public boolean needsMove;
        public boolean needsSetActualSize;

        protected SkinClassInfo(ICompilerProject project, ClassDefinition definition)
        {
            needsIBorder = !definition.isInstanceOf(TranscoderBase.CORE_PACKAGE + ".IBorder", project);
            needsIFlexDisplayObject = !definition.isInstanceOf(TranscoderBase.CORE_PACKAGE + ".IFlexDisplayObject", project);
            royaleMovieClipOrSprite = definition.isInstanceOf(TranscoderBase.CORE_PACKAGE + ".RoyaleMovieClip", project) ||
                                    definition.isInstanceOf(TranscoderBase.CORE_PACKAGE + ".FlexSprite", project);

            final INamespaceDefinition qualifier = definition.getNamespaceReference().resolveNamespaceReference(project);
            needsBorderMetrics = needsGetter(project, qualifier, definition, "borderMetrics");
            needsMeasuredHeight = needsGetter(project, qualifier, definition, "measuredHeight");
            needsMeasuredWidth = needsGetter(project, qualifier, definition, "measuredWidth");
            needsMove = needsFunction(project, qualifier, definition, "move");
            needsSetActualSize = needsFunction(project, qualifier, definition, "setActualSize");
        }

        private static boolean needsGetter(ICompilerProject project, INamespaceDefinition qualifier, ClassDefinition classDefinition, String baseName)
        {
            final ASScope scope = classDefinition.getContainedScope();
            IDefinition def = scope.getQualifiedPropertyFromDef(project, classDefinition, baseName, qualifier, false);
            return (def instanceof IGetterDefinition) ? false : true;
        }

        private static boolean needsFunction(ICompilerProject project, INamespaceDefinition qualifier, ClassDefinition classDefinition, String baseName)
        {
            final ASScope scope = classDefinition.getContainedScope();
            IDefinition def = scope.getQualifiedPropertyFromDef(project, classDefinition, baseName, qualifier, false);
            if (def instanceof IFunctionDefinition)
            {
                FunctionClassification classification = ((IFunctionDefinition)def).getFunctionClassification();
                return (classification == FunctionClassification.CLASS_MEMBER) ? false : true;
            }

            return false;
        }
    }

    public EmbedData(String containingSourceFilename, String specifiedQName)
    {
        this.containingSourceFilename = containingSourceFilename;
        this.attributes = new HashMap<EmbedAttribute, Object>();
        this.specifiedName = specifiedQName;
        this.swcSource = null;
        this.skinClassInfo = null;
    }

    private final String containingSourceFilename;
    private final HashMap<EmbedAttribute, Object> attributes;
    private final String specifiedName;
    private TranscoderBase transcoder;
    private ISWCFileEntry swcSource;
    @SuppressWarnings("unused")
    private SkinClassInfo skinClassInfo;

    /**
     * Add an attribute
     * 
     * @param project containing project
     * @param location source location of the attribute
     * @param key attribute key
     * @param value attribute value
     * @param problems any problems with the key or value
     * @return true if there was an error
     */
    public boolean addAttribute(ICompilerProject project, ISourceLocation location, String key, String value, Collection<ICompilerProblem> problems)
    {
        boolean hadError = false;
        try
        {
            // a null key means default to source, ie [Embed="image.png"]
            if (EmbedAttribute.SOURCE.equals(key) || key == null)
            {
                // put source resolution problems into a separate collection first
                // so that if we fail because there's an octothorpe, and resolve successfully
                // later on, we haven't created incorrect problems.
                List<ICompilerProblem> resolveProblems = new LinkedList<ICompilerProblem>();
                String source = getResolvedSourcePath(project, location, value, resolveProblems);

                // could not resolve the source, so check for an octothorpe
                // which indicates a file within a SWC
                if (source == null)
                {
                    int octothorpe = value.indexOf("#");
                    if (octothorpe != -1)
                    {
                        source = getResolvedSourcePath(project, location, value.substring(0, octothorpe), problems);

                        String symbol = value.substring(octothorpe + 1);
                        attributes.put(EmbedAttribute.SYMBOL, symbol);
                    }
                    else
                    {
                        problems.addAll(resolveProblems);
                    }
                }

                if (source != null)
                {
                    attributes.put(EmbedAttribute.SOURCE, source);

                    // if we have a filename, but the mimeType hasn't been set yet,
                    // set if from the filename, but override it later on if there
                    // is an explicit mimeType, as that takes priority
                    if (!attributes.containsKey(EmbedAttribute.MIME_TYPE))
                    {
                        attributes.put(EmbedAttribute.MIME_TYPE, EmbedMIMEType.getMimeTypeFromFilename(source));
                    }
                }
                else
                {
                    Collection<ICompilationUnit> referencingCUs = project.getCompilationUnits(containingSourceFilename);
                    for (ICompilationUnit cu : referencingCUs)
                    {
                        ((RoyaleProject)project).addUnfoundReferencedSourceFileDependency(value, cu);
                    }
                    hadError = true;
                }
            }
            else if (EmbedAttribute.MIME_TYPE.equals(key))
            {
                attributes.put(EmbedAttribute.MIME_TYPE, EmbedMIMEType.getMimeTypeFromMimeString(value));
            }
            else if (EmbedAttribute.COMPRESSION.equals(key))
            {
                attributes.put(EmbedAttribute.COMPRESSION, Boolean.parseBoolean(value));
            }
            else if (EmbedAttribute.ENCODING.equals(key))
            {
                attributes.put(EmbedAttribute.ENCODING, value);
            }
            else if (EmbedAttribute.EXPORT_SYMBOL.equals(key))
            {
                attributes.put(EmbedAttribute.EXPORT_SYMBOL, value);
            }
            else if (EmbedAttribute.FLASH_TYPE.equals(key))
            {
                attributes.put(EmbedAttribute.FLASH_TYPE, Boolean.parseBoolean(value));
            }
            else if (EmbedAttribute.ORIGINAL.equals(key))
            {
                attributes.put(EmbedAttribute.ORIGINAL, value);
            }
            else if (EmbedAttribute.QUALITY.equals(key))
            {
                double doubleValue = Double.parseDouble(value);
                if (doubleValue < 0 || doubleValue > 100)
                {
                    problems.add(new EmbedQualityValueProblem(location, doubleValue));
                    hadError = true;
                }
                else
                {
                    Float floatValue = (float)(doubleValue / 100.0);
                    attributes.put(EmbedAttribute.QUALITY, floatValue);
                }
            }
            else if (EmbedAttribute.SCALE_GRID_BOTTOM.equals(key))
            {
                Integer intValue = Integer.parseInt(value);
                if (intValue.intValue() < 0)
                {
                    problems.add(new EmbedScalingGridValueProblem(location, EmbedAttribute.SCALE_GRID_BOTTOM, intValue.intValue()));
                    hadError = true;
                }
                else
                {
                    intValue *= ISWFConstants.TWIPS_PER_PIXEL;
                    attributes.put(EmbedAttribute.SCALE_GRID_BOTTOM, intValue);
                }
            }
            else if (EmbedAttribute.SCALE_GRID_LEFT.equals(key))
            {
                Integer intValue = Integer.parseInt(value);
                if (intValue.intValue() < 0)
                {
                    problems.add(new EmbedScalingGridValueProblem(location, EmbedAttribute.SCALE_GRID_LEFT, intValue.intValue()));
                    hadError = true;
                }
                else
                {
                    intValue *= ISWFConstants.TWIPS_PER_PIXEL;
                    attributes.put(EmbedAttribute.SCALE_GRID_LEFT, intValue);
                }
            }
            else if (EmbedAttribute.SCALE_GRID_RIGHT.equals(key))
            {
                Integer intValue = Integer.parseInt(value);
                if (intValue.intValue() < 0)
                {
                    problems.add(new EmbedScalingGridValueProblem(location, EmbedAttribute.SCALE_GRID_RIGHT, intValue.intValue()));
                    hadError = true;
                }
                else
                {
                    intValue *= ISWFConstants.TWIPS_PER_PIXEL;
                    attributes.put(EmbedAttribute.SCALE_GRID_RIGHT, intValue);
                }
            }
            else if (EmbedAttribute.SCALE_GRID_TOP.equals(key))
            {
                Integer intValue = Integer.parseInt(value);
                if (intValue.intValue() < 0)
                {
                    problems.add(new EmbedScalingGridValueProblem(location, EmbedAttribute.SCALE_GRID_TOP, intValue.intValue()));
                    hadError = true;
                }
                else
                {
                    intValue *= ISWFConstants.TWIPS_PER_PIXEL;
                    attributes.put(EmbedAttribute.SCALE_GRID_TOP, intValue);
                }
            }
            else if (EmbedAttribute.SKIN_CLASS.equals(key))
            {
                attributes.put(EmbedAttribute.SKIN_CLASS, value);
                if (value == null || value.length() == 0)
                {
                    //problems.add(new EmbedNoSkinClassProblem(location));
                    hadError = true;
                }

                if (!attributes.containsKey(EmbedAttribute.MIME_TYPE))
                {
                    attributes.put(EmbedAttribute.MIME_TYPE, EmbedMIMEType.SKIN);
                }

                // resolve the skin class here, as need to resolve against
                // a specific project
                IDefinition skinSymbol = project.resolveQNameToDefinition(value);
                if (skinSymbol == null)
                {
                    //problems.add(new EmbedNoSkinClassProblem(location));
                    hadError = true;                    
                }
                else
                {
                    // set the file from which the symbol came from to the source
                    // so we can still detect whether EmbedDatas are equal if
                    // a symbol resolves to a different class depending on the project
                    String source = skinSymbol.getContainingFilePath();
                    attributes.put(EmbedAttribute.SOURCE, source);

                    assert (skinSymbol instanceof ClassDefinition);
                    skinClassInfo = new SkinClassInfo(project, (ClassDefinition)skinSymbol);
                }
            }
            else if (EmbedAttribute.SMOOTHING.equals(key))
            {
                attributes.put(EmbedAttribute.SMOOTHING, Boolean.parseBoolean(value));
            }
            else if (EmbedAttribute.SYMBOL.equals(key))
            {
                attributes.put(EmbedAttribute.SYMBOL, value);
            }
            else if (EmbedAttribute.ADV_ANTI_ALIASING.equals(key) ||
                    EmbedAttribute.EMBED_AS_CFF.equals(key) ||
                    EmbedAttribute.FONT_FAMILY.equals(key) ||
                    EmbedAttribute.FONT_NAME.equals(key) ||
                    EmbedAttribute.FONT_STYLE.equals(key) ||
                    EmbedAttribute.FONT_WEIGHT.equals(key) ||
                    EmbedAttribute.SYSTEM_FONT.equals(key) ||
                    EmbedAttribute.SOURCE_LIST.equals(key))
            {
                // silently ignore these, as proper problem will be reported elsewhere
            }
            else
            {
                problems.add(new EmbedUnknownAttributeProblem(location, key));
                hadError = true;
            }
        }
        catch (NumberFormatException e)
        {
            problems.add(new EmbedInvalidAttributeValueProblem(location, key, value));
            hadError = true;
        }

        return hadError;
    }

    /**
     * Returns the value of an attribute.
     * 
     * @param attribute An embed attribute.
     * @return value of an attribute.  null if attribute does not exist
     */
    public Object getAttribute(EmbedAttribute attribute)
    {
        return attributes.get(attribute);
    }

    /**
     * @return All attributes
     */
    public EmbedAttribute[] getAttributes()
    {
        return attributes.keySet().toArray(new EmbedAttribute[attributes.size()]);
    }

    /**
     * @param project The compiler project.
     * @param location The source location.
     * @param problems The colleciton of compiler projects to which this method should add problems.
     * @return true if the transcoder was successfully constructed
     */
    public boolean createTranscoder(ICompilerProject project, ISourceLocation location, Collection<ICompilerProblem> problems)
    {
        // there should always be a source, with the exception of skin embedding, so don't
        // create a transcoder in this error state
        String source = (String)getAttribute(EmbedAttribute.SOURCE);
        if (source == null && getAttribute(EmbedAttribute.SKIN_CLASS) == null)
        {
            problems.add(new EmbedNoSourceAttributeProblem(location));
            return false;
        }

        // also check that we have a mimetype set, as don't know what transcoder
        // to create without it!
        EmbedMIMEType mimeType = (EmbedMIMEType)getAttribute(EmbedAttribute.MIME_TYPE);
        if (mimeType == null)
        {
            problems.add(new EmbedUnrecogniedFileTypeProblem(location, source));
            return false;
        }

        Workspace workspace = (Workspace)project.getWorkspace();
        switch (mimeType)
        {
            case JPEG:
            case JPG:
            case PNG:
            case GIF:
            {
                Boolean compression = (Boolean)getAttribute(EmbedAttribute.COMPRESSION);
                Float quality = (Float)getAttribute(EmbedAttribute.QUALITY);
                if ((compression != null && compression == true) || quality != null)
                {
                    transcoder = new JPEGTranscoder(this, workspace);
                }
                else
                {
                    transcoder = new ImageTranscoder(this, workspace);
                }
                break;
            }
            case MP3:
            {
                transcoder = new SoundTranscoder(this, workspace);
                break;
            }
            case FLASH:
            {
                transcoder = new MovieTranscoder(this, workspace);
                break;
            }
            case PBJ:
            {
                transcoder = new PBJTranscoder(this, workspace);
                break;
            }
            case OCT_STRM:
            {
                transcoder = new DataTranscoder(this, workspace);
                break;
            }
            case XML:
            {
                transcoder = new XMLTranscoder(this, workspace);
                break;
            }
            case SKIN:
            {
                //transcoder = new SkinTranscoder(this, workspace, skinClassInfo);
                break;
            }
            case TTF:
            case TTC:
            case OTF:
            case FONT:
            case DFONT:
            {
                problems.add(new FontEmbeddingNotSupported(location));
                transcoder = null;
                break;
            }
            case TEXT:
            case PROPERTIES:
            	break;  // don't need transcoder for text
            default:
            {
                problems.add(new EmbedUnknownMimeTypeProblem(location, mimeType));
                transcoder = null;
            }
        }

        if (transcoder == null)
            return false;

        // there were problems with the transcoder because of attribute settings
        // so don't return it, and let the user deal with the errors
        if (!transcoder.analyze(location, problems))
        {
            transcoder = null;
            return false;
        }

        return true;
    }

    /**
     * Returns the qname of the class generated from the EmbedData.  The name
     * is guaranteed to be unique and not conflict with user space names, unless
     * a user defined class has been decorated with the embed metadata, in which
     * case, the users class name will be returned.
     * @return qname
     */
    public String getQName()
    {
        if (specifiedName != null)
            return specifiedName;

        String source = (String)getAttribute(EmbedAttribute.SOURCE);
        if (swcSource != null)
        {
            source = EMBED_SWC_SEP.concat(source);
            source = swcSource.getContainingSWCPath().concat(source);
        }

        String filename = FilenameUtils.getName(source);
        filename = filename.replace(".", "_");
        String qname = filename + "$" + StringEncoder.stringToMD5String(source);

        // add the transcoder hashCode to the end of the QName to ensure
        // two embed data's with the same source, but different attributes
        // don't clash
        qname += transcoder.hashCode();

        return qname;
    }

    /**
     * Check if the generated class extends another
     * 
     * @return true if another class is extended
     */
    public boolean generatedClassExtendsAnother()
    {
        String baseClassQname = transcoder.getBaseClassQName();
        if (baseClassQname.isEmpty())
            return false;

        return true;
    }

    /**
     * Get the transcoder used by this embed.  This can be null if there was
     * a problem with the Embed directive
     * 
     * @return transcoder
     */
    public final ITranscoder getTranscoder()
    {
        return transcoder;
    }

    /**
     * 
     * @return ISWCFileEntry entry to source asset contained within swc.  null if not contained within SWC
     */
    public final ISWCFileEntry getSWCSource()
    {
        return swcSource;
    }

    @Override
    public boolean equals(Object o)
    {
        assert (transcoder != null) : "equals called on EmbedData with null transcoder";

        if (!(o instanceof EmbedData))
            return false;

        // EmbedData's are considered equal if their transcoders are equal
        return transcoder.equals(((EmbedData)o).getTranscoder());
    }

    @Override
    public int hashCode()
    {
        assert (transcoder != null) : "hashCode called on EmbedData with null transcoder";
        return transcoder.hashCode();
    }

    private String getResolvedSourcePath(ICompilerProject project, ISourceLocation location, String sourceValue, Collection<ICompilerProblem> problems)
    {
        if (sourceValue == null || sourceValue.isEmpty())
        {
            problems.add(new EmbedNoSourceAttributeProblem(location));
            return null;
        }

        Map<String,String> searchedLocations = new LinkedHashMap<String,String>();
        String containingSourcePath = new File(containingSourceFilename).getParent();
        String sourceFile = getResolvedSourcePath(project, containingSourcePath,
                sourceValue, searchedLocations);
        if (sourceFile == null)
        {
            problems.add(new EmbedSourceAttributeDoesNotExistProblem(location, 
                    sourceValue, searchedLocations));
        }

        return sourceFile;
    }

    /**
     * Resolve the location to the requested embed asset filename based on the rules.
     * 1) Absolute filename
     * 2) relative to the containing source file
     * 3) the source path (if flash project)
     * 4) the library path (if flash project)
     * @param containingSourcePath
     * @param filename
     * @param searchedLocations A map of the locations searched for filename. The
     * key is the filename and the value is the id of the message format used to 
     * format the filename.
     * @return The absolute path to the requested filename, or null if not found.
     */
    private String getResolvedSourcePath(ICompilerProject project, 
            String containingSourcePath, String filename,
            Map<String,String> searchedLocations)
    {
        // first check if absolute path
        String sourceFile = null;
        if (new File(filename).isAbsolute())
        {
            searchedLocations.put(FilenameNormalization.normalize(filename), "QuotedPath");
            sourceFile = SourcePathManager.getSourceFileInPath(null, filename);
            if (sourceFile != null)
                return sourceFile;
        }

        // not an absolute path, so try relative to the containing source
        if (containingSourcePath != null)
        {
            File file = new File(containingSourcePath, filename);
            searchedLocations.put(FilenameNormalization.normalize(file).getAbsolutePath(),
                    "QuotedPath");
            sourceFile = SourcePathManager.getSourceFileInPath(new File(containingSourcePath), filename);
        }

        if (sourceFile != null)
            return sourceFile;

        if (project instanceof ASProject)
        {
            sourceFile = getResolvedSourcePath((ASProject)project, filename,
                    searchedLocations);
        }
        if (project instanceof RoyaleProject)
        {
            RoyaleProject royaleProject = (RoyaleProject) project;
            String packagePath = null;
            if((containingSourcePath != null) && !royaleProject.getSourcePath().isEmpty()) {
                for (File sourcePath : royaleProject.getSourcePath()) {
                	if (containingSourcePath.equals(sourcePath.getAbsolutePath()))
                	{
                		packagePath = "";
                		break;
                	}
                    if (containingSourcePath.startsWith(sourcePath.getAbsolutePath())) {
                        packagePath = containingSourcePath.substring(sourcePath.getAbsolutePath().length() + 1);
                        break;
                    }
                }
            }
            sourceFile = getResolvedSourcePath((RoyaleProject)project, filename, packagePath,
                    searchedLocations);
        }

        return sourceFile;
    }

    private String getResolvedSourcePath(ASProject project, String filename,
            Map<String,String> searchedLocations)
    {
        // Only files that start with a leading "/" are resolved using the 
        // source path.
        String sourceFile = null;
        boolean isAbsolute = filename.startsWith("/");  
        if (isAbsolute)
        {
            searchedLocations.put(filename.substring(1), "EmbedOnSourcePath");
            sourceFile = project.getSourceFileFromSourcePath(filename.substring(1));
        }
        
        if (sourceFile != null)
            return sourceFile;

        // Not in the source path, so finally look for the file within the libraries.
        // Absolute files are not looked up using the library path.
        if (!isAbsolute)
        {
            searchedLocations.put(filename, "EmbedOnLibraryPath");
            swcSource = project.getSourceFileFromLibraryPath(filename);
            if (swcSource != null)
            {
                sourceFile = swcSource.getPath();
            }            
        }

        return sourceFile;
    }

    private String getResolvedSourcePath(RoyaleProject project, String filename, String packagePath,
                                         Map<String,String> searchedLocations)
    {
        // Only files that start with a leading "/" are resolved using the
        // source path.
        String sourceFile = null;
        boolean isAbsolute = filename.startsWith("/");
        if (isAbsolute)
        {
            searchedLocations.put(filename.substring(1), "EmbedOnSourcePath");
            sourceFile = project.getSourceFileFromSourcePath(filename.substring(1));
        }

        if (sourceFile != null)
            return sourceFile;

        // Not in the source path, so finally look for the file within the libraries.
        // Absolute files are not looked up using the library path.
        if (!isAbsolute)
        {
            for(File sourceDirectory : project.getSourcePath()) {
                File potentialFile = sourceDirectory;
                if(packagePath != null) {
                    potentialFile = new File(potentialFile, packagePath);
                }
                searchedLocations.put(filename, potentialFile.getAbsolutePath());
                potentialFile = new File(potentialFile, filename);
                if(potentialFile.exists()) {
                    return potentialFile.getAbsolutePath();
                }
            }
            searchedLocations.put(filename, "EmbedOnLibraryPath");
            swcSource = project.getSourceFileFromLibraryPath(filename);
            if (swcSource != null)
            {
                sourceFile = swcSource.getPath();
            }
        }

        return sourceFile;
    }
}
