using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Timers;
using System.Windows.Forms;

namespace BEMSDataGateway
{

    public delegate int ErrorFunc(int nErrorCode);

    class Parsing
    {
        static IcosComm iCosSocket;
        Thread _thread;
        /// <summary>
        /// Concurrent Dictionary 는 Key, Value로 구성됌.
        /// 여기서 Key 는 string형이고 Value 는 float[] 이므로 배열형태의 float타입이다.
        /// RawData는 raw데이터를 담는다.
        /// NowData는 현재값 데이터를 담는다.
        /// averageData는 평균 데이터를 담는다.
        /// AddData는 적산 데이터를 담는다.
        /// OnData는 가동시간 데이터를 담는다.
        /// Add2는 적산2(전력순시값을->전력량) 데이터를 담는다.
        /// Now2는 현재2(15분동안 데이터가 한번이라도 1일때 15분데이터는 1) 데이터를 담는다.
        /// </summary>
        ConcurrentDictionary<string, float[]> RawData = new ConcurrentDictionary<string, float[]>();
        ConcurrentDictionary<string, float[]> NowData = new ConcurrentDictionary<string, float[]>();
        ConcurrentDictionary<string, float[]> AverageData = new ConcurrentDictionary<string, float[]>();
        ConcurrentDictionary<string, float[]> AddData = new ConcurrentDictionary<string, float[]>();
        ConcurrentDictionary<string, float[]> OnData = new ConcurrentDictionary<string, float[]>();
        ConcurrentDictionary<string, float[]> Add2Data = new ConcurrentDictionary<string, float[]>();
        ConcurrentDictionary<string, float[]> Now2Data = new ConcurrentDictionary<string, float[]>();

        /// <summary>
        /// Tmp~는 연산할때 사용하기 위한 임시ConcurrentDictionary이다. 왜냐하면 15분마다 DB에 저장을 해줘야하는데 그러면서 1분 단위로 연산해야한다.
        /// 따라서 위에있는 Dictionary는 1분마다 계속 연산을 해주고, Tmp~를 이용하여 DB에 데이터를 저장한다.
        /// RawData는 raw데이터를 담는다.
        /// NowData는 현재값 데이터를 담는다.
        /// averageData는 평균 데이터를 담는다.
        /// AddData는 적산 데이터를 담는다.
        /// OnData는 가동시간 데이터를 담는다.
        /// Add2는 적산2(전력순시값을->전력량) 데이터를 담는다.
        /// Now2는 현재2(15분동안 데이터가 한번이라도 1일때 15분데이터는 1) 데이터를 담는다.
        /// </summary>

        ConcurrentDictionary<string, float[]> TmpAverageData = new ConcurrentDictionary<string, float[]>();
        ConcurrentDictionary<string, float[]> TmpAddData = new ConcurrentDictionary<string, float[]>();
        ConcurrentDictionary<string, float[]> TmpNowData = new ConcurrentDictionary<string, float[]>();
        ConcurrentDictionary<string, float[]> TmpOnData = new ConcurrentDictionary<string, float[]>();
        ConcurrentDictionary<string, float[]> TmpNow2Data = new ConcurrentDictionary<string, float[]>();
        ConcurrentDictionary<string, float[]> TmpAdd2Data = new ConcurrentDictionary<string, float[]>();
        ConcurrentDictionary<string, float[]> TmpRawData = new ConcurrentDictionary<string, float[]>();

        /// <summary>
        /// 성능분석식을 연산하기 위해 필요한 Dictionary
        /// </summary>
        ConcurrentDictionary<string, float[]> Exp_Raw_Data = new ConcurrentDictionary<string, float[]>();
        ConcurrentDictionary<string, float[]> Exp_Fifteen_Data = new ConcurrentDictionary<string, float[]>();
        ConcurrentDictionary<string, float[]> Exp_Hour_Data = new ConcurrentDictionary<string, float[]>();

        /// <summary>
        /// Raw 데이터를 스케일링 작업하기 위한 Dictionary..대구은행의 경우 사용하지 않음.. 
        /// </summary>
        ConcurrentDictionary<string, string> Matching_Tag = new ConcurrentDictionary<string, string>();
        ConcurrentDictionary<string, string> Value_Modify = new ConcurrentDictionary<string, string>();

        //Change of Value .. 값이 0에서 1이나 1에서 0으로 바뀌었을때의 연산을 해주는 Dictionary 추가 기능으로 지금은 사용하지 않는다.
        ConcurrentDictionary<string, float[]> COV_Dic = new ConcurrentDictionary<string, float[]>();

        private string[] temp;

        public void setIcosSocket(IcosComm socket)
        {
            iCosSocket = socket;
        }
        public string SettingFileParsing()
        {

            Stopwatch SW = new Stopwatch();
            string sTemp1;
            SW.Reset();
            SW.Start();

            LogFileCreate LFC = new LogFileCreate();
            int count_modify_value = 0;

            StreamReader MatchingDic = new StreamReader("SettingFile.csv", Encoding.GetEncoding("euc-kr")); // 파일 한번만 읽기.
            string[] Matching_Key_Value;

            while (!MatchingDic.EndOfStream) // Stream의 끝이 올때까지 반복
            {
                string s = MatchingDic.ReadLine(); // 한줄을 읽음.                

                if (!(s.Length > 0))
                {
                    continue;
                }
                Matching_Key_Value = s.Split(',');        // Split() 메서드를 이용하여 ',' 구분하여 자름
                Matching_Tag.TryAdd(Matching_Key_Value[3], Matching_Key_Value[0]); // [Key] = TagXXX [Value] = 1.1.4478.xxx
            }
            MatchingDic.Close();
            MatchingDic.Dispose();
            StreamReader Modify_Value = new StreamReader("Modify_Value.csv", Encoding.GetEncoding("euc-kr")); //Modify_Value 의 형식 -> 3, ch.ctrl.tag3,Tag3+2,1.1.4478.3
            string[] temp_Modify_Value;
            while (!Modify_Value.EndOfStream) // Stream의 끝이 올때까지 반복
            {
                string s = Modify_Value.ReadLine(); // 한줄을 읽음.           

                if (!(s.Length > 0))
                {
                    continue;
                }
                temp_Modify_Value = s.Split(',');        // Split() 메서드를 이용하여 ',' 구분하여 잘라냄   [0]은 serial num, [1]은 Tag명, [2]는 식 , [3] bems포인트  
                Value_Modify.TryAdd(temp_Modify_Value[3], temp_Modify_Value[2]); // Value_modifty Dic의 형식은 [1.1.4478.1] [Tag3+2]와 같은형식.
                count_modify_value++; // count를 한개늘림.
            }
            Modify_Value.Close();
            Modify_Value.Dispose();
            float value = 0;

            for (int TypeSelect = 0; TypeSelect < 9; TypeSelect++)
            {
                try
                {
                    if (Form1.Enable_EnglishMode)//영어
                    {
                        LFC.Log("[Parsing.cs] Start operation Type : " + TypeSelect);
                    }
                    else//한글
                    {
                        LFC.Log("[Parsing.cs] 연산 시작 Type : " + TypeSelect);
                    }

                    StreamReader sr = new StreamReader("SettingFile.csv", Encoding.GetEncoding("euc-kr")); // 파일 한번만 읽기.

                    while (!sr.EndOfStream) // Stream의 끝이 올때까지 반복
                    {
                        string s = sr.ReadLine(); // 한줄을 읽음.

                        if (!(s.Length > 0))
                        {
                            continue;
                        }
                        temp = s.Split(',');        // Split() 메서드를 이용하여 ',' 구분하여 잘라냄  
                        temp[0] = temp[0].Trim(); //SettingFile에서의 1.3.4478.2 => 벰스 포인트
                        temp[1] = temp[1].Trim(); //SettingFile에서의 BACnetPort.기계실-IBGX-1.BING_CYR => iCos포인트
                        temp[2] = temp[2].Trim(); //SettingFile에서의 3 => 값 타입
                        temp[4] = temp[4].Trim(); //SetiingFile에서의 TagXXX => Tag 아이디
                                                  /// temp[0] => SiteId, FacilityId, FacilityCode, PropertyId 나누기.                     

                        // 특정 관제점의 경우 계절마다 저장하거나 저장하지 않을 수 있다. 따라서 아래와 같이...
                        // SettingFile에서 가장 마지막에 0,1,2가 있는데 0인 경우엔 계절에 상관없이 저장
                        // 1인 경우에는 여름시즌에만 저장 , 2인 경우에는 겨울시즌에만 저장..
                        // 여름 시즌, 겨울 시즌은 프로그램의 설정에서 설정가능하다. 혹은 ini파일에서 직접 설정가능
                        if (temp[4] == "1")  //여름시즌
                        {
                            Readini Ri_cool = new Readini();
                            Ri_cool.ReadData();

                            if ((DateTime.Now > DateTime.Parse(Ri_cool.CoolDayFromgs.Trim())) || (DateTime.Now < DateTime.Parse(Ri_cool.CoolDayTogs.Trim())))
                            {
                                continue;
                            }
                        }
                        else if (temp[4] == "2") // 겨울시즌
                        {
                            Readini Ri_heat = new Readini();
                            Ri_heat.ReadData();

                            if ((DateTime.Now > DateTime.Parse(Ri_heat.HeatDayFromgs.Trim())) && (DateTime.Now < DateTime.Parse(Ri_heat.HeatDayTogs.Trim())))
                            {
                                continue;
                            }
                        }

                        //temp[0]의 경우 1.2.3424.3와 같은 형식으로 되어있다.
                        //따라서 이를 Split을 통해 분해해야한다.
                        string[] PointDivid = temp[0].Split('.');

                        //처음이 #인 경우는 건너뛰도록...즉 #은 SettingFile에 주석을 달때 사용한다.
                        if (temp[0] == "#")
                        {
                            continue;
                        }
                        value = (float)iCosSocket.IcosGetTagValue(temp[1]);// 기존 float -> float ;; 현재 double -> float 에러 ?                                                      
                        if (value.GetType() == typeof(DBNull))
                        {
                            value = 0;
                            if (Form1.Enable_EnglishMode)//영어
                            {
                                LFC.Log("[Parsing.cs] : " + temp[0] + temp[1] + temp[2] + "Null value entered." + value);
                            }
                            else//한글
                            {
                                LFC.Log("[Parsing.cs] : " + temp[0] + temp[1] + temp[2] + "Null 값이 들어옴." + value);
                            }
                        }

                        //값이 소수점 16자리정도까지 나타날 수 있으므로 4자리까지 나타나도록 값을 컷팅한다.
                        value = (float)Math.Round(value, 4, MidpointRounding.AwayFromZero);

                        //이 부분은 값 변경 위한 소스부분이다.
                        //상단에서 StreamReader를 통해 하나라도 csv파일에 목록이 1개 라도 있고 && Value_Modfiy에 1.1.4478.1과 같은 키를 포함하고 있다면 아래 if이 시작된다.
                        if (count_modify_value > 0 && (Value_Modify.ContainsKey(temp[0]) == true))
                        {
                            MSScriptControl.ScriptControl sc = new MSScriptControl.ScriptControl(); // Script를 사용할 수 있게 만드는 스크립트 컨트롤을 객체 선언
                            sc.Language = "VBScript"; // 사용할 스크립트 언어는 Visaul Basic Script

                            string Pattern = "Tag" + @"\d{1,5}"; //태그 형식
                            Regex regex = new Regex(Pattern);
                            string Exp = Value_Modify[temp[0]]; //키값에 대한 값(식)을 불러옴.

                            foreach (Match match in regex.Matches(Exp))   // 불러들인 수식에서 포인트 명을 값으로...
                            {
                                string Tag_Name = Convert.ToString(match); //Matching 된 값을 string형식으로 변환.
                                                                           //int Point_Number = Convert.ToInt32(Regex.Replace(Tag_Name, @"\D", "")); // 10진수만 뽑아냄.
                                Exp = Exp.Replace(Tag_Name, value.ToString()); //태그값을 값으로 바꿈 ch.ctrl.tag1 -> value로..
                            }
                            value = (float)Convert.ToDouble(sc.Eval(Exp)); // value 값이 변경된 결과.
                        }

                        float[] values = new float[14]; // 20161209 기존 13에서 ->14로 늘림. 
                        values[0] = value; // 값                 
                        values[1] = 1;       // 카운트
                        values[2] = float.Parse(PointDivid[0]); // SiteId
                        values[3] = float.Parse(PointDivid[1]); // FacilityTypeId
                        values[4] = float.Parse(PointDivid[2]); // FacilityCode
                        values[5] = float.Parse(PointDivid[3]); // PropertyId
                                                                // values[7] = (float)Convert.ToDouble(temp[2]);
                        values[13] = value; // 현재값

                        if (RawData.ContainsKey(temp[0]) == false) // Tag가 없다면
                        {
                            RawData.TryAdd(temp[0], values);
                        }
                        else // Tag가 있다면
                        {
                            float[] Tmp1ValueRaw = RawData[temp[0]]; // Tag의 값을 가져옴 
                            Tmp1ValueRaw[0] = values[0];
                            Tmp1ValueRaw[7] = TypeSelect;
                            RawData.TryUpdate(temp[0], Tmp1ValueRaw, values); // 새로운 값을 업데이트 Key의값과 Values의 값이 같다면 Tmp1ValueRaw를 업데이트.
                        }

                        if (temp[2].Equals(Convert.ToString(TypeSelect)))
                        {
                            switch (TypeSelect)
                            {
                                case 1:
                                    /// TypeSelect 1 : 평균값
                                    if (AverageData.ContainsKey(temp[0]) == false) // Tag가 없다면 ,, 참고로 temp[0]는 키값 = 1.1.4478.xxx와 같은...
                                    {
                                        AverageData.TryAdd(temp[0], values);
                                    }
                                    else // Tag가 있다면
                                    {
                                        float[] Tmp1Value = AverageData[temp[0]]; // Tag의 값을 가져옴                                

                                        Tmp1Value[0] = Tmp1Value[0] + values[0]; // 이전 태그의 값에 새로운 값을 더함
                                        Tmp1Value[1] = Tmp1Value[1] + values[1]; // 카운트 ++
                                        Tmp1Value[7] = TypeSelect;
                                        Tmp1Value[13] = values[13];
                                        AverageData.TryUpdate(temp[0], Tmp1Value, values); // 새로운 값을 업데이트
                                    }
                                    break;

                                case 2:
                                    /// TypeSelect 2 : 적산값 
                                    /// 
                                    if (value < 0)
                                        value = 0;

                                    if (AddData.ContainsKey(temp[0]) == false) // Tag가 없다면
                                    {
                                        AddData.TryAdd(temp[0], values);
                                    }
                                    else
                                    {
                                        float[] Tmp1Value2 = AddData[temp[0]]; // Tag의 값을 가져옴                                        
                                                                               //Tmp1Value2[0] = Tag에서 가져온 값 : 예)1030 
                                                                               //Tmp1Value2[1] = 카운트
                                                                               //Tmp1Value2[2] = 두 값의 차이 : 예)1040-1030 = 10
                                                                               //Tmp1Value2[0] = values[0];
                                                                               //if (value - Tmp1Value2[0] > 100)
                                                                               //{
                                                                               //    Tmp1Value2[6] += 0;
                                                                               //}
                                                                               //else
                                                                               //{
                                        Tmp1Value2[6] += value - Tmp1Value2[0]; // 이전 태그의 값에 새로운 값을 더함 예) 1030 - 1020 = 10
                                        //}
                                        Tmp1Value2[0] = value;
                                        Tmp1Value2[1] = Tmp1Value2[1] + values[1]; // 카운트 ++
                                        Tmp1Value2[7] = TypeSelect;
                                        Tmp1Value2[13] = values[13];
                                        AddData.TryUpdate(temp[0], Tmp1Value2, values); // 새로운 값을 업데이트   
                                    }
                                    break;

                                //현재값 같은 경우엔 값 변경이 필요없음.
                                case 3:
                                    /// TypeSelect 3 : 현재값                                   

                                    if (NowData.ContainsKey(temp[0]) == false) // Tag가 없다면
                                    {
                                        NowData.TryAdd(temp[0], values);
                                    }
                                    else
                                    {
                                        float[] Tmp1Value5 = NowData[temp[0]]; // Tag의 값을 가져옴 
                                        Tmp1Value5[0] = value;
                                        Tmp1Value5[7] = TypeSelect;
                                        NowData.TryUpdate(temp[0], Tmp1Value5, values);
                                    }
                                    break;

                                case 4:
                                    /// TypeSelect 4 : 가동시간값   
                                    /// 
                                    if (value < 0)
                                        value = 0;

                                    if (OnData.ContainsKey(temp[0]) == false) // Tag가 없다면
                                    {
                                        OnData.TryAdd(temp[0], values);
                                    }
                                    else
                                    {
                                        float[] Tmp1Value3 = OnData[temp[0]]; // Tag의 값을 가져옴  

                                        Tmp1Value3[0] = Tmp1Value3[0] + values[0]; // 이전 태그의 값에 새로운 값을 더함
                                        Tmp1Value3[1] = Tmp1Value3[1] + values[1]; // 카운트 ++
                                        Tmp1Value3[7] = TypeSelect;
                                        Tmp1Value3[13] = values[13];
                                        OnData.TryUpdate(temp[0], Tmp1Value3, values); // 새로운 값을 업데이트   
                                    }
                                    break;
                                //OnData.TryAdd(temp[0], value);    
                                case 5:
                                    /// TypeSelect 5 : 적산값2    
                                    if (value < 0)
                                        value = 0;

                                    if (Add2Data.ContainsKey(temp[0]) == false) // Tag가 없다면
                                    {
                                        Add2Data.TryAdd(temp[0], values);
                                    }
                                    else // Tag가 있다면
                                    {
                                        float[] Tmp6Value = Add2Data[temp[0]]; // Tag의 값을 가져옴

                                        Tmp6Value[0] = Tmp6Value[0] + values[0]; // 이전 태그의 값에 새로운 값을 더함
                                        Tmp6Value[1] = Tmp6Value[1] + values[1]; // 카운트 ++
                                        Tmp6Value[7] = TypeSelect;
                                        Tmp6Value[13] = values[13];
                                        Add2Data.TryUpdate(temp[0], Tmp6Value, values); // 새로운 값을 업데이트
                                    }
                                    break;

                                case 6:
                                    /// TypeSelect 6 : 현재값2   
                                    if (value < 0)
                                        value = 0;

                                    if (Now2Data.ContainsKey(temp[0]) == false) // Tag가 없다면
                                    {
                                        Now2Data.TryAdd(temp[0], values);
                                    }
                                    else
                                    {
                                        float[] Tmp1Value4 = Now2Data[temp[0]]; // Tag의 값을 가져옴   
                                        Tmp1Value4[0] = Tmp1Value4[0] + values[0]; // 이전 태그의 값에 새로운 값을 더함
                                        Tmp1Value4[1] = Tmp1Value4[1] + values[1]; // 카운트 ++
                                        Tmp1Value4[7] = TypeSelect;
                                        Tmp1Value4[13] = values[13];
                                        Now2Data.TryUpdate(temp[0], Tmp1Value4, values); // 새로운 값을 업데이트   
                                    }
                                    break;

                                case 7: //1분 단위 Insert..Peak전력 등등..
                                    OneMinute_Insert OMI = new OneMinute_Insert();
                                    OMI.OneMin_Insert(values[2], values[0]);
                                    OMI.PeakCheck(values[0]);
                                    break;

                                case 8:
                                    OneMinute_Insert OMI2 = new OneMinute_Insert();

                                    if (COV_Dic.ContainsKey(temp[0]) == false) // Tag가 없다면
                                    {
                                        COV_Dic.TryAdd(temp[0], values);
                                    }
                                    else
                                    {
                                        float[] Tmp1Value2 = COV_Dic[temp[0]]; // Tag의 값을 가져옴                                        
                                                                               //Tmp1Value2[0] = Tag에서 가져온 값 : 예)1030 
                                                                               //Tmp1Value2[1] = 카운트
                                                                               //Tmp1Value2[2] = 두 값의 차이 : 예)1040-1030 = 10
                                                                               //Tmp1Value2[0] = values[0];
                                        Tmp1Value2[6] = value - Tmp1Value2[0]; // 이전 태그의 값에 새로운 값을 더함 예) 1030 - 1020 = 10                                        

                                        if (Tmp1Value2[6] != 0)
                                        {
                                            LFC.Log(temp[1] + "." + values[2] + "." + values[3] + "." + values[4] + "." + values[5] + " = COV 값의 차이 = " + Tmp1Value2[6]);
                                            OMI2.OneMin_Insert_COV(values[2], values[3], values[4], values[5], Tmp1Value2[6]);
                                        }
                                        Tmp1Value2[0] = value;
                                        COV_Dic.TryUpdate(temp[0], Tmp1Value2, values); // 새로운 값을 업데이트   
                                    }
                                    break;
                            }
                        }
                    }
                    sr.Close();
                    sr.Dispose();
                }
                catch (Exception e)
                {
                    if (Form1.Enable_EnglishMode)//영어
                    {
                        LFC.Log("[Parsing.cs] Error : " + e + Environment.NewLine);
                    }
                    else//한글
                    {
                        LFC.Log("[Parsing.cs] 에러발생 : " + e + Environment.NewLine);
                    }
                }
            }

            /// Set Value (DGW -> iCos)         
            SW.Stop();   // 현재 인스턴스가 측정한 총 경과 시간을 가져옵니다.
            sTemp1 = SW.Elapsed.ToString();
            if (Form1.Enable_EnglishMode)//영어
            {
                LFC.Log("[Parsing.cs] Operation time : " + sTemp1 + Environment.NewLine);
            }
            else//한글
            {
                LFC.Log("[Parsing.cs] 연산 시간 : " + sTemp1 + Environment.NewLine);
            }
            int TmpMinNow = Convert.ToInt32(DateTime.Now.Minute.ToString());

            if ((TmpMinNow % 15) == 0)
            {
                _thread = new Thread(new ThreadStart(Thread_Test1));
                _thread.Start();
            }
            string CompleteTime = DateTime.Now.Minute.ToString();
            return CompleteTime;
        }

        public void Thread_Test1() // 1분마다 실행되는 데이터 수집 로직
        {
            try
            {
                DateTime TmpDate = DateTime.Now;

                int TmpMinNow = Convert.ToInt32(TmpDate.Minute.ToString());
                string Hour = (TmpDate).ToString("yyyy-MM-dd HH:00:00.000");

                LogFileCreate LFC = new LogFileCreate();
                Expression_Process EP = new Expression_Process();
                ///시간 측정//////////////////
                Stopwatch SW = new Stopwatch();
                string sTemp1;
                SW.Reset();
                SW.Start();

                /// *************데이터 복사*************** ///
                #region CopyData
                TmpAverageData = new ConcurrentDictionary<string, float[]>(AverageData);
                TmpAddData = new ConcurrentDictionary<string, float[]>(AddData);
                TmpNowData = new ConcurrentDictionary<string, float[]>(NowData);
                TmpOnData = new ConcurrentDictionary<string, float[]>(OnData);
                TmpAdd2Data = new ConcurrentDictionary<string, float[]>(Add2Data);
                TmpNow2Data = new ConcurrentDictionary<string, float[]>(Now2Data);
                TmpRawData = new ConcurrentDictionary<string, float[]>(RawData);
                #endregion
                ///////////////////////////////////////////////            

                SW.Stop();   // 현재 인스턴스가 측정한 총 경과 시간을 가져옵니다.
                sTemp1 = SW.Elapsed.ToString();
                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] Data copy time : " + sTemp1 + Environment.NewLine);
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] 데이터 복사 시간 : " + sTemp1 + Environment.NewLine);
                }
                /// *************데이터 연산*************** ///   
                /// 
                string sTemp2;
                SW.Reset();
                SW.Start();

                #region Data_Calculate
                AverageCal_Min(TmpAverageData, TmpMinNow);
                AddCal_Min(TmpAddData, TmpMinNow);
                NowCal_Min(TmpNowData, TmpMinNow);
                OnCal_Min(TmpOnData, TmpMinNow);
                Add2Cal_Min(TmpAdd2Data, TmpMinNow);
                Now2Cal_Min(TmpNow2Data, TmpMinNow);
                #endregion
                ///////////////////////////////////////////////      

                var Tmp_Expression_result_FifMin = TmpAverageData.Union(TmpAddData).Union(TmpNowData).Union(TmpOnData).Union(TmpAdd2Data).Union(TmpNow2Data).ToDictionary(k => k.Key, v => v.Value);
                EP.ReadCSV_Passing_Expression(RawData, Hour, TmpMinNow, "Raw", Matching_Tag);
                EP.ReadCSV_Passing_Expression(Tmp_Expression_result_FifMin, Hour, TmpMinNow, "FiftMin", Matching_Tag);

                SW.Stop();   // 현재 인스턴스가 측정한 총 경과 시간을 가져옵니다.
                sTemp2 = SW.Elapsed.ToString();

                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] 15 minutes data calculation time : " + sTemp2);
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] 15분 데이터 계산 시간 : " + sTemp2);
                }
                /// 15분에 대한 성능분석식 + Raw 에 대한 성능분석식

                My_DB_DML DBI = new My_DB_DML();

                string sTemp_delete;
                SW.Reset();
                SW.Start();
                /// *************15분 삭제***************** ///               
                DBI.DB_Min_Delete(TmpAverageData, TmpMinNow);
                DBI.DB_Min_Delete(TmpAddData, TmpMinNow);
                //DBI.DB_Min_Delete(TmpNowData, TmpMinNow);
                DBI.DB_Min_Delete(TmpOnData, TmpMinNow);
                DBI.DB_Min_Delete(TmpAdd2Data, TmpMinNow);
                DBI.DB_Min_Delete(TmpNow2Data, TmpMinNow);
                SW.Stop();   // 현재 인스턴스가 측정한 총 경과 시간을 가져옵니다.
                sTemp_delete = SW.Elapsed.ToString();

                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] 15 minutes Data deletion time : " + sTemp_delete);
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] 15분 데이터 삭제 시간 : " + sTemp_delete);
                }

                string sTemp3;
                SW.Reset();
                SW.Start();

                /// *************15분 삽입***************** ///
                #region 15분삽입
                DBI.DB_Min_Insert(TmpAverageData, TmpMinNow);
                DBI.DB_Min_Insert(TmpAddData, TmpMinNow);
                DBI.DB_Min_Insert(TmpNowData, TmpMinNow);
                DBI.DB_Min_Insert(TmpOnData, TmpMinNow);
                DBI.DB_Min_Insert(TmpAdd2Data, TmpMinNow);
                DBI.DB_Min_Insert(TmpNow2Data, TmpMinNow);
                RawCal(TmpMinNow);

                #endregion
                /////////////////////////////////////////////// 

                SW.Stop();   // 현재 인스턴스가 측정한 총 경과 시간을 가져옵니다.
                sTemp3 = SW.Elapsed.ToString();
                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] 15 minutes data insertion time : " + sTemp3);
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] 15분 데이터 삽입 시간 : " + sTemp3);
                }

                string sTemp_Now;
                SW.Reset();
                SW.Start();

                /// *************15분 현재값 삽입***************** ///
                DBI.DB_Min_Insert_Now(TmpAverageData, TmpMinNow);
                DBI.DB_Min_Insert_Now(TmpAddData, TmpMinNow);
                //DBI.DB_Min_Insert_Now(TmpNowData, TmpMinNow);
                DBI.DB_Min_Insert_Now(TmpOnData, TmpMinNow);
                DBI.DB_Min_Insert_Now(TmpAdd2Data, TmpMinNow);
                DBI.DB_Min_Insert_Now(TmpNow2Data, TmpMinNow);
                /////////////////////////////////////////////// 

                SW.Stop();   // 현재 인스턴스가 측정한 총 경과 시간을 가져옵니다.
                sTemp_Now = SW.Elapsed.ToString();

                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] 15 minutes Current value insertion time : " + sTemp_Now);
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] 15분 현재값 삽입 시간 : " + sTemp_Now);
                }

                string sTemp4;
                SW.Reset();
                SW.Start();
                /// ************한시간 데이터 연산********** ///                    
                #region Hour_Data_Calculate
                HourCalCulate_Average(TmpAverageData, TmpMinNow);
                HourCalCulate_Add(TmpAddData, TmpMinNow);
                HourCalCulate_Now(TmpNowData, TmpMinNow);
                HourCalCulate_On(TmpOnData, TmpMinNow);
                HourCalCulate_Add2(TmpAdd2Data, TmpMinNow);
                HourCalCulate_Now2(TmpNow2Data, TmpMinNow);
                #endregion
                ///////////////////////////////////////////////  
                SW.Stop();   // 현재 인스턴스가 측정한 총 경과 시간을 가져옵니다.
                sTemp4 = SW.Elapsed.ToString();

                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] Time data operation time : " + sTemp4);
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] 시간 데이터 연산 시간 : " + sTemp4);
                }
                var Tmp_Expression_result_Hour = TmpAverageData.Union(TmpAddData).Union(TmpNowData).Union(TmpOnData).Union(TmpAdd2Data).Union(TmpNow2Data).ToDictionary(k => k.Key, v => v.Value);
                EP.ReadCSV_Passing_Expression(Tmp_Expression_result_Hour, Hour, TmpMinNow, "Hour", Matching_Tag);

                /// 한시간에 대한 성능분석식
                string sTemp5;
                SW.Reset(); // 
                SW.Start();
                /// *************한시간 삽입***************** ///
                DBI.DB_Hour_Update(TmpAverageData, TmpMinNow, Hour);
                DBI.DB_Hour_Update(TmpAddData, TmpMinNow, Hour);
                if (TmpMinNow == 00)
                {
                    DBI.DB_Hour_Update(TmpNowData, TmpMinNow, Hour);
                }
                DBI.DB_Hour_Update(TmpOnData, TmpMinNow, Hour);
                DBI.DB_Hour_Update(TmpAdd2Data, TmpMinNow, Hour);
                DBI.DB_Hour_Update(TmpNow2Data, TmpMinNow, Hour);

                //////////////////////////////////////////////////  
                SW.Stop();   // 현재 인스턴스가 측정한 총 경과 시간을 가져옵니다.
                sTemp5 = SW.Elapsed.ToString();

                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] Time data insertion time : " + sTemp5);
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] 시간 데이터 삽입 시간 : " + sTemp5);
                }

                var Tmp_Expression_result_Daily = TmpAverageData.Union(TmpAddData).Union(TmpNowData).Union(TmpOnData).Union(TmpAdd2Data).Union(TmpNow2Data).ToDictionary(k => k.Key, v => v.Value);
                EP.ReadCSV_Passing_Expression(Tmp_Expression_result_Daily, Hour, TmpMinNow, "Daily", Matching_Tag);

                string sTemp6;
                SW.Reset();
                SW.Start();
                #region Daily_Update
                DBI.DB_Day_Update(TmpAverageData, TmpMinNow, Hour);
                SW.Stop();   // 현재 인스턴스가 측정한 총 경과 시간을 가져옵니다.
                sTemp6 = SW.Elapsed.ToString();
                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] Daily data insertion time (average) : " + sTemp6);
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] 하루 데이터 삽입 시간(평균) : " + sTemp6);
                }

                string sTemp7;
                SW.Reset();
                SW.Start();
                DBI.DB_Day_Update(TmpAddData, TmpMinNow, Hour);
                //DBI.DB_Hour_Update(TmpNowData, TmpMinNow, Hour);
                SW.Stop();   // 현재 인스턴스가 측정한 총 경과 시간을 가져옵니다.
                sTemp7 = SW.Elapsed.ToString();

                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] Daily data insertion time (accumulation) : " + sTemp7);
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] 하루 데이터 삽입 시간(적산) : " + sTemp7);
                }

                string sTemp8;
                SW.Reset();
                SW.Start();
                DBI.DB_Day_Update(TmpNowData, TmpMinNow, Hour);
                SW.Stop();   // 현재 인스턴스가 측정한 총 경과 시간을 가져옵니다.
                sTemp8 = SW.Elapsed.ToString();

                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] Daily data insertion time (current) : " + sTemp8);
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] 하루 데이터 삽입 시간(현재) : " + sTemp8);
                }

                string sTemp10;
                SW.Reset();
                SW.Start();
                DBI.DB_Day_Update(TmpAdd2Data, TmpMinNow, Hour);
                SW.Stop();   // 현재 인스턴스가 측정한 총 경과 시간을 가져옵니다.
                sTemp10 = SW.Elapsed.ToString();

                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] Daily data insertion time (accumulation 2) : " + sTemp10);
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] 하루 데이터 삽입 시간(적산2) : " + sTemp10);
                }

                string sTemp11;
                SW.Reset();
                SW.Start();
                DBI.DB_Day_Update(TmpNow2Data, TmpMinNow, Hour);
                SW.Stop();   // 현재 인스턴스가 측정한 총 경과 시간을 가져옵니다.
                sTemp11 = SW.Elapsed.ToString();

                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] Daily data insertion time (current 2) : " + sTemp11);
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] 하루 데이터 삽입 시간(현재2) : " + sTemp11);
                }

                string sTemp9;
                SW.Reset();
                SW.Start();
                DBI.DB_Day_Update(TmpOnData, TmpMinNow, Hour);
                SW.Stop();   // 현재 인스턴스가 측정한 총 경과 시간을 가져옵니다.
                sTemp9 = SW.Elapsed.ToString();
                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] Daily data insertion time (uptime) : " + sTemp9);
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] 하루 데이터 삽입 시간(가동시간) : " + sTemp9);
                }
                #endregion

                ////////// Dictionary 초기화//////////////////////
                #region Dic_Clear
                TmpAverageData.Clear();
                TmpAddData.Clear();
                TmpNowData.Clear();
                TmpOnData.Clear();
                TmpNow2Data.Clear();
                TmpAdd2Data.Clear();
                TmpRawData.Clear();
                #endregion
                //////////////////////////////////////////////////

                //////////////////시간 측정 완료////////////////=
                SW.Stop();   // 현재 인스턴스가 측정한 총 경과 시간을 가져옵니다.
                sTemp1 = SW.Elapsed.ToString();
                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] Thread operation time : " + sTemp1 + Environment.NewLine);
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] 스레드 연산 시간 : " + sTemp1 + Environment.NewLine);
                }
                ///////////////////////////////////////////////       
                //_thread.Abort();   // 기존 스레드 종료 - 무작위 종료
                _thread.Abort();   // 신형 스레드 종료 - 다돌고 종료        
                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] : Data collection thread termination");
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] : 데이터 수집 스레드 종료");
                }
            }
            catch (Exception e)
            {
                LogFileCreate LFC = new LogFileCreate();

                if (Form1.Enable_EnglishMode)//영어
                {
                    LFC.Log("[Parsing.cs] : Data collection thread error occurred :" + e);
                }
                else//한글
                {
                    LFC.Log("[Parsing.cs] : 데이터 수집 스레드 에러발생 :" + e);
                }
            }
            finally
            {
                ////////// Dictionary 초기화//////////////////////
                #region Dic_Clear
                TmpAverageData.Clear();
                TmpAddData.Clear();
                TmpNowData.Clear();
                TmpOnData.Clear();
                TmpNow2Data.Clear();
                TmpAdd2Data.Clear();
                TmpRawData.Clear();
                #endregion
                //////////////////////////////////////////////////  
            }
        }

        /// <summary>
        /// 평균 데이터 처리하는 메서드
        /// </summary>
        /// <param name="Min"></param>       
        public void AverageCal_Min(IDictionary<string, float[]> AvrDic, int Min)
        {
            //float[] Average_Tmp2Value;           
            foreach (KeyValuePair<string, float[]> kv in AvrDic)
            {
                //복사한 평균 Dic의 값을 업데이트
                float[] TmpValue = kv.Value;
                TmpValue[0] = TmpValue[0] / TmpValue[1]; // 일반적인 상황이라면 15개 값의 합과 Count15를 나눔
                int CheckData = Select_MinTime_Data(Min);
                TmpValue[CheckData] = TmpValue[0];
                TmpAverageData.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트                                 

                //원본 평균 Dic의 값을 업데이트                
                TmpValue[0] = 0; // 값을 0으로 초기화
                TmpValue[1] = 0; // 카운트를 0으로 초기화   
                AverageData.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트            
            }
        }
        /// <summary>
        /// 적산 데이터 처리하고 INSERT하는 메서드
        /// </summary>
        /// <param name="Min"></param>
        public void AddCal_Min(IDictionary<string, float[]> AddDic, int Min)
        {
            foreach (KeyValuePair<string, float[]> kv in AddDic)
            {
                float[] TmpValue = kv.Value;
                int CheckData = Select_MinTime_Data(Min);
                TmpValue[CheckData] = TmpValue[6];
                TmpAddData.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트  

                TmpValue[6] = 0; // 적산값을 0으로 초기화               
                TmpValue[1] = 0; // 카운트를 0으로 초기화   
                AddData.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트  
            }
        }
        /// <summary>
        /// 현재 데이터 처리하고 INSERT하는 메서드
        /// </summary>
        /// <param name="Min"></param>
        public void NowCal_Min(IDictionary<string, float[]> NowDic, int Min)
        {
            foreach (KeyValuePair<string, float[]> kv in NowDic)
            {
                float[] TmpValue = kv.Value;
                int CheckData = Select_MinTime_Data(Min);
                TmpValue[CheckData] = TmpValue[0];
                TmpNowData.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트  

                TmpValue[0] = 0; // 값을 0으로 초기화
                TmpValue[1] = 0; // 카운트를 0으로 초기화   
                NowData.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트  
            }
        }
        /// <summary>
        /// 가동시간 데이터 연산하고 INSERT하는 메서드
        /// </summary>
        /// <param name="Min"></param>
        public void OnCal_Min(IDictionary<string, float[]> OnDic, int Min)
        {
            foreach (KeyValuePair<string, float[]> kv in OnDic)
            {
                float[] TmpValue = kv.Value;
                int CheckData = Select_MinTime_Data(Min);
                TmpValue[CheckData] = TmpValue[0];
                TmpOnData.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트  

                TmpValue[0] = 0; // 값을 0으로 초기화
                TmpValue[1] = 0; // 카운트를 0으로 초기화   
                OnData.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트  
            }
        }
        /// <summary>
        /// 현재값2 데이터 연산하고 INSERT하는 메서드
        /// </summary>
        /// <param name="Min"></param>
        public void Add2Cal_Min(IDictionary<string, float[]> Add2Dic, int Min)
        {
            //float[] Average_Tmp2Value;           
            foreach (KeyValuePair<string, float[]> kv in Add2Dic)
            {
                //복사한 평균 Dic의 값을 업데이트
                float[] TmpValue = kv.Value;
                TmpValue[0] = (TmpValue[0] / TmpValue[1]) / 4; // 일반적인 상황이라면 15개 값의 합과 Count15를 나누고 4로또 나눔.
                int CheckData = Select_MinTime_Data(Min);
                TmpValue[CheckData] = TmpValue[0];
                TmpAdd2Data.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트                                 

                //원본 평균 Dic의 값을 업데이트                
                TmpValue[0] = 0; // 값을 0으로 초기화
                TmpValue[1] = 0; // 카운트를 0으로 초기화   
                Add2Data.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트            
            }
        }

        public void Now2Cal_Min(IDictionary<string, float[]> Now2Dic, int Min)
        {
            foreach (KeyValuePair<string, float[]> kv in Now2Dic)
            {
                float[] TmpValue = kv.Value;
                if (TmpValue[0] > 0)
                {
                    TmpValue[0] = 1; // 일반적인 상황이라면 15개 값의 합과 Count15를 나눔
                }
                else
                {
                    TmpValue[0] = 0;
                }
                int CheckData = Select_MinTime_Data(Min);
                TmpValue[CheckData] = TmpValue[0];
                TmpNow2Data.TryUpdate(kv.Key, TmpValue, kv.Value); // 복사 현재값2 Dic에 새로운 값을 업데이트    

                TmpValue[0] = 0;
                TmpValue[1] = 0;
                Now2Data.TryUpdate(kv.Key, TmpValue, kv.Value); // 원본 현재값2 Dic에 새로운 값을 업데이트   
            }
        }
        private StringBuilder RawCal_sb = new StringBuilder();

        public void RawCal(int Min)
        {
            /// BemsMonitoringPointHourly Insert&Update
            if ((Min % 15) == 0) //15분인 경우엔 insert
            {
                My_DB_DML MDD = new My_DB_DML();
                string strcon = MDD.ConnDBInfo();
                string query = "";
                string InsertDate = DateTime.Now.ToString("yyyy-MM-dd HH:" + Min + ":00.000");

                using (SqlConnection conn = new SqlConnection(strcon))
                {
                    conn.Open();
                    foreach (KeyValuePair<string, float[]> kv in TmpRawData)
                    {
                        float[] TmpValue = kv.Value;

                        RawCal_sb.Append("INSERT INTO BemsMonitoringPointHistory15minRawData(SiteId,FacilityTypeId,FacilityCode,PropertyId,CreatedDateTime,CurrentValue) ");
                        RawCal_sb.Append("VALUES(" + TmpValue[2] + "," + TmpValue[3] + "," + TmpValue[4] + "," + TmpValue[5] + ",'" + InsertDate + "'," + Math.Round(TmpValue[0], 4, MidpointRounding.AwayFromZero) + ")");
                        query = RawCal_sb.ToString();

                        SqlCommand cmd = new SqlCommand(query, conn);
                        cmd.ExecuteNonQuery();
                        cmd.Dispose();
                        RawCal_sb.Clear();
                    }
                    conn.Close();
                    conn.Dispose();
                }
            }
            TmpRawData.Clear();
        }

        //15분인경우 [8] 에 데이터 업데이트
        //30분인경우 [9] 에 데이터 업데이트
        //45분인경우 [10] 에 데이터 업데이트
        //00분인경우 [11] 에 데이터 업데이트
        public int Select_MinTime_Data(int Min)
        {
            int Check = 0;

            switch (Min)
            {
                case 00:
                    Check = 11;
                    break;
                case 15:
                    Check = 8;
                    break;
                case 30:
                    Check = 9;
                    break;
                case 45:
                    Check = 10;
                    break;
            }
            return Check;
        }

        public void HourCalCulate_Average(IDictionary<string, float[]> AvDic, int Min)
        {
            foreach (KeyValuePair<string, float[]> kv in AvDic)
            {
                float[] TmpValue = kv.Value;
                switch (Min)
                {
                    case 00:
                        TmpValue[12] = (TmpValue[8] + TmpValue[9] + TmpValue[10] + TmpValue[11]) / 4; break;
                    case 15:
                        TmpValue[12] = TmpValue[8]; break;
                    case 30:
                        TmpValue[12] = (TmpValue[8] + TmpValue[9]) / 2; break;
                    case 45:
                        TmpValue[12] = (TmpValue[8] + TmpValue[9] + TmpValue[10]) / 3; break;
                }
                TmpAverageData.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트  
            }
        }

        public void HourCalCulate_Add(IDictionary<string, float[]> AddDic, int Min)
        {
            foreach (KeyValuePair<string, float[]> kv in AddDic)
            {
                float[] TmpValue = kv.Value;
                switch (Min)
                {
                    case 00:
                        TmpValue[12] = (TmpValue[8] + TmpValue[9] + TmpValue[10] + TmpValue[11]); break;
                    case 15:
                        TmpValue[12] = TmpValue[8]; break;
                    case 30:
                        TmpValue[12] = (TmpValue[8] + TmpValue[9]); break;
                    case 45:
                        TmpValue[12] = (TmpValue[8] + TmpValue[9] + TmpValue[10]); break;
                }
                TmpAddData.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트  
            }
        }

        public void HourCalCulate_Now(IDictionary<string, float[]> NowDic, int Min)
        {
            foreach (KeyValuePair<string, float[]> kv in NowDic)
            {
                float[] TmpValue = kv.Value;
                switch (Min)
                {
                    case 00:
                        TmpValue[12] = (TmpValue[11]); break;
                    case 15:
                        TmpValue[12] = TmpValue[8]; break;
                    case 30:
                        TmpValue[12] = (TmpValue[9]); break;
                    case 45:
                        TmpValue[12] = (TmpValue[10]); break;
                }
                TmpNowData.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트  
            }
        }

        public void HourCalCulate_On(IDictionary<string, float[]> OnDic, int Min)
        {
            foreach (KeyValuePair<string, float[]> kv in OnDic)
            {
                float[] TmpValue = kv.Value;
                switch (Min)
                {
                    case 00:
                        TmpValue[12] = (TmpValue[8] + TmpValue[9] + TmpValue[10] + TmpValue[11]); break;
                    case 15:
                        TmpValue[12] = TmpValue[8]; break;
                    case 30:
                        TmpValue[12] = (TmpValue[8] + TmpValue[9]); break;
                    case 45:
                        TmpValue[12] = (TmpValue[8] + TmpValue[9] + TmpValue[10]); break;
                }
                TmpOnData.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트  
            }
        }

        public void HourCalCulate_Add2(IDictionary<string, float[]> Add2Dic, int Min)
        {
            foreach (KeyValuePair<string, float[]> kv in Add2Dic)
            {
                float[] TmpValue = kv.Value;
                switch (Min)
                {
                    case 00:
                        TmpValue[12] = (TmpValue[8] + TmpValue[9] + TmpValue[10] + TmpValue[11]); break;
                    case 15:
                        TmpValue[12] = TmpValue[8]; break;
                    case 30:
                        TmpValue[12] = (TmpValue[8] + TmpValue[9]); break;
                    case 45:
                        TmpValue[12] = (TmpValue[8] + TmpValue[9] + TmpValue[10]); break;
                }
                TmpAdd2Data.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트  
            }
        }

        public void HourCalCulate_Now2(IDictionary<string, float[]> Now2Dic, int Min)
        {
            foreach (KeyValuePair<string, float[]> kv in Now2Dic)
            {
                float[] TmpValue = kv.Value;
                switch (Min)
                {
                    case 00:
                        TmpValue[12] = (TmpValue[8] + TmpValue[9] + TmpValue[10] + TmpValue[11]);
                        break;
                    case 15:
                        TmpValue[12] = TmpValue[8]; break;
                    case 30:
                        TmpValue[12] = (TmpValue[8] + TmpValue[9]); break;
                    case 45:
                        TmpValue[12] = (TmpValue[8] + TmpValue[9] + TmpValue[10]); break;
                }
                if (TmpValue[12] > 1)
                {
                    TmpValue[12] = 1;
                }
                else
                {
                    TmpValue[12] = 0;
                }
                TmpNow2Data.TryUpdate(kv.Key, TmpValue, kv.Value); // 새로운 값을 업데이트  
            }
        }

        public string[] TagParsing()
        {

            string[] TagSum = new string[2];
            string[] CSVReadLine = new string[2];

            int count = 0;

            StringBuilder Sb = new StringBuilder();

            StreamReader sr = new StreamReader("TagSetFile.csv", Encoding.GetEncoding("euc-kr"));
            while (!sr.EndOfStream) // Stream의 끝이 올때까지 반복
            {
                string temp = sr.ReadLine(); // 한줄을 읽음.

                if (!(temp.Length > 0))
                {
                    continue;
                }
                CSVReadLine = temp.Split(',');
                CSVReadLine[1] = CSVReadLine[1].Trim();
                Sb.Append(CSVReadLine[1] + ",");

                count++;
            }
            sr.Close();
            sr.Dispose();
            TagSum[0] = Sb.ToString();
            Sb.Clear();
            TagSum[0] = TagSum[0].Substring(0, TagSum[0].Length - 1);   //맨 마지막의 콤마 제거.
            TagSum[1] = Convert.ToString(count);
            return TagSum;
        }
    }
}



