using System;
using System.Collections.Concurrent;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Timers;
using NLog;
using Xylem.Common.CommonCore.Consts;
using Xylem.Common.Hardware.WaterMeter;
using Xylem.Common.Hardware.WaterMeter.Genesis.DataPackages.MeasurementRecords;
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisConfig;
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore;

namespace TempLogger
{
    public class Program
    {
        private static Logger logger;
        static MeterBatch Batch = new MeterBatch();
        public static void Main(string[] args)
        {
        

            var config = new NLog.Config.LoggingConfiguration();



            Console.WriteLine("TempLogger");


            Console.WriteLine("Enter Slots (e.g. 1,2,3) or Comports(e.g. 1@COM1,3@COM2) in order to Slot Nr (separated by ','):");
            var input = Console.ReadLine();
            var SlotsComports = input.Split(',');
            foreach (var streamInput in SlotsComports)
            {
                if (streamInput.ToLower().Contains("COM"))
                {
                    var slotNr = int.Parse(streamInput.Split('@')[0]);
                    var PortName = streamInput.Split('@')[1];
                    var myStreamingPortConfig = new PortConfig()
                    {
                        PortName = PortName,
                        Type = typeof(Xylem.Common.Hardware.Interfaces.Ports.SerialPorts.LedSerialPort).FullName
                    };
                    var meter = new GenesisMeter(slotNr, null, myStreamingPortConfig);
                    meter.SyncStreamingBuffer(SyncMarkRecord.DecodeEveryPackage);
                    Batch.AddMeter(meter);
                    meter.LogRawData(true);

                }
                else
                {
                    var slotNr = int.Parse(streamInput);
                    var meter = new GenesisMeter();
                    meter.SetupFromConfigFile(slotNr, false, false, true);
                    meter.SyncStreamingBuffer(SyncMarkRecord.DecodeEveryPackage);
                    Batch.AddMeter(meter);
                    meter.LogRawData(true);

                }
            }
            Console.WriteLine("update interval in ms");

            int updateintervall = 1000;
            if (!int.TryParse(Console.ReadLine(), out updateintervall))
            {
                Console.WriteLine("use default interval");
            }
           
       

            Console.WriteLine("LogFile Name and location (e.g. C:\\GenesisLog\\myfirstTempLog\\logname.txt)");
            var filename = Console.ReadLine();

            if (string.IsNullOrEmpty(filename))
            {
                filename = "tempLog.log";
                Console.WriteLine($"use default filename '{filename}'");
            }


            var logfile = new NLog.Targets.FileTarget("logfile") { FileName = filename, Layout =  "${message};" };

            config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile);

            NLog.LogManager.Configuration = config;

            logger = NLog.LogManager.GetCurrentClassLogger();
            logger.Info("Meter;Channel;Temp;LastUpdate;accuflow");


            Console.WriteLine("Press any key to exit");
            var t = Task.Factory.StartNew(() =>
            {
                var aTimer = new System.Timers.Timer(updateintervall);
                // Hook up the Elapsed event for the timer. 
                aTimer.Elapsed += OnTimedEvent;
                aTimer.AutoReset = true;
                aTimer.Enabled = true;

                foreach (var basemeter in Batch.ListOfMeters)
                {
                    var meter = basemeter as GenesisMeter;
                    if (meter != null)
                    {
                        meter.StreamingProtocol.OnRecordIsDecoded += (sender, eventArgs) =>
                        {
                            if (eventArgs.GetEventData() is CalibrationRecord)
                            {
                                var calib = (CalibrationRecord)eventArgs.GetEventData();
                                var ident = new MeterTempIdent()
                                {
                                    Slot = meter.Slot,
                                    Channel = calib.Channel,
                                };


                                var a = new MeterTempData()
                                {
                                    LastUpdate = calib.ReceivedTime,
                                    Temp = calib.TemperatureDegC,
                                    rawVolume = calib.AccuVolumeRaw,
                                    
                                };

                                tempMeterCollections.AddOrUpdate(ident, a, (key, oldValue) => a);
                            }


                        };
                    }


                }
            });



            Console.ReadLine();
            t.Dispose();
            Batch.Dispose();

        }
        static ConcurrentDictionary<MeterTempIdent, MeterTempData> tempMeterCollections = new ConcurrentDictionary<MeterTempIdent, MeterTempData>();
        public class MeterTempIdent
        {
            public int Slot;
            public int Channel;

            public override bool Equals(object obj)
            {
                var fooItem = obj as MeterTempIdent;

                return GetHashCode() == fooItem.GetHashCode();
            }

            public override int GetHashCode()
            {
                int hashCode = Slot.GetHashCode();
                hashCode ^= Channel.GetHashCode();
                return hashCode;
            }
        }
        public class MeterTempData
        {
            public double Temp;
            public DateTimeOffset LastUpdate;
            public double rawVolume;

        }

        private static void OnTimedEvent(object sender, ElapsedEventArgs e)
        {
            StringBuilder sbHL = new StringBuilder();
            Console.Clear();
            sbHL.Append("Meter\t\t");
            foreach (var meter in Batch.ListOfMeters)
            {
                sbHL.Append("\t\t");
                sbHL.Append(meter.Slot);
            }

            Console.WriteLine(sbHL.ToString());

            getLinesOFPrint(1);
            getLinesOFPrint(2);
            getLinesOFPrint(3);

            foreach (var meter in Batch.ListOfMeters)
            {
                if (meter is GenesisMeter)
                {
                    ((GenesisMeter)meter).SyncStreamingBuffer(SyncMarkRecord.FlushBuffer);
                }
            }

        }

        static void getLinesOFPrint(int channel)
        {

            StringBuilder sbHL = new StringBuilder();
            StringBuilder sbUpdate = new StringBuilder();
            StringBuilder sbFlow = new StringBuilder();

            sbHL.Append($"Temp Channel {channel} Temp C°");

            sbUpdate.Append($"Temp Channel {channel} Update S");
            sbFlow.Append($"Temp Channel {channel} Flow");
            foreach (var meter in Batch.ListOfMeters)
            {
                sbHL.Append("\t\t");
                sbUpdate.Append("\t\t");
                sbFlow.Append("\t\t");
                var DataToPrint = tempMeterCollections.Where(a => a.Key.Slot == meter.Slot && a.Key.Channel == channel);

                if (DataToPrint.Any() && DataToPrint.First().Value != null)
                {

                    sbHL.Append(DataToPrint.First().Value.Temp.ToString("N4"));

                    var ts = DateTimeOffset.Now - DataToPrint.First().Value.LastUpdate;
                    sbUpdate.Append(ts.TotalSeconds.ToString("N1"));
                    sbFlow.Append(DataToPrint.First().Value.rawVolume);
                    logger.Info($"{meter.Slot};{channel};{DataToPrint.First().Value.Temp};{DataToPrint.First().Value.LastUpdate};{DataToPrint.First().Value.rawVolume}");
                }
                else
                {

                    sbHL.Append("-");
                    sbUpdate.Append("-");
                    sbFlow.Append("-");
                    logger.Info($"{meter.Slot};{channel};-;-;-");

                }
            }
            Console.WriteLine(sbHL.ToString());
            Console.WriteLine(sbUpdate.ToString());
            Console.WriteLine(sbFlow.ToString());

        }
    }
}