using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Reflection;
 
namespace S_MzH.Update
{
  /// <summary>
  /// Diese Klasse ist dafür gedacht einige Informationen für das Update zurückzugeben.
  /// </summary>
  class UpdateInfo : IComparable
  {
    // Einige Variablen die benötigt werden
    private string m_sFileName = String.Empty;
    private string m_sLocalPath = String.Empty;
    private string m_sServerPath = String.Empty;
    private string m_sServerVersion = String.Empty;
    private string m_sLocalVersion = String.Empty;
    private DateTime m_dtServerWriteTime = DateTime.Now;
    private DateTime m_dtLocalWriteTime = DateTime.Now;
    private bool m_bUpToDate;
 
    /// <summary>
    /// Die interne Methode zum Überprüfen ob es ein Update gibt
    /// </summary>
    private void CheckUpdate()
    {
      string sFileExtension = Path.GetExtension(m_sFileName).ToLower();
 
      m_bUpToDate = true;
      // Die Version der Datei muss nur überprüft werden,
      // wenn es sich um eine .exe, .dll oder .msi Datei handelt
      if ((sFileExtension == ".exe") || (sFileExtension == ".dll") || (sFileExtension == ".msi"))
      {
        try
        {
          m_sServerVersion = Assembly.LoadFrom(m_sServerPath + m_sFileName).FullName;
          m_sServerVersion = m_sServerVersion.Split(',')[1].Trim();
          m_sServerVersion = m_sServerVersion.Substring(m_sServerVersion.IndexOf('=') + 1);
        }
        catch (Exception ex)
        {
          throw new ArgumentException(ex.Message);
        }
 
        try
        {
          m_sLocalVersion = Assembly.LoadFrom(m_sLocalPath + m_sFileName).FullName;
          m_sLocalVersion = m_sLocalVersion.Split(',')[1].Trim();
          m_sLocalVersion = m_sLocalVersion.Substring(m_sLocalVersion.IndexOf('=') + 1);
        }
        catch
        {
          m_sLocalVersion = String.Empty;
        }
 
        // Ist die Server Datei aktueller als die Lokale Datei?
        if (m_sLocalVersion.CompareTo(m_sServerVersion) < 0)
          m_bUpToDate = false;
      }
      try
      {
        m_dtServerWriteTime = File.GetLastWriteTime(m_sServerPath + m_sFileName);
        m_dtLocalWriteTime = File.GetLastWriteTime(m_sLocalPath + m_sFileName);
 
        // Wurde die Server Datei zuletzt beschrieben?
        if ((m_dtServerWriteTime.Subtract(m_dtLocalWriteTime)).Ticks > 0)
          m_bUpToDate = false;
      }
      catch (Exception ex)
      {
        throw new ArgumentException(ex.Message);
      }
    }
 
    /// <summary>
    /// Im Konstruktor wird die Datei hinzugefügt und überprüft od diese aktuell ist.
    /// </summary>
    /// <param name="FileName">Dateiname mit Endung</param>
    /// <param name="ServerPath">Der Pfad in dem sich die aktuellen Dateien befinden. Achtung: Ein \ muss am Ende stehen!</param>
    /// <param name="LocalPath">Der Pfad in dem sich die zu überprüfenden Dateien befinden. Achtung: Ein \ muss am Ende stehen!</param>
    public UpdateInfo(string FileName, string ServerPath, string LocalPath)
    {
      // Speichern Datei-Eigenschaften
      m_sFileName = FileName;
      m_sServerPath = ServerPath;
      m_sLocalPath = LocalPath;
 
      // Überprüfen ob die Datei UpToDate ist
      CheckUpdate();
    }
 
    /// <summary>
    /// Gibt den Dateinamen zurück
    /// </summary>
    public string FileName
    {
      get { return m_sFileName; }
    }
 
    /// <summary>
    /// Gibt den Pfad zurück indem die zu überprüfende Datei liegt
    /// </summary>
    public string LocalPath
    {
      get { return m_sLocalPath; }
    }
 
    /// <summary>
    /// Gibt den Pfad zurück in dem sich die aktuelle Dateien befinden
    /// </summary>
    public string ServerPath
    {
      get { return m_sServerPath; }
    }
 
    /// <summary>
    /// Wenn es sich um eine .exe, .dll oder .msi Datei handelt dann wird die Version zurückgegeben.
    /// Sonst wird ein leerer String zurückgegeben.
    /// </summary>
    public string ServerVersion
    {
      get { return m_sServerVersion; }
    }
 
    /// <summary>
    /// Wenn es sich um eine .exe, .dll oder .msi Datei handelt dann wird die Version zurückgegeben.
    /// Sonst wird ein leerer String zurückgegeben.
    /// </summary>
    public string LocalVersion
    {
      get { return m_sLocalVersion; }
    }
 
    /// <summary>
    /// Wenn die Datei aktuell ist, dann gibt es true zurück
    /// </summary>
    public bool UpToDate
    {
      get { return m_bUpToDate; }
    }
 
    /// <summary>
    /// Interne Vergleich der UpdateInfo Elementen
    /// Es wird nach dem Dateinamen sortiert.
    /// </summary>
    /// <param name="ui"></param>
    /// <returns></returns>
    private int InternalCompare(UpdateInfo ui)
    {
      string sFirstFileName = m_sFileName;
      string sSecondFileName = ui.FileName;
 
      return sFirstFileName.CompareTo(sSecondFileName);
    }
 
    /// <summary>
    /// Liefert den Dateinamen und den Status zurück
    /// </summary>
    /// <returns></returns>
    public override string ToString()
    {
      string ret = m_sFileName + " : UpToDate=" + m_bUpToDate.ToString();
      return ret;
    }
 
    /// <summary>
    /// Es wird der Dateiname verglichen.
    /// </summary>
    /// <param name="o"></param>
    /// <returns></returns>
    public int CompareTo(object o)
    {
      UpdateInfo ui = (o as UpdateInfo);
      if (ui == null)
        throw new ArgumentException ("Das übergebene Objekt muss vom Typ \"UpdateInfo\" sein!");
      else
        return InternalCompare(ui);
    }
  }
}