/* ------------------------------------------------------------------------
  File:	  Program
  Module: Vector.ODXStudio.Plugins.SyntaxCheckerPluginExample
---------------------------------------------------------------------------
  Syntax Checker Plugin Example
---------------------------------------------------------------------------
  Copyright (c) Vector Informatik GmbH. All rights reserved.
------------------------------------------------------------------------ */

using System;
using System.Collections.Generic;
using System.IO;
using Vector.ODXStudio.PluginInterfaces;
#if DEBUG

#endif

namespace Vector.ODXStudio.Plugins.SyntaxCheckerPluginExample
{
  public class SyntaxCheckerExamplePlugin : MarshalByRefObject, ISyntaxCheckerPlugin
  {
    private const string NAME = "Syntax Checker Plugin Example";
    private const string DESCRIPTION = "Example implementation of a Syntax Checker Plugin";
    private const string AUTHOR = "Vector Informatik GmbH";
    private string mLastError = string.Empty;

    private SyntaxCheckSummary mSummaryData;
    private List<SyntaxCheckSummaryItem> mItemList;

#if DEBUG 
    private StreamWriter mStreamWriter;
    private const string mDumpFile = "SyntaxCheckerExamplePlugin.txt";
#endif

    #region MarshalByRefObject overrides

    /// <summary>
    /// Assure an infinite lifetime for the object
    /// </summary>
    /// <returns>null</returns>   
    public override object InitializeLifetimeService()
    {
      return null;
    }

    #endregion

    #region Implementation of IPlugin

    /// <summary>
    /// Initialize the Plugin
    /// </summary>
    /// <param name="languageCode">LanguageCode the ODXStudio GUI is running in ("en-US" or "de-DE"). May be used to synchronize Plugin GUI language with ODXStudio.</param>
    public void Initialize(string languageCode)
    {
      //throw new NotImplementedException();
    }

    /// <summary>
    /// Dispose the Plugin
    /// </summary>
    public void Dispose()
    {
      //throw new NotImplementedException();
    }

    /// <summary>
    /// Retrieves description of the last error occurred
    /// </summary>
    /// <returns>
    /// Error text
    /// </returns>
    public string GetLastError()
    {
      return mLastError;
    }

    /// <summary>
    /// Get name of the Plugin
    /// </summary>
    public string Name
    {
      get { return NAME; }
    }

    /// <summary>
    /// Get description of the Plugin
    /// </summary>
    public string Description
    {
      get { return DESCRIPTION; }
    }

    /// <summary>
    /// Get author of the Plugin
    /// </summary>
    public string Author
    {
      get { return AUTHOR; }
    }

    /// <summary>
    /// Get version of the Plugin
    /// </summary>
    public string Version
    {
      get
      {
        Version ver = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
        return string.Format("{0}.{1}.{2}", ver.Major, ver.Minor, ver.Build);
      }
    }

    #endregion

    #region Implementation of ISyntaxCheckerPlugin

    /// <summary>
    /// Configures ODXStudio not to fire CheckElement for certain objects when running the plugin
    /// </summary>
    /// <param name="deRegisterInfo">SyntaxCheckDeRegisterInfo of the plugin</param>
    public void Configure(out SyntaxCheckDeRegisterInfo deRegisterInfo)
    {
      deRegisterInfo = new SyntaxCheckDeRegisterInfo();

      List<SyntaxCheckDeRegisterItem> list = new List<SyntaxCheckDeRegisterItem>();

#if !DEBUG 

      SyntaxCheckDeRegisterItem item = new SyntaxCheckDeRegisterItem
                                         {
                                                 Type = SyntaxCheckDeRegisterItem.DeRegisterType.ElementType,
                                                 Value = "SESSION"
                                         };
      list.Add(item);
#endif

      deRegisterInfo.SyntaxCheckDeRegisterItems = list.ToArray();

      // Init the summary data
      mSummaryData = new SyntaxCheckSummary();
      mItemList = new List<SyntaxCheckSummaryItem>();

#if DEBUG 
      {
        string tempDir = Path.GetTempPath();
        string filePath = Path.Combine(tempDir, mDumpFile);
        FileStream fstream = File.Create(filePath);

        mStreamWriter = new StreamWriter(fstream);
        mStreamWriter.WriteLine("SyntaxCheckerExamplePlugin Dump {0:yyyy-MM-dd HH:mm:ss}", DateTime.Now);

        mItemList.Add(new SyntaxCheckSummaryItem
                        {
                                Severity = SyntaxCheckSummaryItem.ItemSeverity.Info,
                                Category = "INFO",
                                Context = "PLUGIN",
                                Summary = string.Format("Dumping all element data to '{0}'", filePath)
                        });

      }
#endif
    }

    /// <summary>
    /// Called for each element not excluded in the Configure step
    /// </summary>
    /// <param name="elementData">SyntaxCheckElementData for the element to be checked</param>
    /// <returns>
    /// True if check has been performed.
    /// </returns>
    public bool CheckElement(SyntaxCheckElementData elementData)
    {
#if DEBUG 
      {
        mStreamWriter.WriteLine("{0}", elementData.ElementPath);
      }
#endif

      // Traverse the name/value pairs for the element to to the checks
      if (elementData.SyntaxCheckElementProperties.GetLength(0) > 0)
      {
        foreach (var elementProperty in elementData.SyntaxCheckElementProperties)
        {
#if DEBUG 
          if (!string.IsNullOrWhiteSpace(elementProperty.Value))
          {
            mStreamWriter.WriteLine("  {0,-20}:{1}", elementProperty.Name, elementProperty.Value);
          }
#endif

          // Check LONG-NAME
          if (elementProperty.Name == "LONG-NAME")
          {
            if (string.IsNullOrEmpty(elementProperty.Value))
            {
              SyntaxCheckSummaryItem item = new SyntaxCheckSummaryItem
                                              {
                                                      Severity = SyntaxCheckSummaryItem.ItemSeverity.Info,
                                                      Category = "Rule 1",
                                                      Context = elementData.ElementPath,
                                                      Summary = string.Format("Empty LONG-NAME.")
                                              };
              mItemList.Add(item);
            }
          }

          // Do other checks
        }
      }

      return true;
    }

    /// <summary>
    /// Retrieves the summary of the last plugin run
    /// </summary>
    /// <param name="checkSummaryData">SyntaxCheckSummary data for the last plugin run</param><param name="logCheckResult">true if checkSummary shall be written to the StatusWindow and Logfile</param>
    /// <returns>
    /// True if summary could be created
    /// </returns>
    public bool CheckSummary(out SyntaxCheckSummary checkSummaryData, out bool logCheckResult)
    {
      logCheckResult = true;
      mSummaryData.SyntaxCheckSummaryItems = mItemList.ToArray();
      mItemList.Clear();
      checkSummaryData = mSummaryData;

#if DEBUG 
      {
        mStreamWriter.Close();
      }
#endif
      return true;
    }

    #endregion
  }
}