using System;
using System.IO;
using System.Text.RegularExpressions;

using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.DotNet.Tasks;

namespace Nemerle.Tools.NAntTasks
{
  /// <summary>
  /// Compiles Nemerle programs.
  /// </summary>
  [TaskName ("ncc")]
  public class NccTask : CompilerBase
  {
    private static _classNameRegex : Regex =  Regex (@"^((?<comment>/\*.*?(\*/|$))|[\s\.\{]+|class\s+(?<class>\w+)|(?<keyword>\w+))*");
    private static _namespaceRegex : Regex =  Regex (@"^((?<comment>/\*.*?(\*/|$))|[\s\.\{]+|namespace\s+(?<namespace>(\w+(\.\w+)*)+)|(?<keyword>\w+))*");

    /// <summary>
    /// Initialize new instance of the <see cref="T:Nemerle.Tools.NAntTasks.NccTask" />.
    /// </summary>
    public this ()
    {
      SupportsKeyFile = true;
    }

    private static FindExecutable (toolName : string) : string
    {
      def my_file = Uri (typeof (NccTask).Assembly.EscapedCodeBase).LocalPath;
      def ncc_file = Path.Combine (Path.GetDirectoryName (my_file), toolName);

      if (File.Exists (ncc_file)) {
        // The tool found in the same folder.
        //
        ncc_file;
      }
      else {
        // Query the shell association.
        //
        def regPath = $@"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\$toolName.exe";
        def regKey = Microsoft.Win32.Registry.LocalMachine.OpenSubKey (regPath);

        if (regKey != null) {
          // The tool is registered with the Shell API.
          //
          regKey.GetValue (null) :> string;
        }
        else {
          // Return the tool name itself.
          // The environment will search common paths for the tool.
          //
          toolName;
        }
      }
    }

    /// <summary>
    /// The name of the executable that should be used to launch the 
    /// external program.
    /// </summary>
    /// <value>
    /// The name of the executable that should be used to launch the external
    /// program, or <see langword="null" /> if no name is specified.
    /// </value>
    /// <remarks>
    /// If available, the configured value in the NAnt configuration
    /// file will be used if no name is specified.
    /// </remarks>
    public override ExeName : string
    {
      get
      {
        when (base.ExeName == Name)
          base.ExeName = FindExecutable (Name);

        base.ExeName;
      }

      set { base.ExeName = value; }
    }

    /// <summary>
    /// Gets the class name regular expression for the language of the 
    /// current compiler.
    /// </summary>
    /// <value>
    /// Class name regular expression for the language of the current 
    /// compiler.
    /// </value>
    protected override ClassNameRegex : Regex
    {
      get { _classNameRegex; }
    }

    /// <summary>
    /// Gets the namespace regular expression for the language of the
    /// current compiler.
    /// </summary>
    /// <value>
    /// Namespace regular expression for the language of the current 
    /// compiler.
    /// </value>
    protected override NamespaceRegex : Regex
    {
      get { _namespaceRegex; }
    }

    /// <summary>
    /// Gets the command-line arguments for the external program.
    /// </summary>
    /// <value>
    /// The command-line arguments for the external program.
    /// </value>
    public override ProgramArguments : string
    {
      // quoting is done in CompilerBase
      //
      get { "-from-file:" + base.ProgramArguments.Substring (1); }
    }

    /// <summary>
    /// Writes an option using the default output format.
    /// </summary>
    /// <param name="writer">The <see cref="T:System.IO.TextWriter" /> to which the compiler options should be written.</param>
    /// <param name="name">The name of the option which should be passed to the compiler.</param>
    protected override WriteOption (writer : TextWriter, name : string) : void
    {
      writer.WriteLine ("-{0}", name);
    }

    /// <summary>
    /// Writes an option and its value using the default output format.
    /// </summary>
    /// <param name="writer">The <see cref="T:System.IO.TextWriter" /> to which the compiler options should be written.</param>
    /// <param name="name">The name of the option which should be passed to the compiler.</param>
    /// <param name="value">The value of the option which should be passed to the compiler.</param>
    /// <remarks>
    /// The combination of <paramref name="option" /> and 
    /// <paramref name="value" /> (separated by a colon) is quoted
    /// unless <paramref name="value" /> is already surrounded by quotes.
    /// </remarks>
    protected override WriteOption (writer : TextWriter, name : string, arg : string) : void
    {
      writer.WriteLine ((if (arg.StartsWith ("\"") && arg.EndsWith ("\"")) "-{0}:{1}" else "\"-{0}:{1}\""), name, arg);
    } 

    /// <summary>
    /// Writes the compiler options to the specified <see cref="T:System.IO.TextWriter" />.
    /// </summary>
    /// <param name="writer"><see cref="T:System.IO.TextWriter" />
    /// to which the compiler options should be written.</param>
    protected override WriteOptions (writer : TextWriter) : void
    {
      when (DocFile != null) {
        WriteOption (writer, "xml", DocFile.FullName);
      }
      when (Debug) {
        WriteOption (writer, "debug");
        WriteOption (writer, "def", "DEBUG");
        WriteOption (writer, "def", "TRACE");
      }
      when (NoStdLib) {
        WriteOption (writer, "nostdlib");
        WriteOption (writer, "nostdmacros");
      }
      when (Optimize) {
        WriteOption (writer, "Ot");
      }
      WriteOption (writer, "greedy-");
      WriteOption (writer, "no-color");
      WriteOption (writer, "bar-");
    }

    /// <summary>
    /// Determines whether compilation is needed.
    /// </summary>
    protected override NeedsCompiling () : bool
    {
      (DocFile != null &&
        FileSet.FindMoreRecentLastWriteTime (
          DocFile.FullName, OutputFile.LastWriteTime) != null) || base.NeedsCompiling ();
    }

    /// <summary>
    /// Gets the file extension required by the current compiler.
    /// </summary>
    /// <value>
    /// For the Nemerle compiler, the file extension is always <c>n</c>.
    /// </value>
    public override Extension : string
    {
      get { "n"; }
    }

    /// <summary>
    /// The name of the XML documentation file to generate.
    /// </summary>
    /// <remarks>
    /// <para>
    /// Corresponds with the <c>-doc:</c> flag.
    /// </para>
    /// </remarks>
    [TaskAttribute ("doc")]
    public DocFile : FileInfo { get; set; }

    /// <summary>
    /// Instructs the compiler not to import mscorlib.dll. The default is 
    /// <see langword="false" />.
    /// </summary>
    /// <remarks>
    /// <para>
    /// Corresponds with the <c>-nostdlib</c> flag.
    /// </para>
    /// </remarks>
    [TaskAttribute ("nostdlib")]
    [BooleanValidator]
    public NoStdLib : bool { get; set; }

    /// <summary>
    /// Specifies whether the compiler should perform tail call optimizations
    /// to make output files smaller, faster, and more effecient. The default 
    /// is <see langword="false" />.
    /// </summary>
    /// <value>
    /// <see langword="true" /> if the compiler should perform optimizations; 
    /// otherwise, <see langword="false" />.
    /// </value>
    /// <remarks>
    /// <para>
    /// Corresponds with the <c>-general-tail-call-opt</c> flag.
    /// </para>
    /// </remarks>
    [TaskAttribute ("optimize")]
    [BooleanValidator]
    public Optimize : bool { get; set; }
  }
}