using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
//-----
using System.IO.Ports;
using System.IO;


namespace comSobitie
{
    public partial class Form1 : Form
    {
        
        // Таймер
        Timer timer = new Timer();
        // Порт
        SerialPort port = new SerialPort("COM2", 9600, System.IO.Ports.Parity.None, 8, System.IO.Ports.StopBits.One);
        string valu = "";
        String indata = "";
        public Form1()
        {
            InitializeComponent();
           System.Windows.Forms.Control.CheckForIllegalCrossThreadCalls = false;  //ОЧЕНЬ СПОРНОЕ РЕШЕНИЕ !!!!!!!!!!
            // Подписались на приход данных
            port.DataReceived += new SerialDataReceivedEventHandler(port_DataReceived);

            // Задаем интервал таймеру
            timer.Interval = 10000;
            // Подписываемся на тики таймера
            timer.Tick += new EventHandler(timer1_Tick);
            // Стартуем таймер
            timer.Start(); 
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            // Открываем порт
            if (port.IsOpen)
            {
                // Если порт открыт, значит какой-то косяк, девайс не ответил, здесь обрабатываем

                // Закрываем
                port.Close();
            }

            // Открываем
            port.Open();

            // Чето посылаем
            port.Write("#10\r");
        }
        int i = 0;
        // Пришли данные
        void port_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
                 System.Threading.Thread.Sleep(100);
                // Получаем пришедшие данные
                indata = port.ReadExisting();
                
                // Чето с ними делаем

                textBox1.Text = " SELECT  \"ID_TagName\"" + indata + " ;";
      
                // Закрываем порт
                if (port.IsOpen) port.Close();                      
           
        }

    }
}

    /// <summary>
    /// Класс работы с последовательным портом
    /// </summary>
    public class SerialPort : IDisposable
    {
        //--------------------------------------------------------------------------
        //Construction, Destruction
        //--------------------------------------------------------------------------
        #region Construction, Destruction
        /// <summary>
        /// Оболочка для работы с СОМ-портом
        /// </summary>
        /// <param name="comNum">Номер СОМ-порта</param>
        /// <param name="baudRate">Скорость</param>
        public SerialPort(byte comNum, int baudRate)
        {
            this.comNum = comNum;
            serialPort = new System.IO.Ports.SerialPort("COM" + comNum.ToString(), baudRate);
            serialPort.Open();
            thread = new System.Threading.Thread(ThreadFn);
            thread.Start();
        }
        
        /// <summary>
        /// Очистка ресурсов
        /// </summary>
        public void Dispose()
        {
            DisposeImpl(true);
        }
        
        /// <summary>
        /// Finalizer
        /// </summary>
        ~SerialPort()
        {
            DisposeImpl(false);
        }

        private void DisposeImpl(bool manualDispose)
        {
            if (manualDispose)
            {
                if (thread != null)
                    thread.Abort();
                if (serialPort != null)
                    serialPort.Dispose();
            }
        }
        #endregion Construction, Destruction

        //--------------------------------------------------------------------------
        //Public Interface
        //--------------------------------------------------------------------------
        #region Public Interface
        /// <summary>
        /// Отправить данные
        /// </summary>
        /// <param name="data">Массив данных</param>
        /// <exception cref="Exception">Генерируется, если при работе с последовательным портом
        /// возникнет исключение</exception>
        public void SendData(Byte[] data)
        {
            serialPort.Write(data, 0, data.Length);
        }
        
        /// <summary>
        /// Текущий номер СОМ-порта
        /// </summary>
        public Byte ComNum
        {
            get { return comNum; }
            set
            {
                if (comNum != value)
                {
                    comNum = value;
                    serialPort.Close();
                    serialPort.PortName = "COM" + value.ToString();
                }
            }
        }

        /// <summary>
        /// Скорость передачи данных
        /// </summary>
        public int BaudRate
        {
            get { return serialPort.BaudRate; }
            set { serialPort.BaudRate = value; }
        }
        /// <summary>
        /// Состояние линии Dtr
        /// </summary>
        public bool DtrEnable
        {
            get { return serialPort.DtrEnable; }
            set { serialPort.DtrEnable = value; }
        }
        /// <summary>
        /// Состояние линии Rts
        /// </summary>
        public bool RtsEnable
        {
            get { return serialPort.RtsEnable; }
            set { serialPort.RtsEnable = value; }
        }

        /// <summary>
        /// Делегат приема байта
        /// </summary>
        /// <param name="data">Принятый байт данных</param>
        public delegate void OnByteReceived(Byte data);

        /// <summary>
        /// Событие приема байт
        /// </summary>
        public event OnByteReceived ByteReceived;
        #endregion Public Interface

        //--------------------------------------------------------------------------
        //Private Member Functions
        //--------------------------------------------------------------------------
        #region Private Member Functions
        //Обработка принятого байта
        private void OnReceiveByte(Byte data)
        {
            //Если на событие приема байт кто-то подписан, то отправляю ему байт
            if (ByteReceived != null)
                ByteReceived(data);
        }
        //Функция чтения данных в новом потоке
        private void ThreadFn(object obj)
        {
            //создаю входной буффер. Сюда будут писаться данные из последовательного порта
            Byte[] inputBuffer = new Byte[inputBufferSize];
            while (true)
            {

                try
                {
                    //получаю количество доступных байт
                    int availibleBytes = serialPort.BytesToRead;
                    if (availibleBytes > 0)
                    {
                        int bytesToRead = availibleBytes < inputBufferSize ? availibleBytes : inputBufferSize;
                        int readedBytes = serialPort.Read(inputBuffer, 0, bytesToRead);
                        for (int i = 0; i < readedBytes; i++)
                            OnReceiveByte(inputBuffer[i]);
                    }
                    System.Threading.Thread.Sleep(1);
                }
                catch (System.Threading.ThreadAbortException)
                {
                    break;
                }
                catch (Exception e)
                {
                    System.Diagnostics.Debug.Assert(false, e.Message);
                }
            }
        }
        #endregion Private Member Functions

        //--------------------------------------------------------------------------
        //Private Data Members
        //--------------------------------------------------------------------------
        #region Private Data Members
        /// <summary>
        /// Номер СОМ-порта
        /// </summary>
        private Byte comNum;
        /// <summary>
        /// Последовательный порт
        /// </summary>
        private System.IO.Ports.SerialPort serialPort;
        /// <summary>
        /// Поток. Нужен, т.к. данные читаются в новом потоке
        /// </summary>
        private System.Threading.Thread thread;
        /// <summary>
        /// Максимальный размер входного буффер
        /// </summary>
        private const int inputBufferSize = 1024;

        #endregion Private Data Members
    }//class RS232

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.ServiceProcess;
using System.Text;
///----
using System.Xml; //xml
using Npgsql;  //pg
using System.Threading;
using System.IO.Ports; //com
using NLog;

namespace ServiceDOF4
{
    public partial class Service1 : ServiceBase
    {
        XmlDocument xml = new XmlDocument();    //xml
        static List<string> list = new List<string>(); //xml
        static private DataSet ds = new DataSet(); //pg com
        static private DataTable dt = new DataTable(); //pg com
        private System.Timers.Timer timer2;
        static String Mystr = null; //pg_query
        static int min = 5000; //time
        private static Logger logger = LogManager.GetCurrentClassLogger(); //log
        static List<MyComReader> allListeners; //list_of_com

        public Service1()
        {
            InitializeComponent();
            XMLReader();
        }

        #region Xml
        public void XMLReader()
        {
            try
            {
                xml.Load("c:\\DATA\\server_info_uni.xml");
                foreach (XmlNode n in xml.SelectNodes("/server_info"))
                {
                    list = new List<string>();
                    list.Add(n.SelectSingleNode("server").InnerText);
                    list.Add(n.SelectSingleNode("port").InnerText);
                    list.Add(n.SelectSingleNode("user_id").InnerText);
                    list.Add(n.SelectSingleNode("password").InnerText);
                    list.Add(n.SelectSingleNode("database").InnerText);
                    list.Add(n.SelectSingleNode("table").InnerText);        //5
                    list.Add(n.SelectSingleNode("tcpenable").InnerText);    //6
                    list.Add(n.SelectSingleNode("opcenable").InnerText);    //7
                    list.Add(n.SelectSingleNode("comenable").InnerText);    //8
                    list.Add(n.SelectSingleNode("value").InnerText);        //9
                }
              
            }
            catch (Exception msg)
            {               
                logger.Trace(msg);
                throw;
            }
        }
        #endregion

        
        #region com


        private void SelectCom()  //com port
        {
            try
            {

                NpgsqlConnection conn = new NpgsqlConnection(("Server=" + list[0] + ";Port=" + list[1] + ";User Id=" + list[2] + ";Password=" + list[3] + ";Database=" + list[4] + ";"));  //
                string sql = "SELECT  \"ID_TagName\", \"F_ComPort\", \"F_ComPortBaudRate\", \"F_ComQuery\", \"F_ParseFunction\", \"F_TagReadTime\",     \"F_AnswerLenght\",   \"F_AnswerKey\",    ";
                sql += "\"F_AnswerKeyPosition\",      \"F_ComPortIPAdress\",     \"F_ComPortParity\",   \"F_ComPortDataBits\",     \"F_ComPortStopBit\",   \"F_ComPortFlowControl\",  ";
                sql += "\"F_ComPortTimeOut\"         FROM  \"SC_Tag\".\"T_TagName\" as tn,\"SC_Tag\".\"T_HardWareTag\" as hw , \"SC_Tag\".\"T_RealHardWare\" as rh        where ";
                sql += "rh.\"ID_RealHardWare\" = hw.\"F_RealHardWare_ID\"   and tn.\"F_HardWare_ID\" = hw.\"F_TagName_ID\"    and \"F_ServerName\"  =\'" + Environment.MachineName + "\' and \"F_ComPortIPAdress\" = '127.0.0.1' ";
               
                NpgsqlDataAdapter da = new NpgsqlDataAdapter(sql, conn);
                ds.Reset();
                da.Fill(ds);
                dt = ds.Tables[0];
               
                if (ds.Tables[0] != null)
                {
                    InitAll();
                }

            }
            catch (Exception msg)
            {
                logger.Trace(msg);
                return;
            }
        }

        private void InitAll()
        {
            try
            {
                allListeners = new List<MyComReader>();

                for (int xx = 0; xx < ds.Tables[0].Rows.Count; ++xx)
                {
                    string com = "COM" + dt.Rows[xx][1];
                    string send = dt.Rows[xx][3].ToString() + "\r";
                    string idcom = dt.Rows[xx][0].ToString();
                    int BaudRate = Convert.ToInt32(dt.Rows[xx][2]);
                    char key = Convert.ToChar(dt.Rows[xx][7]);
                    string parity = dt.Rows[xx][10].ToString();
                    int databit = Convert.ToInt32(dt.Rows[xx][11]);
                    double stopbit = Convert.ToDouble(dt.Rows[xx][12]);
                    string flowcontrol = dt.Rows[xx][13].ToString();
                    int timeout = Convert.ToInt32(dt.Rows[xx][14]);
                    string parseFunc = dt.Rows[xx][4].ToString();
                    allListeners.Add(new MyComReader(com, BaudRate, send, idcom, parity, databit, stopbit, flowcontrol, timeout, parseFunc, key));
                }
                min = Convert.ToInt32(dt.Rows[0][5]);
                for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
                {
                    if (Convert.ToInt32(dt.Rows[i][5]) < min)
                        min = Convert.ToInt32(dt.Rows[i][5]);
                }

                this.timer2 = new System.Timers.Timer();
                this.timer2.Enabled = true;
                this.timer2.Interval = min;
                this.timer2.Elapsed += new System.Timers.ElapsedEventHandler(this.timer2_Elapsed);
                this.timer2.AutoReset = true;
                this.timer2.Start();
            
            }
            catch (Exception msg)
            {              
                logger.Trace(msg);
                return;
            }
        }

        private void timer2_Elapsed(object sender, EventArgs e)
        {
            try
            {
                Go();
            }
            catch (Exception msg)
            {
                logger.Trace(msg);
                throw;
            }

        }
        private void Go()
        {
            try
            {
                foreach (MyComReader comListener in allListeners)
                {
                    comListener.ThreadStart();
                    Thread.Sleep(1000);
                    if (comListener.ThreadState())
                            comListener.ThreadStop();
                }

            }
            catch (Exception msg)
            {              
                logger.Trace(msg);
                return;
            }
        }
        #endregion

        #region mycom
        internal class MyComReader
        {

           // private SerialPort port;
            private System.Timers.Timer timer;
            private System.Threading.Thread thread;
            readonly EventWaitHandle wh = new AutoResetEvent(false);
            private bool doWork;
           // int i = 0;
            string value = "";
            private string inData = "";
            SerialPort _COM;
            string DataToSend;
            string IdCom;
            string ParseGlob = "";
            char Key;


            internal MyComReader(string portNumber, int bodRate, string dataTosend, string idcom, string parity, int databit, double stopbit, string flowcontrol, int timeout, string parse, char key)
            {
                IdCom = idcom;
                DataToSend = dataTosend;
                Key = key;
                _COM = new SerialPort(portNumber, bodRate);

                if (parity.ToLower() == "none")
                    _COM.Parity = System.IO.Ports.Parity.None;
                else if (parity.ToLower() == "even")
                    _COM.Parity = System.IO.Ports.Parity.Even;
                else if (parity.ToLower() == "mark")
                    _COM.Parity = System.IO.Ports.Parity.Mark;
                else if (parity.ToLower() == "odd")
                    _COM.Parity = System.IO.Ports.Parity.Odd;
                else if (parity.ToLower() == "space")
                    _COM.Parity = System.IO.Ports.Parity.Space;

                _COM.DataBits = databit;

                if (stopbit == 0)
                    _COM.StopBits = StopBits.None;
                else if (stopbit == 1)
                    _COM.StopBits = StopBits.One;
                else if (stopbit == 1.5)
                    _COM.StopBits = StopBits.OnePointFive;
                else if (stopbit == 2)
                    _COM.StopBits = StopBits.Two;

                if (flowcontrol.ToLower() == "none")
                    _COM.Handshake = Handshake.None;
                else if (flowcontrol.ToLower() == "rts/cts" || flowcontrol.ToLower() == "rts\\cts")
                    _COM.Handshake = Handshake.RequestToSend;
                else if (flowcontrol.ToLower() == "xon/xof" || flowcontrol.ToLower() == "xon\\xof")
                    _COM.Handshake = Handshake.RequestToSendXOnXOff;
                else if (flowcontrol.ToLower() == "dtr/dsr" || flowcontrol.ToLower() == "dtr\\dsr")
                    _COM.Handshake = Handshake.XOnXOff;

                _COM.ReadTimeout = timeout;
                _COM.WriteTimeout = timeout;
                if (parse != "")
                    ParseGlob = parse;

                _COM.DataReceived += port_DataReceived;

            }

            public void ThreadStart()
            {
                doWork = true;
                thread = new Thread(Execute);
                thread.Start();                

                this.timer = new System.Timers.Timer();
                this.timer.Enabled = true;
                this.timer.Interval = min;
                this.timer.Elapsed += new System.Timers.ElapsedEventHandler(this.timer_Elapsed);
                this.timer.AutoReset = true;
                this.timer.Start();
            }

            public void ThreadStop()
            {
                doWork = false;
                timer.Stop();
                wh.Set();
                _COM.Close();
            }

            public bool ThreadState()
            {
                if (doWork)
                    return true;
                else return false;
            }


            void Execute()
            {
                try
                {
                    while (doWork)
                    {

                        if (_COM.IsOpen)
                        {
                            // Если порт открыт, значит какой-то косяк, девайс не ответил, здесь обрабатываем

                            // Закрываем
                            _COM.Close();
                        }

                        // Открываем
                        _COM.Open();

                        _COM.Write(DataToSend);
                        wh.WaitOne();
                    }
                }
                catch (Exception msg)
                {
                    logger.Debug("Execute() " + msg);
                    return;                    
                }
            }

            void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
            {
                wh.Set();
            }


            void port_DataReceived(object sender, SerialDataReceivedEventArgs e)
            {
                try
                {
                    ////////////
                    SerialPort sp = (SerialPort)sender;

                    inData += sp.ReadExisting();
                    value = inData;

                   // if (value.Length == 14 && value.Length < 15 && value.Contains("\r"))
                    if (value[0] == Key && value.Length == 14 && value.Contains("\r"))
                    {


                        value = value.Substring(0, value.Length - 1);
                        // Пришли данные

                        //  string IdCom = "2";
                        // Чето с ними делаем  

                        NpgsqlConnection conn = new NpgsqlConnection(("Server=" + list[0] + ";Port=" + list[1] + ";User Id=" + list[2] + ";Password=" + list[3] + ";Database=" + list[4] + ";"));
                        conn.Open();

                        if (ParseGlob != "") Mystr = ("INSERT INTO " + list[5] + "(\"F_TagName_ID\"," + list[9] + ",\"F_Date\")  VALUES (" + IdCom + ",(SELECT * FROM " + ParseGlob + "(\'" + value + "\')),\'" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "\'   )");
                        else Mystr = ("INSERT INTO " + list[5] + "(\"F_TagName_ID\"," + list[9] + ",\"F_Date\")  VALUES (" + IdCom + ",\'" + value + "\',\'" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "\'   )");
                        //   MessageBox.Show(Mystr);

                        NpgsqlCommand command = new NpgsqlCommand(Mystr, conn);
                        int rowsaffected;
                        rowsaffected = command.ExecuteNonQuery();
                        conn.Close();
                        inData = "";                        
                   //     logger.Info("ok "+ value);
                        value = "";
                    }
                    else 
                    {
                        logger.Debug("port_DataReceived "+value);
                        value = "";
                        inData = "";
                        return;
                    }
                    // проверка, если в InData появилась полная строка - отрезаем кусок
                    // и обрабатываем, а лучше в другой поток для обработки передаем

                    ////////
                }
                catch (Exception msg)
                {
                    logger.Debug(msg);
                    logger.Debug(Mystr);
                    return;
                }
            }



        }
        #endregion
        protected override void OnStart(string[] args)
        {
            try
            {
                if (list[8] == "1")
                {
                    SelectCom();
                }

            }
            catch (Exception msg)
            {             
                logger.Trace(msg);
                return;
            }
        }

        protected override void OnStop()
        {
            try
            {
                if (list[8] == "1")
                {                   
                    foreach (MyComReader comListener in allListeners)
                    {
                        if (comListener.ThreadState())
                            comListener.ThreadStop();
                    }
                    this.timer2.Stop();
                    
                }
            }
            catch (Exception msg)
            {
                logger.Trace(msg);
                return;
            }
        }
    }
}