using MTC;
using System;
using System.Collections.Generic;

namespace SCMA.AdapterCom
{
  /// <summary>
  /// Gateway di comunicazione secondo diversi standard, partendo da oggetti BASE MTC
  /// </summary>
  public class Gateway
  {

    #region oggetti base

    /// <summary>
    /// Protocollo attivo per la comunicazione dell'adapter
    /// </summary>
    public gwProtocol protocollo;
    /// <summary>
    /// STOBE allarmi:
    /// 1024 bit di strobe degli allarmi attivi (32 word da 4byte/32 bit di flags...)
    /// </summary>
    public byte[] AlarmFlags;
    /// <summary>
    /// Oggetto elenco allarmi
    /// </summary>
    public allarme[] elencoAllarmi;
    /// <summary>
    /// Porta comunicazione standard oggetto
    /// </summary>
    public int port;
    /// <summary>
    /// Stringa di configurazione globale
    /// </summary>
    public string connConfig;
    /// <summary>
    /// Flag per indicare se l'obj stia ancora girando
    /// </summary>
    private bool myRunning = false;
    /// <summary>
    /// Indicatore public di oggetto running running.
    /// </summary>
    public bool Running { get { return myRunning; } }
    /// <summary>
    /// la parte di "mark & sweep" (segnala ed invia) è iniziata e stiamo tracciando le conditions.
    /// </summary>
    bool myBegun = false;
    /// <summary>
    /// Elenco di TUTTI i NODI ITEMS gestiti dal gateway (item/variabile)...
    /// </summary>
    public Dictionary<string, itemNode> itemNodes = new Dictionary<string, itemNode>();
    /// <summary>
    /// Elenco di TUTTI i NODI CONDITIONS gestiti dal gateway (allarme/condizione)...
    /// </summary>
    public Dictionary<string, itemNode> conditionNodes = new Dictionary<string, itemNode>();

    #endregion

    #region gestione globale oggetto

    /// <summary>
    /// init classe come output su LOGFILE
    /// </summary>
    public Gateway()
    {
      port = 0;
      connConfig = "";
      protocollo = gwProtocol.LOGFILE;
    }
    /// <summary>
    /// Inizia la raccolta dati per confronto modifica da precedente...
    /// </summary>
    public virtual void beginDataCollect()
    {
      myBegun = true;
      foreach (object di in itemNodes)
      {
        // inizializza ogni oggetto (in particolare di tipo alarm/conditions x check variazione)
        //di.Begin();
      }
    }
    /// <summary>
    /// Fa la verifica di cosa sia cambiato ed invia
    /// </summary>
    public virtual void sendChanged()
    {
      if (myBegun)
      {
        foreach (object di in itemNodes)
        {
          //di.Prepare();  
        }
      }

#if false
      // Separate out the data items into those that are on one line and those
      // need separate lines.
      List<SimpleDataItem> together = new List<SimpleDataItem>();
      List<SimpleDataItem> separate = new List<SimpleDataItem>();
      foreach (object di in trackItems)
      {
        List<SimpleDataItem> list = di.ItemList();
        if (di.NewLine)
          separate.AddRange(list);
        else
          together.AddRange(list);
      }

      // Compone all the same line data items onto one line.
      string line;
      if (timestamp == null)
      {
        DateTime now = DateTime.UtcNow;
        timestamp = now.ToString("yyyy-MM-dd\\THH:mm:ss.fffffffK");
      }
      if (together.Count > 0)
      {
        line = timestamp;
        foreach (SimpleDataItem di in together)
          line += "|" + di.ToString();
        line += "\n";

        SendToAll(line);
      }

      // Now write out all the separate lines
      if (separate.Count > 0)
      {
        foreach (SimpleDataItem di in separate)
        {
          line = timestamp;
          line += "|" + di.ToString() + "\n";
          SendToAll(line);
        }
      }

      // Flush the output
      FlushAll(); 
#endif

      // Cleanup
      foreach (object di in itemNodes)
      {
        // pulizia oggetti
        //di.Cleanup();
      }
      myBegun = false;
    }
    /// <summary>
    /// Imposta TUTTI i data items unavailable
    /// </summary>
    public virtual void setAllUnavailable()
    {
      foreach (object di in itemNodes)
      {
        //// imposta a unavailable
        //di.Unavailable();
      }
    }
    /// <summary>
    /// AVVIA processo lettura CNC e invio dati a client
    /// </summary>
    public virtual void start()
    {
#if false
      if (!mRunning)
      {
        mListener = new TcpListener(IPAddress.Any, mPort);
        mListener.Start();
        mListenThread = new Thread(new ThreadStart(ListenForClients));
        mListenThread.Start();
      } 
#endif
    }
    /// <summary>
    /// FERMA processo lettura CNC e invio dati a client
    /// </summary>
    public virtual void stop()
    {
#if false
      if (mRunning)
      {
        mRunning = false;
        mListener.Stop();
        foreach (Object obj in mClients)
        {
          Stream client = (Stream)obj;
          client.Close();
        }
        mClients.Clear();

        // Wait 5 seconds for the thread to exit.
        mListenThread.Join(2000);

        // Wait for all client threads to exit.
        mActiveClients.Wait(2000);
      } 
#endif
    }

    #endregion

    #region gestione nodi (dataItems / conditions)

    /// <summary>
    /// Aggiunge un generico item all'elenco di quelli tracciati INDICANDO IL TYPE
    /// </summary>                  
    /// <param name="key"></param>
    /// <param name="value"></param>
    public virtual void addItemNodeByType(string key, itemType tipo)
    {
      if (!itemNodes.ContainsKey(key))
      {
        itemNode currItem = new itemNode(tipo, availStatus.UNAVAILABLE.ToString());
#if false
        // di base salvo tipo/valore come KVP nell'item...
        Dictionary<itemType, object> currObj = new Dictionary<itemType, object>();
        currObj.Add(tipo, "UNAVAILABLE"); 
#endif
        itemNodes.Add(key, currItem);
      }
    }
    /// <summary>
    /// Aggiunge un generico item all'elenco di quelli tracciati INDICANDO IL TYPE ed il valore iniziale
    /// </summary>                  
    /// <param name="key"></param>
    /// <param name="value"></param>
    public virtual void addItemNodeAndSet(string key, itemType tipo, object value)
    {
      addItemNodeByType(key, tipo);
      updateItemNodeValue(key, value);
    }
    /// <summary>
    /// Aggiunge un generico item all'elenco di quelli tracciati (NON STRONGLY TYPED!!! occhio!!!)
    /// </summary>                  
    /// <param name="key"></param>
    /// <param name="value"></param>
    public virtual void addItemNode(string key, object value)
    {
      // se non c'è già elemento lo aggiungo...
      if (!itemNodes.ContainsKey(key))
      {
        // default: event...
        itemNode currItem = new itemNode(itemType.Event, value);
        itemNodes.Add(key, currItem);
      }
    }
    public virtual void addItemNode(object value)
    {
      if (!itemNodes.ContainsKey(value.ToString()))
      {
        // default: event...
        itemNode currItem = new itemNode(itemType.Event, value);
        itemNodes.Add(value.ToString(), currItem);
      }
    }
    /// <summary>
    /// Rimuove TUTTI i data items tracciati
    /// </summary>
    public virtual void removeAllItemNodes()
    {
      itemNodes.Clear();
    }
    /// <summary>
    /// Rimuove un item dall'elenco di quelli tracciati
    /// </summary>
    /// <param name="key"></param>
    public virtual void removeItemNode(string key)
    {
      itemNodes.Remove(key);
    }
    /// <summary>
    /// RESTITUISCE un item da KEY
    /// </summary>                  
    /// <param name="key"></param>
    public virtual object getItemNode(string key)
    {
      return itemNodes[key].cObject;
    }
    /// <summary>
    /// AGGIORNA un generico item all'elenco di quelli tracciati (NON STRONGLY TYPED!!! occhio!!!)
    /// </summary>                  
    /// <param name="key"></param>
    /// <param name="value"></param>
    public virtual void updateItemNodeValue(string key, object value)
    {
      itemNodes[key].cObject = value;
    }
    /// <summary>
    /// AGGIORNA un generico item all'elenco di quelli tracciati (NON STRONGLY TYPED!!! occhio!!!)
    /// </summary>                  
    /// <param name="key"></param>   
    /// <param name="code"></param>
    /// <param name="value"></param>
    public virtual void updateItemNodeCodeValue(string key, string code, object value)
    {
      itemNodes[key].cObject = value;
    }

    /// <summary>
    /// Aggiunge un generico item all'elenco di quelli tracciati (NON STRONGLY TYPED!!! occhio!!!)
    /// </summary>                     
    /// <param name="key"></param>    
    /// <param name="value"></param>
    public virtual void addConditionNode(string key, object value)
    {
      // se non c'è già elemento lo aggiungo...
      if (!conditionNodes.ContainsKey(key))
      {
        // default: event...
        itemNode currItem = new itemNode(itemType.Condition, value);
        conditionNodes.Add(key, currItem);
      }
    }
    /// <summary>
    /// Rimuove TUTTI i CONDITION NODES tracciati
    /// </summary>
    public virtual void removeAllConditionNodes()
    {
      conditionNodes.Clear();
    }
    /// <summary>
    /// Rimuove un CONDITION NODE dall'elenco di quelli tracciati
    /// </summary>
    /// <param name="key">chaive</param>
    public virtual void removeConditionNode(string key)
    {
      conditionNodes.Remove(key);
    }

    #endregion

    #region gestione allarmi

    /// <summary>
    /// processo il vettore LOCALE degli allarmi
    /// </summary>
    public virtual void processAlarm()
    {
      if (AlarmFlags != null)
      {
        // variabili helper
        StFlag32 AlarmBlock = 0;
        allarme currAllarm;
        // controllo TUTTI i bit della variabile COMPLETA degli status allarmi: se ce ne sono di alzati DEVO processare...
        for (int i = 0; i < AlarmFlags.Length / 4; i++)
        {
          // leggo 32bit alla volta...
          AlarmBlock = (StFlag32)BitConverter.ToUInt32(AlarmFlags, i * 4);
          for (int j = 0; j < 32; j++)
          {
            // converto! e aggiungo allarmi sollevati al corretto controller allarmi...
            if (AlarmBlock.HasFlag((StFlag32)Math.Pow(2, j)))
            {
              // recupero allarme da oggetto in memoria...
              currAllarm = elencoAllarmi[i * 32 + j];
              addAlarm(currAllarm);
            }
          }
        }
      }
    }
    /// <summary>
    /// SETUP oggetti gestione allarmi
    /// </summary>
    public virtual void addAlarmNodes()
    {
      // minimo sempre PLC/CNC       
      addConditionNode("CNC", "CNC");
      addConditionNode("PLC", "PLC");
    }
    /// <summary>
    /// INIT allarmi a normal
    /// </summary>
    public virtual void initAlarms()
    {
    }
    /// <summary>
    /// INIT di un SINGOLO NODO di allarme a normal
    /// </summary>
    /// <param name="alarmNode"></param>
    public virtual void initAlarm(itemNode alarmNode)
    {
    }
    /// <summary>
    /// Aggiunta SINGOLO allarme su GENERICO (global) nodo
    /// </summary>                          
    /// <param name="currAllarm">Allarme da riportare al nodo</param>
    public virtual void addAlarm(allarme currAllarm)
    {
#if false
      // in base al tipo di allarme decodifico condizione...
      Condition.Level livello = Condition.Level.NORMAL;
      switch (currAllarm.livello)
      {
        case "WARNING":
          livello = Condition.Level.WARNING;
          break;
        case "FAULT":
        default:
          livello = Condition.Level.FAULT;
          break;
      }
      // in base al gruppo decido dove assegnare come CONDITION...
      switch (currAllarm.gruppo)
      {
        case "PLC":
          mAlarmPLC.Add(livello, currAllarm.descrizione, currAllarm.codNum, "", "");
          break;
        case "CNC":
        default:
          mAlarmCNC.Add(livello, currAllarm.descrizione, currAllarm.codNum, "", "");
          break;
      } 
#endif
    }
    /// <summary>
    /// Aggiunta SINGOLO allarme su SPECIFICO nodo
    /// </summary>                          
    /// <param name="alarmNode">Generico nodo di tipo condition</param>
    /// <param name="currAllarm">Allarme da riportare al nodo</param>
    public virtual void addAlarm(itemNode alarmNode, allarme currAllarm)
    {
#if false
      // in base al tipo di allarme decodifico condizione...
      Condition.Level livello = Condition.Level.NORMAL;
      switch (currAllarm.livello)
      {
        case "WARNING":
          livello = Condition.Level.WARNING;
          break;
        case "FAULT":
        default:
          livello = Condition.Level.FAULT;
          break;
      }
      // in base al gruppo decido dove assegnare come CONDITION...
      switch (currAllarm.gruppo)
      {
        case "PLC":
          mAlarmPLC.Add(livello, currAllarm.descrizione, currAllarm.codNum, "", "");
          break;
        case "CNC":
        default:
          mAlarmCNC.Add(livello, currAllarm.descrizione, currAllarm.codNum, "", "");
          break;
      } 
#endif
    }
    /// <summary>
    /// RESTITUISCE un nodo CONDITION da KEY
    /// </summary>                  
    /// <param name="key"></param>
    public virtual object getAlarmNode(string key)
    {
      return conditionNodes[key];
    }

    #endregion

  }
  /// <summary>
  /// Classe item node (tipo/obj)
  /// </summary>
  public class itemNode
  {
    /// <summary>
    /// Tipo oggetto (per cast)
    /// </summary>
    public itemType cType;
    /// <summary>
    /// Object specifico
    /// </summary>
    public object cObject;
    /// <summary>
    /// costruttore
    /// </summary>
    public itemNode()
    { }
    /// <summary>
    /// costruttore
    /// </summary>
    /// <param name="_tipo"></param>
    /// <param name="_obj"></param>
    public itemNode(itemType _tipo, object _obj)
    {
      cType = _tipo;
      cObject = _obj;
    }
  }

  /// <summary>
  /// Tipologia protocolli di comunicazione ammessi
  /// </summary>
  public enum gwProtocol
  {
    /// <summary>
    /// NESSUN protocollo reale --> FILE DUMP sul log...
    /// </summary>
    LOGFILE,
    /// <summary>
    /// Protocollo di comunicazione MTConnect
    /// </summary>
    MTC,
    /// <summary>
    /// Protocollo di comunicazione SCM.OPC.UA.REDIS.SERVER
    /// </summary>
    SOURS
  }
  /// <summary>
  /// Tipologia di ITEM
  /// </summary>
  public enum itemType
  {
    /// <summary>
    /// CONDIZION = ALLARME
    /// </summary>
    Condition,
    /// <summary>
    /// Evento = point in time data
    /// </summary>
    Event,
    /// <summary>
    /// Messaggio generico
    /// </summary>
    Message,
    /// <summary>
    /// Campionamento continuo
    /// </summary>
    Sample
  }
  /// <summary>
  /// Varibili STATO ATTIVO (es attuatori, sistemi...)
  /// </summary>
  public enum actStatus
  {
    /// <summary>
    /// Stato inattivo
    /// </summary>
    INACTIVE = 0,
    /// <summary>
    /// Stato Attivo
    /// </summary>
    ACTIVE
  }
  /// <summary>
  /// Varibili STATO OnOff
  /// </summary>
  public enum onOffStatus
  {
    /// <summary>
    /// Stato OFF
    /// </summary>
    OFF = 0,
    /// <summary>
    /// Stato ON
    /// </summary>
    ON
  }
  /// <summary>
  /// Varibili STATO per EMERGENZA
  /// </summary>
  public enum emStatus
  {
    /// <summary>
    /// Stato ARMATO
    /// </summary>
    ARMED = 0,
    /// <summary>
    /// Stato EMERGENZA PREMUTA
    /// </summary>
    TRIGGERED
  }
  /// <summary>
  /// Varibili STATO per AVAIL
  /// </summary>
  public enum availStatus
  {
    /// <summary>
    /// Stato DISPONIBILE
    /// </summary>
    AVAILABLE = 0,
    /// <summary>
    /// Stato NON disponibile
    /// </summary>
    UNAVAILABLE
  }
  /// <summary>
  /// Varibili STATO per AVAIL
  /// </summary>
  public enum pathType
  {
    /// <summary>
    /// Stato LAVORO
    /// </summary>
    LAVORO = 0,
    /// <summary>
    /// Stato ASSERV
    /// </summary>
    ASSERV
  }
}