using System;
using System.IO;
using System.Xml.Serialization;

namespace SCMA
{
  #region -- ModelDesign Class --

  /// <summary>
  /// Classe per serializzazione / deserializzazione del datamodel x le informazioni necessarie x ADAPTER OPC-UA 2.1+
  /// 
  /// ref: http://www.cambiaresearch.com/articles/33/how-can-i-easily-manage-an-xml-configuration-file-in-dotnet
  /// </summary>
  [Serializable]
  [XmlRoot("ModelDesign")]
  public class ModelDesign
  {

    cMachine mMachine;

#if false
    string sNomeAdapt;
    int nVers;
    double tContOreMaccOn;
    double tContOreMaccLav;
    double tContSlittaTast;
    int[] _ContGiriElettrom;
    float[] _ContKmMovAssi;
    tipoAdapter etipoAdapt;

    element[] _VacuumPump;
    element[] _VacuumAct;
    element[] _Lubro;
    element[] _SlittaMag;
    element[] _ProtMag;
    element[] _Cooler;
    element[] _Press;
    element[] _Temp;
    element[] _Path;
    element[] _UnOp;
    element[] _Axis;
    element[] _MemArea; 
#endif

    /// <summary>
    /// init conf adapter
    /// </summary>
    public ModelDesign()
    {
#if false
      sNomeAdapt = "";
      etipoAdapt = tipoAdapter.DEMO; 
#endif
    }

    /// <summary>
    /// Classe di base oggetti OPC-UA in Datamodel da deserializzare
    /// </summary>
    public class ouBaseObj
    {
      //[XmlAttribute("SymbolicName")]
      [XmlAttribute]
      public string SymbolicName { get; set; }
      [XmlAttribute("BrowseName")]
      public string BrowseName { get; set; }
      [XmlAttribute("DataType")]
      public string DataType { get; set; }
      [XmlAttribute("ValueRank")]
      public string ValueRank { get; set; }
    }

    public class Property : ouBaseObj
    {
      [XmlAttribute("Value")]
      public string Value { get; set; }
    }

    public class ouVariable : ouBaseObj
    {
      [XmlAttribute("Units")]
      public string Units { get; set; }
    }

    /// <summary>
    /// Oggetto più esterno Machine
    /// </summary>
    [Serializable]
    public class cMachine
    {
      public Property Model { get; set; }
    }

    public cMachine Machine
    {
      get
      {
        return mMachine;
      }
      set
      {
        mMachine = value;
      }
    }

    

#if false
    public int nVacuumPump
    {
      get
      {
        int answ = 0;
        if (VacuumPump != null)
        {
          try
          {
            answ = Convert.ToInt32(VacuumPump.Length);
          }
          catch
          { }
        }
        return answ;
      }
    }
    public int nVacuumAct
    {
      get
      {
        int answ = 0;
        if (VacuumAct != null)
        {
          try
          {
            answ = Convert.ToInt32(VacuumAct.Length);
          }
          catch
          { }
        }
        return answ;
      }
    }
    public int nLubro
    {
      get
      {
        int answ = 0;
        if (Lubro != null)
        {
          try
          {
            answ = Convert.ToInt32(Lubro.Length);
          }
          catch
          { }
        }
        return answ;
      }
    }
    public int nSlittaMag
    {
      get
      {
        int answ = 0;
        if (SlittaMag != null)
        {
          try
          {
            answ = Convert.ToInt32(SlittaMag.Length);
          }
          catch
          { }
        }
        return answ;
      }
    }
    public int nProtMag
    {
      get
      {
        int answ = 0;
        if (ProtMag != null)
        {
          try
          {
            answ = Convert.ToInt32(ProtMag.Length);
          }
          catch
          { }
        }
        return answ;
      }
    }
    public int nCooler
    {
      get
      {
        int answ = 0;
        if (Cooler != null)
        {
          try
          {
            answ = Convert.ToInt32(Cooler.Length);
          }
          catch
          { }
        }
        return answ;
      }
    }
    public int nPress
    {
      get
      {
        int answ = 0;
        if (Press != null)
        {
          try
          {
            answ = Convert.ToInt32(Press.Length);
          }
          catch
          { }
        }
        return answ;
      }
    }
    public int nTemp
    {
      get
      {
        int answ = 0;
        if (Temp != null)
        {
          try
          {
            answ = Convert.ToInt32(Temp.Length);
          }
          catch
          { }
        }
        return answ;
      }
    }
    public int nPath
    {
      get
      {
        int answ = 0;
        if (Path != null)
        {
          try
          {
            answ = Convert.ToInt32(Path.Length);
          }
          catch
          { }
        }
        return answ;
      }
    }
    public int nUnOp
    {
      get
      {
        int answ = 0;
        if (UnOp != null)
        {
          try
          {
            answ = Convert.ToInt32(UnOp.Length);
          }
          catch
          { }
        }
        return answ;
      }
    }
    public int nAxis
    {
      get
      {
        int answ = 0;
        if (Axis != null)
        {
          try
          {
            answ = Convert.ToInt32(Axis.Length);
          }
          catch
          { }
        }
        return answ;
      }
    }
    public int nMemArea
    {
      get
      {
        int answ = 0;
        if (MemArea != null)
        {
          try
          {
            answ = Convert.ToInt32(MemArea.Length);
          }
          catch
          { }
        }
        return answ;
      }
    }

#endif

    /// <summary>
    /// Serializzazione XML dell'oggetto conf dell'adapter
    /// </summary>
    /// <param name="file"></param>
    /// <param name="c"></param>
    public static void Serialize(string file, ModelDesign c)
    {
      // prima provo a creare il file vuoto...
      if (!File.Exists(file))
      {
        string dirPath = file.Substring(0, file.LastIndexOf('\\'));
        // verifico directory
        if (!Directory.Exists(dirPath))
        {
          Directory.CreateDirectory(dirPath);
        }
      }
      // salvo effettivamente file...
      XmlSerializer xs = new XmlSerializer(c.GetType());
      StreamWriter writer = File.CreateText(file);
      xs.Serialize(writer, c);
      writer.Flush();
      writer.Close();
    }
    /// <summary>
    /// deserializzazione oggetto conf adapter
    /// </summary>
    /// <param name="file"></param>
    /// <returns></returns>
    public static ModelDesign Deserialize(string file)
    {
      XmlSerializer xs = new XmlSerializer(typeof(ModelDesign));
      StreamReader reader = File.OpenText(file);
      ModelDesign c = (ModelDesign)xs.Deserialize(reader);
      reader.Close();
      return c;
    }
    /// <summary>
    /// restitusice forma XML grezza del file
    /// </summary>
    /// <param name="file"></param>
    /// <returns></returns>
    public static string rawXml(string file)
    {
      string answ = "";
      XmlSerializer xs = new XmlSerializer(typeof(ModelDesign));
      StreamReader reader = File.OpenText(file);
      answ = reader.ReadToEnd();
      reader.Close();
      return answ;
    }

#if false
    public int Version
    {
      get { return nVers; }
      set { nVers = value; }
    }
    public string NomeAdapt
    {
      get { return sNomeAdapt; }
      set { sNomeAdapt = value; }
    }
    public tipoAdapter TipoAdapt
    {
      get { return etipoAdapt; }
      set { etipoAdapt = value; }
    }
    public double ContOreMaccOn
    {
      get { return tContOreMaccOn; }
      set { tContOreMaccOn = value; }
    }
    public double ContOreMaccLav
    {
      get { return tContOreMaccLav; }
      set { tContOreMaccLav = value; }
    }
    public double ContSlittaTast
    {
      get { return tContSlittaTast; }
      set { tContSlittaTast = value; }
    }
    public int[] ContGiriElettrom
    {
      get { return _ContGiriElettrom; }
      set { _ContGiriElettrom = value; }
    }
    public float[] ContKmMovAssi
    {
      get { return _ContKmMovAssi; }
      set { _ContKmMovAssi = value; }
    }
    public element[] VacuumPump
    {
      get { return _VacuumPump; }
      set { _VacuumPump = value; }
    }
    public element[] VacuumAct
    {
      get { return _VacuumAct; }
      set { _VacuumAct = value; }
    }
    public element[] Lubro
    {
      get { return _Lubro; }
      set { _Lubro = value; }
    }
    public element[] SlittaMag
    {
      get { return _SlittaMag; }
      set { _SlittaMag = value; }
    }
    public element[] ProtMag
    {
      get { return _ProtMag; }
      set { _ProtMag = value; }
    }
    public element[] Cooler
    {
      get { return _Cooler; }
      set { _Cooler = value; }
    }
    public element[] Press
    {
      get { return _Press; }
      set { _Press = value; }
    }
    public element[] Temp
    {
      get { return _Temp; }
      set { _Temp = value; }
    }
    public element[] Path
    {
      get { return _Path; }
      set { _Path = value; }
    }
    public element[] UnOp
    {
      get { return _UnOp; }
      set { _UnOp = value; }
    }
    public element[] Axis
    {
      get { return _Axis; }
      set { _Axis = value; }
    }
    public element[] MemArea
    {
      get { return _MemArea; }
      set { _MemArea = value; }
    }

#endif
  }

#if false

  [Serializable]
  [XmlType(TypeName = "dataRef")]
  public struct DataRefItem<K, V>
  {
    public K Key { get; set; }
    public V Value { get; set; }

    public DataRefItem(K k, V v) : this() { Key = k; Value = v; }
  }

  /// <summary>
  /// classe elemento base in cui salvare i dati di conf x recupero dati adapters
  /// </summary>
  public class element
  {
    /// <summary>
    /// identificativo univoco x classe di elemento
    /// </summary>
    public string ident;
    /// <summary>
    /// Elenco riferimento dati x recupero (es posizioni memoria separate da #)
    /// </summary>
    public List<DataRefItem<string, string>> dataRefList;

    /// <summary>
    /// init empty
    /// </summary>
    public element()
    {
      ident = "";
      dataRefList = new List<DataRefItem<string, string>>();
    }
    /// <summary>
    /// init element con dati
    /// </summary>
    /// <param name="Idx">Identificativo univoco</param>
    /// <param name="DataRef">Parametri x recupero dati in forma dictionary</param>
    public element(string Idx, List<DataRefItem<string, string>> DataRef)
    {
      ident = Idx;
      dataRefList = DataRef;
    }
  }

#endif

  #endregion
}