package npanday.plugin.compile;

/*
 * 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.
 */

import npanday.ArtifactType;
import npanday.ArtifactTypeHelper;
import npanday.LocalRepositoryUtil;
import npanday.PathUtil;
import npanday.PlatformUnsupportedException;
import npanday.assembler.AssemblerContext;
import npanday.assembler.AssemblyInfo;
import npanday.assembler.AssemblyInfo.TargetFramework;
import npanday.assembler.AssemblyInfoException;
import npanday.assembler.AssemblyInfoMarshaller;
import npanday.executable.ExecutionException;
import npanday.executable.compiler.CompilerConfig;
import npanday.executable.compiler.CompilerExecutable;
import npanday.executable.compiler.CompilerRequirement;
import npanday.registry.RepositoryRegistry;
import npanday.resolver.NPandayDependencyResolution;
import npanday.resolver.filter.DotnetAssemblyArtifactFilter;
import npanday.resolver.filter.DotnetSymbolsArtifactFilter;
import npanday.resolver.filter.OrArtifactFilter;
import npanday.vendor.SettingsUtil;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.artifact.resolver.filter.AndArtifactFilter;
import org.apache.maven.artifact.resolver.filter.InversionArtifactFilter;
import org.apache.maven.artifact.resolver.filter.ScopeArtifactFilter;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.MavenProjectHelper;
import org.codehaus.plexus.util.FileUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Abstract Class for compile mojos for both test-compile and compile.
 *
 * @author Shane Isbell, Leopoldo Lee Agdeppa III
 * @author <a href="me@lcorneliussen.de">Lars Corneliussen, Faktum Software</a>
 */
public abstract class AbstractCompilerMojo
        extends AbstractMojo
{

    /**
     * @parameter expression="${npanday.settings}" default-value="${user.home}/.m2"
     */
    private String settingsPath;

    /**
     * @component
     */ 
    private AssemblerContext assemblerContext;

    /**
     * Skips compiling of unit tests
     *
     * @parameter expression = "${skipTestCompile}" default-value = "false"
     */
    protected boolean skipTestCompile;


    /**
     * The maven project.
     *
     * @parameter expression="${project}"
     * @required
     */
    protected MavenProject project;

    /**
     * The maven project helper.
     *
     * @component
     * @required
     */
    protected MavenProjectHelper projectHelper;

    /**
     * @component
     */
    private NPandayDependencyResolution dependencyResolution;

    /**
     * The location of the local Maven repository.
     *
     * @parameter expression="${settings.localRepository}"
     */
    protected File localRepository;

    /**
     * Additional compiler commands
     *
     * @parameter expression = "${parameters}"
     */
    protected ArrayList<String> parameters;


    /**
     * Additional compiler commands for test classes
     *
     * @parameter expression = "${testParameters}"
     */
    protected ArrayList<String> testParameters;


    /**
     * Specify a strong name key file.
     *
     * @parameter expression = "${keyfile}"
     */
    protected File keyfile;

    /**
     * Specify a strong name key file.
     *
     * @parameter expression = "${testKeyfile}"
     */
    protected File testKeyfile;


    /**
     * The starup object class
     *
     * @parameter expression = "${main}"
     */
    protected String main;


    /**
     * The starup object class
     *
     * @parameter expression = "${testMain}"
     */
    protected String testMain;


    /**
     * define
     *
     * @parameter expression = "${define}"
     */
    protected String define;


    /**
     * define
     *
     * @parameter expression = "${testDefine}"
     */
    protected String testDefine;

    /**
     * Specifies a strong name key container. (not currently supported)
     *
     * @parameter expression = "${keycontainer}"
     */
    protected String keycontainer;


    /**
     * Specifies a strong name key container. (not currently supported)
     *
     * @parameter expression = "${testKeycontainer}"
     */
    protected String testKeycontainer;

    /**
     * Limit the platforms this code can run on.
     *
     * @parameter expression = "${platform}"
     */
    protected String platform;

    /**
     * Limit the platforms this code can run on.
     *
     * @parameter expression = "${testPlatform}"
     */
    protected String testPlatform;

    /**
     * The framework version to compile under: 1.1, 2.0, 3.0
     *
     * @parameter expression = "${frameworkVersion}"
     */
    protected String frameworkVersion;


    /**
     * The framework version to compile the test classes: 1.1, 2.0, 3.0
     *
     * @parameter expression = "${testFrameworkVersion}"
     */
    protected String testFrameworkVersion;

    /**
     * The profile that the compiler should use to compile classes: FULL, COMPACT, (or a custom one specified in a
     * compiler-plugins.xml).
     *
     * @parameter expression = "${profile}" default-value = "FULL"
     */
    protected String profile;


    /**
     * The profile that the compiler should use to compile classes: FULL, COMPACT, (or a custom one specified in a
     * compiler-plugins.xml).
     *
     * @parameter expression = "${testProfile}" default-value = "FULL"
     */
    protected String testProfile;


    /**
     * .NET Language. The default value is <code>C_SHARP</code>. Not case or white-space sensitive.
     *
     * @parameter expression="${language}" default-value = "C_SHARP"
     * @required
     */
    protected String language;


    /**
     * .NET Language. The default value is <code>C_SHARP</code>. Not case or white-space sensitive.
     *
     * @parameter expression="${testLanguage}"
     */
    protected String testLanguage;


    /**
     * Returns the rootnamespace of the project. Used by VB project only.
     *
     * @parameter expression="${rootNamespace}"
     */
    protected String rootNamespace;


    /**
     * Returns the rootnamespace of the project. Used by VB project only.
     *
     * @parameter expression="${testRootNamespace}" default-value="${project.groupId}.${project.artifactId}"
     */
    protected String testRootNamespace;


    /**
     * The Vendor for the Compiler. Not
     * case or white-space sensitive.
     *
     * @parameter expression="${vendor}"
     */
    protected String vendor;

    /**
     * The Vendor for the Compiler. Supports MONO and MICROSOFT: the default value is <code>MICROSOFT</code>. Not
     * case or white-space sensitive.
     *
     * @parameter expression="${testVendor}"
     */
    protected String testVendor;


    /**
     * This over-rides the defaultAssemblyPath for the compiler plugin.
     *
     * @parameter expression = "${profileAssemblyPath}
     */
    protected File profileAssemblyPath;


    /**
     * This over-rides the defaultAssemblyPath for the compiler plugin.
     *
     * @parameter expression = "${testProfileAssemblyPath}
     */
    protected File testProfileAssemblyPath;

    /**
     * @parameter expression = "${vendorVersion}"
     */
    protected String vendorVersion;

    /**
     * @parameter expression = "${testVendorVersion}"
     */
    protected String testVendorVersion;


    /**
     * @parameter expression = "${isDebug}" default-value="false"
     */
    protected boolean isDebug;

    /**
     * @parameter classifier;
     */
    protected String classifier;

    /**
     * @component
     */
    protected npanday.executable.NetExecutableFactory netExecutableFactory;

    /**
     * @parameter expression="${project.file}"
     * @required
     * @readonly
     */
    protected File pomFile;

    /**
     * Delay-sign the assembly using only the public portion of the strong name key
     *
     * @parameter
     */
    protected boolean delaysign;


    /**
     * Delay-sign the assembly using only the public portion of the strong name key
     *
     * @parameter
     */
    protected boolean testDelaysign;

    /**
     * Link the specified modules into this assembly
     *
     * @parameter expression="${addmodules}"
     */
    protected String[] addModules;

    /**
     * Link the specified modules into this assembly
     *
     * @parameter expression="${testAddmodules}"
     */
    protected String[] testAddModules;

    /**
     * Specify a Win32 resource file (.res)
     *
     * @parameter expression = "${win32res}"
     */
    protected String win32Res;

    /**
     * Specify a Win32 resource file (.res)
     *
     * @parameter expression = "${testWin32res}"
     */
    protected String testWin32Res;

    /**
     * Remove integer checks.
     *
     * @parameter
     */
    protected boolean removeintchecks;


    /**
     * Remove integer checks.
     *
     * @parameter
     */
    protected boolean testRemoveintchecks;

    /**
     * Specifies a Win32 icon file (.ico) for the default Win32 resources.
     *
     * @parameter expression = "${win32icon}"
     */
    protected String win32Icon;

    /**
     * Specifies a Win32 icon file (.ico) for the default Win32 resources.
     *
     * @parameter expression = "${testWin32icon}"
     */
    protected String testWin32Icon;

    /**
     * Declare global Imports for namespaces in referenced metadata files.
     *
     * @parameter expression = "${imports}"
     */
    protected String[] imports;

    /**
     * Declare global Imports for namespaces in referenced metadata files.
     *
     * @parameter expression = "${testImports}"
     */
    protected String[] testImports;

    /**
     * Included source files
     *
     * @parameter expression = "${includeSources}"
     * @deprecated Use includes + excludes instead!
     */
    protected File[] includeSources;

    /**
     * Included test source files
     *
     * @parameter expression = "${testIncludeSources}"
     * @deprecated Use testIncludes + testExcludes instead!
     */
    protected File[] testIncludeSources;


    /**
     * Source file patterns to be included in compile.
     *
     * @parameter
     */
    protected String[] includes;

    /**
     * Source file patterns to be included in compile.
     *
     * @parameter
     */
    protected String[] excludes;

    /**
     * Source file patterns to be included in compile.
     *
     * @parameter
     */
    protected String[] testIncludes;

    /**
     * Source file patterns to be included in compile.
     *
     * @parameter
     */
    protected String[] testExcludes;

    /**
     * Embed the specified resource
     *
     * @parameter expression = "${resource}"
     */
    protected String resource;
    
    /**
     * Embed the specified resource
     *
     * @parameter expression = "${embeddedResources}"
     */
    protected ArrayList<String> embeddedResources;    

    /**
     * Embed the specified resource
     *
     * @parameter expression = "${testResource}"
     */
    protected String testResource;

    /**
     * Link the specified resource to this assembly
     *
     * @parameter expression = "${linkresource}"
     */
    protected String linkResource;

    /**
     * Link the specified resource to this assembly
     *
     * @parameter expression = "${testLinkresource}"
     */
    protected String testLinkResource;


    /**
     * Require explicit declaration of variables.
     *
     * @parameter
     */
    protected boolean optionexplicit;
    
    /**
     * Require explicit declaration of variables.
     *
     * @parameter
     */
    protected boolean testOptionexplicit;

    /**
     * Enforce strict language semantics / Warn when strict language semantics are not respected.
     *
     * @parameter expression = "${optionstrict}"
     */
    protected String optionStrict;

    /**
     * Enforce strict language semantics / Warn when strict language semantics are not respected.
     *
     * @parameter expression = "${testOptionstrict}"
     */
    protected String testOptionStrict;

    /**
     * Enable optimizations.
     *
     * @parameter
     */
    protected boolean optimize;

    /**
     * Enable optimizations.
     *
     * @parameter
     */
    protected boolean testOptimize;

    /**
     * Specifies binary or text style string comparisons
     *
     * @parameter expression = "${optioncompare}"
     */
    protected String optionCompare;


    /**
     * Specifies binary or text style string comparisons
     *
     * @parameter expression = "${testOptioncompare}"
     */
    protected String testOptionCompare;

    /**
     * Generate overflow checks
     *
     * @parameter
     */
    protected boolean checked;


    /**
     * Generate overflow checks
     *
     * @parameter
     */
    protected boolean testChecked;

    /**
     * Allow 'unsafe' code
     *     
     * @parameter
     */
    protected boolean unsafe;


    /**
     * Allow 'unsafe' code
     *
     * @parameter
     */
    protected boolean testUnsafe;

    /**
     * Do not auto include CSC.RSP/VBC.RSP file
     *
     * @parameter
     */
    protected boolean noconfig;


    /**
     * Do not auto include CSC.RSP/VBC.RSP file
     *
     * @parameter
     */
    protected boolean testNoconfig;

    /**
     * Base address for the library to be built
     *
     * @parameter expression = "${baseaddress}"
     */
    protected String baseAddress;

    /**
     * Base address for the library to be built
     *
     * @parameter expression = "${testBaseaddress}"
     */
    protected String testBaseAddress;

    /**
     * Create a 'Bug Report' file.
     *
     * @parameter expression = "${bugreport}"
     */
    protected String bugReport;

    /**
     * Create a 'Bug Report' file.
     *
     * @parameter expression = "${testBugreport}"
     */
    protected String testBugReport;

    /**
     * Specify the codepage to use when opening source files
     *
     * @parameter expression = "${codepage}"
     */
    protected String codePage;

    /**
     * Specify the codepage to use when opening source files
     *
     * @parameter expression = "${testCodepage}"
     */
    protected String testCodePage;

    /**
     * Output compiler messages in UTF-8 encoding
     *
     * @parameter
     */
    protected boolean utf8output;

    /**
     * Output compiler messages in UTF-8 encoding
     *
     * @parameter
     */
    protected boolean testUtf8output;

    /**
     * Specify debug information file name (default: output file name with .pdb extension)
     *
     * @parameter expression = "${pdb}"
     */
    protected String pdb;

    /**
     * Specify debug information file name (default: output file name with .pdb extension)
     *
     * @parameter expression = "${testPdb}"
     */
    protected String testPdb;

    /**
     * Specify how to handle internal compiler errors: prompt, send, queue, or none. The default is queue.
     *
     * @parameter expression = "${errorreport}"
     */
    protected String errorReport;

    /**
     * Specify how to handle internal compiler errors: prompt, send, queue, or none. The default is queue.
     *
     * @parameter expression = "${testErrorreport}"
     */
    protected String testErrorReport;

    /**
     * Name of the assembly which this module will be a part of
     *
     * @parameter expression = "${moduleassemblyname}"
     */
    protected String moduleAssemblyName;

    /**
     * Name of the assembly which this module will be a part of
     *
     * @parameter expression = "${testModuleassemblyname}"
     */
    protected String testModuleAssemblyName;

    /**
     * Specify additional directories to search in for references
     *
     * @parameter expression = "${libs}"
     */
    protected String[] libs;


    /**
     * Specify additional directories to search in for references
     *
     * @parameter expression = "${testLibs}"
     */
    protected String[] testLibs;


    /**
     * The artifact acts as an Integration test project
     *
     * @parameter
     */
    protected boolean integrationTest;


    /**
     * The directory for the compilated web application
     *
     * @parameter  expression = "${outputDirectory}"
     */
    protected File outputDirectory;
	
    /**
     * warn
     *
     * @parameter expression = "${warn}"
     */
    protected Integer warn;
    
    /**
     * testWarn
     *
     * @parameter expression = "${testWarn}"
     */
    protected Integer testWarn;
    
    /**
     * nowarn
     *
     * @parameter expression = "${nowarn}"
     */
    protected String nowarn;

 
    /**
     * testNowarn
     *
     * @parameter expression = "${testNowarn}"
     */
    protected String testNowarn;

    /**
     * @component
     */
    private RepositoryRegistry repositoryRegistry;

    /**
     * Attach PDB file as artifact, if <code>isDebug</code> enabled.
     *
     * @parameter expression = "${attachPdb}" default-value="false"
     */
    protected boolean attachPdb;

    /**
     * Compiles the class files.
     *
     * @throws MojoExecutionException thrown if MOJO is unable to compile the class files or if the environment is not
     *                                properly set.
     */


    public void execute() throws MojoExecutionException
    {
        SettingsUtil.applyCustomSettings( getLog(), repositoryRegistry, settingsPath );

        execute(false);
    }

    private List<String> readPomAttribute(String pomFileLoc, String tag)
    {
        List<String> attributes=new ArrayList<String>();

        try 
        {
            File file = new File(pomFileLoc);

            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
            DocumentBuilder db = dbf.newDocumentBuilder();
            Document doc = db.parse(file);
            doc.getDocumentElement().normalize();

            NodeList nodeLst = doc.getElementsByTagName(tag);

            for (int s = 0; s < nodeLst.getLength(); s++) 
            {
                Node currentNode = nodeLst.item(s);

                NodeList childrenList = currentNode.getChildNodes();

                for (int i = 0; i < childrenList.getLength(); i++)
                {
                    Node child = childrenList.item(i);
                    attributes.add(child.getNodeValue());
                }
            }
        } 
        catch (Exception e) 
        {
            System.out.println("[ERROR] readPomAttribute encountered error, there is a problem with the parsing of the pomfile");
        }

        return attributes;
    }

    private String getContents(File aFile) 
    {
        StringBuilder contents = new StringBuilder();

        try 
        {
          BufferedReader input =  new BufferedReader(new FileReader(aFile));
          try 
          {
            String line = null; //not declared within while loop

            while (( line = input.readLine()) != null)
            {
              contents.append(line);
              contents.append(System.getProperty("line.separator"));
            }
          }
          finally 
          {
            input.close();
          }
        }
        catch (Exception ex)
        {
          System.out.println("[ERROR] Could not get the contents of the given file: "+aFile);
        }

        return contents.toString();
    }

    private void setContents(File aFile, String aContents) throws Exception
    {
        if (aFile == null) 
        {
          throw new Exception("File should not be null.");
        }
        if (!aFile.exists()) {
          throw new Exception ("File does not exist: " + aFile);
        }
        if (!aFile.isFile()) {
          throw new Exception("Should not be a directory: " + aFile);
        }
        if (!aFile.canWrite()) {
          throw new Exception("File cannot be written: " + aFile);
        }

        //use buffering
        Writer output = new BufferedWriter(new FileWriter(aFile));
        try 
        {
          //FileWriter always assumes default encoding is OK!
          output.write( aContents );
        }
        finally {
          output.close();
        }
    }

    private void updateProjectVersion(String assemblyInfoFile, String ver, String dirtyVersion)
    {
        try
        {
            //returns if assemblyInfoFile does not exist
            if(!FileUtils.fileExists(assemblyInfoFile))
            {
                return;
			}
			String contents = getContents(new File(assemblyInfoFile));
			
			//add build number from Hudson (if any)
			String buildNumber = System.getenv("BUILD_NUMBER");// just for Hudson
			String fullVer = buildNumber != null && buildNumber.length() != 0 ? ver + "." + buildNumber : ver;
			
			//check for assembly version
			Boolean atrIsCSharp = assemblyInfoFile.indexOf(".cs") != -1;
			Pattern atrPattern = Pattern.compile("AssemblyVersion\\(.*\\)");
			Matcher m = atrPattern.matcher(contents);
			if(m.find()) //we have some record already, so change it
			{
				m.reset();
				contents = m.replaceAll("AssemblyVersion(\""+fullVer+"\")");
			}
			else //add new
			{
				if (atrIsCSharp)
					contents += "[assembly: AssemblyVersion(\""+fullVer+"\")]";
				else
					contents += "<Assembly: AssemblyVersion(\""+fullVer+"\")>";
			}
			
			
			//check for assembly file version
			atrPattern = Pattern.compile("AssemblyFileVersion\\(.*\\)");
			m = atrPattern.matcher(contents);
			if(m.find()) //we have some record already, so change it
			{
				m.reset();
				contents = m.replaceAll("AssemblyFileVersion(\""+fullVer+"\")");
			}
			else //add new
			{
				if (atrIsCSharp)
					contents += "[assembly: AssemblyFileVersion(\""+fullVer+"\")]";
				else
					contents += "<Assembly: AssemblyFileVersion(\""+fullVer+"\")>";
			}
			
			//check for assembly informational version
			atrPattern = Pattern.compile("AssemblyInformationalVersion\\(.*\\)");
			m = atrPattern.matcher(contents);
			if(m.find()) //we have some record already, so change it
			{
				m.reset();
				contents = m.replaceAll("AssemblyInformationalVersion(\""+dirtyVersion+"\")");
			}
			else //add new
			{
				if (atrIsCSharp)
					contents += "[assembly: AssemblyInformationalVersion(\""+dirtyVersion+"\")]";
				else
					contents += "<Assembly: AssemblyInformationalVersion(\""+dirtyVersion+"\")>";
			}
			/*String checkVersion = "AssemblyFileVersion(\""+ver;
			//modify AssemblyFileInfo if version is different in the pom.
			if(contents.lastIndexOf(checkVersion)==-1)
			{
				try
				{
					contents = contents.substring(0,contents.indexOf("[assembly: AssemblyFileVersion(")) 
					+"[assembly: AssemblyFileVersion(\""+ver+"\")]";
					setContents(new File(assemblyInfoFile),contents);
				}
				// thrown exception if the project type is vb
				catch(Exception e)
				{
					if(contents.lastIndexOf(checkVersion)==-1)
					{
						contents = contents.substring(0,contents.indexOf("<Assembly: AssemblyFileVersion(")) 
						+"<Assembly: AssemblyFileVersion(\""+ver+"\")>";
						setContents(new File(assemblyInfoFile),contents);
					}
				}
			}*/
			
			setContents(new File(assemblyInfoFile),contents);
		}
		catch(Exception e)
		{
		//setContents(new File(assemblyInfoFile),contents);
			System.out.println("[Error] Problem with updating Project File Version");
			e.printStackTrace();
		}
	}
	
	private boolean hasArtifactVersion(File aFile) 
	{
		StringBuilder contents = new StringBuilder();
		boolean hasVersion = false;
		int verCtr=0;
		int buildFlag=0;
		try 
		{
		  BufferedReader input =  new BufferedReader(new FileReader(aFile));
		  try 
		  {
			String line = null; //not declared within while loop
			
			while (( line = input.readLine()) != null)
			{
			  if(line.indexOf("<version>")!=-1)
			  {
				verCtr++;
			  }
			  if(line.indexOf("<build>")!=-1)
			  {
				break;
			  }
			}
			
			if(verCtr==2)
			{
				hasVersion = true;
			}
		  }
		  finally 
		  {
			input.close();
		  }
		}
		catch (Exception ex)
		{
		  
		}
    
		return hasVersion;
	}
	
	private String filterVersion(String version)
	{
		StringBuffer newVersion = new StringBuffer();
		char[] ver = version.toCharArray();
		for(char c : ver)
		{
			if(c!= '.' && !new Character(c).isDigit(c))
			{
				break;
			}
			else
			{
				newVersion.append(c);
			}
		}
		return newVersion.toString();
	}
    
	private void updateAssemblyInfoVersion()
	{
		try
		{
			String currentWorkingDir = System.getProperty("user.dir");
			String ver = "";
			List<String> modules = readPomAttribute(currentWorkingDir+File.separator+"pom.xml","module");
			
			
			//child pom or flat single module without parent tags
			if(modules.size()==0)
			{	
				//get versions in specific project path if executed with CURRENT project option
				List<String> versions = readPomAttribute(currentWorkingDir+File.separator+"pom.xml","version");
				ver = versions.get(0);
				String durtyVer = ver;
				
				//added checking for flat single modules with parent pom
				List<String> parent = readPomAttribute(currentWorkingDir+File.separator+"pom.xml","parent");
				List<String> files = FileUtils.getFiles(new File(currentWorkingDir),"*.csproj,*.sln,*.vbproj","",false);
								
				if(hasArtifactVersion(new File(currentWorkingDir+File.separator+"pom.xml")))
				{
					ver = versions.get(1);
					durtyVer = ver;
					ver = filterVersion(ver);
				}
				else
				{
					ver = filterVersion(ver);
				}
					
				String assemblyInfoFile = currentWorkingDir+File.separator+"Properties"+File.separator+"AssemblyInfo.cs";
				
				if(!FileUtils.fileExists(assemblyInfoFile))
				{
					assemblyInfoFile = currentWorkingDir+File.separator+"My Project"+File.separator+"AssemblyInfo.vb";
				}
				updateProjectVersion(assemblyInfoFile,ver, durtyVer);				
			}
			//parent pom
			else
			{
				if(!modules.isEmpty())
				{
					//check if there is a matching dependency with the namespace
					for(String child : modules)
					{
						String childDir = currentWorkingDir+File.separator+child;
						
						//get versions in parent path if executed with ALL project option
						List<String> versions = readPomAttribute(childDir+File.separator+"pom.xml","version");
						ver = versions.get(0);
						String durtyVer = ver;
				
						//checking if artifact has its own version
						if(hasArtifactVersion(new File(childDir+File.separator+"pom.xml")))
						{
							ver = versions.get(1);
							durtyVer = ver;
							ver = filterVersion(ver);
						}
						else
						{
							ver = filterVersion(ver);
						}
							
						try
						{
							String assemblyInfoFile = childDir+File.separator+"Properties"+File.separator+"AssemblyInfo.cs";
							
							if(!FileUtils.fileExists(assemblyInfoFile))
							{
								assemblyInfoFile = childDir+File.separator+"My Project"+File.separator+"AssemblyInfo.vb";
							}
							updateProjectVersion(assemblyInfoFile,ver, durtyVer);		
						}
						catch(Exception e)
						{
						}
					}
				}
			}
		}
		catch(Exception e)
		{
			System.out.println("[ERROR]UpdateAssemblyInfo -- Encountered a Problem during updateAssemblyInfoVersion");
		}
		
		
	}
	
    protected void execute(boolean test)
            throws MojoExecutionException
    {
        long startTime = System.currentTimeMillis();

        String scope = test ? "test" : "compile";
        try
        {
            AndArtifactFilter filter = new AndArtifactFilter();
            filter.add(new ScopeArtifactFilter(scope));
            filter.add(new InversionArtifactFilter(new DotnetSymbolsArtifactFilter()));

            dependencyResolution.require( project, LocalRepositoryUtil.create( localRepository ), filter );
        }
        catch ( ArtifactResolutionException e )
        {
            throw new MojoExecutionException(
                "NPANDAY-900-010: Could not satisfy required dependencies for scope " + scope, e
            );
        }

        //Modifies the AssemblyInfo.cs files to match the version of the pom
		try
		{
			updateAssemblyInfoVersion();
		}
		catch(Exception e)
		{
		
		}

        initializeDefaults();
  
        try
        {
            CompilerExecutable compilerExecutable = netExecutableFactory.getCompilerExecutable(
                getCompilerRequirement(), getCompilerConfig(), project
            );

            if (!compilerExecutable.shouldCompile()) {
                getLog().debug("NPANDAY-900-011: Compiler vetoed compile, see preceding log entries for details");
                return;
            }

            File compiledArtifact = compilerExecutable.getCompiledArtifact();

            // TODO: see issue with CompilerContextImpl.getArtifact(), which does not incorporate outputDirectory
            if ( outputDirectory != null )
            {
                ArtifactType artifactType = getCompilerConfig().getArtifactType();

                // TODO: shouldn't this use build.finalName?
                compiledArtifact = new File(outputDirectory.getAbsolutePath() + File.separator +
                                            project.getArtifactId() + "." + artifactType.getExtension());
            }

            if (!test)
            {
                // System.Runtime.Versioning.TargetFrameworkAttribute support
                generateAssemblyAttributesIfNecessary(compilerExecutable.getTargetFramework());

                Boolean sourceFilesUpToDate = (Boolean) super.getPluginContext().get("SOURCE_FILES_UP_TO_DATE");
                if ((sourceFilesUpToDate != null && sourceFilesUpToDate) &&
                        System.getProperty("forceCompile") == null && compilerExecutable.getCompiledArtifact() != null &&
                        compilerExecutable.getCompiledArtifact().exists())
                {
                    if (isUpToDateWithPomAndSettingsAndDependencies(compilerExecutable.getCompiledArtifact()))
                    {
                        getLog().info("NPANDAY-900-003: Nothing to compile - all classes are up-to-date");
                        attachArtifact(compiledArtifact, classifier);
                        return;
                    }
                }
            }

            FileUtils.mkdir(project.getBuild().getDirectory());

            long startTimeCompile = System.currentTimeMillis();
            compilerExecutable.execute();
            long endTimeCompile = System.currentTimeMillis();

            getLog().info("NPANDAY-900-004: Compile Time = " + (endTimeCompile - startTimeCompile) + " ms");


            if (!test)
            {
                attachArtifact(compiledArtifact, classifier);
            }

        }
        catch (PlatformUnsupportedException e)
        {
            throw new MojoExecutionException("NPANDAY-900-005: Unsupported Platform: Language = " + language +
                    ", Vendor = " + vendor + ", ArtifactType = " + project.getArtifact().getType(), e);
        }
        catch (ExecutionException e)
        {
            throw new MojoExecutionException("NPANDAY-900-006: Unable to Compile: Language = " + language +
                    ", Vendor = " + vendor + ", ArtifactType = " + project.getArtifact().getType() + ", Source Directory = " +
                    project.getBuild().getSourceDirectory(), e);
        }
        long endTime = System.currentTimeMillis();
        getLog().info("NPANDAY-900-013: Mojo Execution Time = " + (endTime - startTime));
    }

    private void attachArtifact(File artifact, String classifier) {
        if ( isDebug && attachPdb )
        {
            attachPdbArtifact(artifact, classifier);
        }
        if ( classifier != null )
        {
            getLog().debug("NPANDAY-900-014: Attaching artifact " + artifact.getPath() + " with classifier: " + classifier);
            projectHelper.attachArtifact(project, artifact, classifier);
        }
        else
        {
            getLog().debug("NPANDAY-900-015: Attaching default project artifact " + artifact.getPath());
            project.getArtifact().setFile(artifact);
        }
    }

    private void attachPdbArtifact(File artifact, String classifier)
    {
       File artifactDirectory = artifact.getParentFile();
       String pdbName = null;
       if ( pdb != null )
       {
    	   pdbName = pdb;
       }
       else
       {
    	   pdbName = artifact.getName().substring(0,artifact.getName().lastIndexOf("."));
       }
       File pdbFile = new File(artifactDirectory, pdbName + "." + ArtifactType.DOTNET_SYMBOLS.getExtension());
       getLog().debug("NPANDAY-900-016: Attaching pdb project artifact " + pdbFile.getPath());
       projectHelper.attachArtifact(project, ArtifactType.DOTNET_SYMBOLS.getPackagingType(), classifier, pdbFile);
    }

    protected abstract void initializeDefaults() throws MojoExecutionException;

    protected ArrayList<String> convertIncludeSourcesConfiguration(String srcDir, File[] includeSources) throws MojoExecutionException {
        ArrayList<String> srcs = new ArrayList<String>();
        for(File includeSource : includeSources)
        {
            if(includeSource.exists())
            {
                try {
                    // each include is specified relative to the project directory, but the patterns we want are
                    // relative to the source directory
                    srcs.add(org.apache.tools.ant.util.FileUtils.getRelativePath(new File(srcDir), includeSource.getAbsoluteFile()));
                } catch (Exception e) {
                    throw new MojoExecutionException("Unable to find relative path for source: " + e.getMessage(), e);
                }
            }
        }
        return srcs;
    }

    protected abstract ArrayList<String> getParameters();

    protected abstract CompilerRequirement getCompilerRequirement() throws MojoExecutionException;

    protected abstract CompilerConfig getCompilerConfig() throws MojoExecutionException;


    protected String listToCommaDelimitedString(String[] list)
    {
        StringBuffer sb = new StringBuffer();
        boolean flag = false;

        if (list == null || list.length == 0) return "";

        for (String item : list)
        {
            sb.append(flag == true ? "," : "").append(item.trim());

            if (!flag)
            {
                flag = true;
            }
        }
        return sb.toString();

    }


    protected boolean isUpToDateWithPomAndSettingsAndDependencies(File targetFile)
    {
        File settingsFile = PathUtil.buildSettingsFilePath(settingsPath);
        Artifact latestDependencyModification =
                this.getLatestDependencyModification(project.getDependencyArtifacts());

        //TODO: Different parameters from the command line should also cause an update
        //TODO: Change in resource should cause an update
        if (targetFile.lastModified() < pomFile.lastModified())
        {
            getLog().info("NPANDAY-900-007: Project pom has changed. Forcing a recompile.");
            return false;
        }
        else if (settingsFile.exists() && targetFile.lastModified() < settingsFile.lastModified())
        {
            getLog().info("NPANDAY-900-008:Project settings has changed. Forcing a recompile.");
            return false;
        }
        else if (latestDependencyModification != null &&
                targetFile.lastModified() < latestDependencyModification.getFile().lastModified())
        {
            getLog().info(
                    "NPANDAY-900-009: Detected change in module dependency. Forcing a recompile: Changed Artifact = " +
                            latestDependencyModification);
            return false;
        }
        return true;
    }


    protected Artifact getLatestDependencyModification(Set<Artifact> artifacts)
    {
        if (artifacts == null)
        {
            return null;
        }
        Artifact lastModArtifact = null;
        for (Artifact artifact : artifacts)
        {
            if (lastModArtifact == null && !ArtifactTypeHelper.isDotnetAnyGac( artifact.getType() ))
            {
                lastModArtifact = artifact;
            }
            else if (!ArtifactTypeHelper.isDotnetAnyGac( artifact.getType() ) &&
                    artifact.getFile().lastModified() > lastModArtifact.getFile().lastModified())
            {
                lastModArtifact = artifact;
            }
        }
        return lastModArtifact;
    }

    private void generateAssemblyAttributesIfNecessary(String frameworkName) throws MojoExecutionException
    {
        if (frameworkName != null)
        {
            TargetFramework targetFramework = new TargetFramework();
            targetFramework.setFrameworkName(frameworkName);
            //targetFramework.setFrameworkDisplayName(frameworkDisplayName);

            AssemblyInfo assemblyInfo = new AssemblyInfo();
            assemblyInfo.setTargetFramework(targetFramework);

            try
            {
                FileInputStream assemblyAttrsInput = null;
                FileOutputStream assemblyAttrsOutput = null;
                try
                {
                    String sourcesDir = project.getBuild().getDirectory() + "/build-sources";
                    String groupIdAsDir = project.getGroupId().replace( ".", File.separator );

                    File assemblyAttrsDir = new File( sourcesDir + "/META-INF/" + groupIdAsDir );
                    String assemblyAttrsExt = assemblerContext.getClassExtensionFor( language.trim() );
                    File assemblyAttrsFile = new File(assemblyAttrsDir, frameworkName + ".AssemblyAttributes." + assemblyAttrsExt);

                    ByteArrayOutputStream bytesOutput = new ByteArrayOutputStream();
                    AssemblyInfoMarshaller marshaller = assemblerContext.getAssemblyInfoMarshallerFor( language.trim() );
                    marshaller.marshal( assemblyInfo, project, bytesOutput );
                    bytesOutput.close();
                    byte[] byteArrayOutput = bytesOutput.toByteArray();

                    byte[] byteArrayInput = null;
                    if (assemblyAttrsFile.exists())
                    {
                        assemblyAttrsInput = new FileInputStream(assemblyAttrsFile);
                        if (assemblyAttrsInput.available() == byteArrayOutput.length)
                        {
                            byteArrayInput = new byte[byteArrayOutput.length];
                            int bytesRead = assemblyAttrsInput.read(byteArrayInput);
                        }
                    }

                    if (byteArrayInput == null || !Arrays.equals(byteArrayInput, byteArrayOutput))
                    {
                        assemblyAttrsDir.mkdirs();
                        assemblyAttrsOutput = new FileOutputStream(assemblyAttrsFile);
                        assemblyAttrsOutput.write(byteArrayOutput);
                    }

                }
                finally
                {
                    if ( assemblyAttrsOutput != null )
                    {
                        assemblyAttrsOutput.close();
                    }

                    if ( assemblyAttrsInput != null )
                    {
                        assemblyAttrsInput.close();
                    }
                }
            }
            catch ( IOException e )
            {
                throw new MojoExecutionException( "NPANDAY-902-008: Problem generating assembly attributes class", e );
            }
            catch ( AssemblyInfoException e )
            {
                throw new MojoExecutionException( "NPANDAY-902-009: Problem generating assembly attributes class", e );
            }
            catch ( PlatformUnsupportedException e )
            {
                throw new MojoExecutionException( "NPANDAY-902-010: Problem generating assembly attributes class", e );
            }
        }
    }

    public String getLanguageFileExtension() throws MojoExecutionException
    {
        try
        {
            return assemblerContext.getClassExtensionFor( language );
        }
        catch ( PlatformUnsupportedException e )
        {
            throw new MojoExecutionException( "NPANDAY-902-011: Language is not supported: Language = " + language, e );
        }
    }

}