using DataPROWin7.DataModel;
using DTS.Common.Classes.Groups;
using DTS.Common.Classes.Sensors;
using DTS.Common.Interface.Groups.GroupList;
using DTS.Common.Storage;
using DTS.SensorDB;
using System;
using System.Collections.Generic;
using System.Linq;
//FB 36879 updated to handle csv group process logic only 
namespace DTS.Common.Import
{
    public class CSVGroupImport : IGroupImport
    {
        public ParseParameters ParseParameters { get; set; }
        public Tuple<TestTemplate, List<IGroup>> CreateGroups(List<SensorData> sensors, Dictionary<string, List<TsetSetupImportSensorInfo>> groupSensorLookup,
            TestTemplate testTemplate, bool createDynamicGroups, List<IGroup> staticGroups, Action<double> setProgress)
        {
            var channelDefaults = DbOperations.GetChannelSettingDefaults();
            var sensorLookup = sensors.ToDictionary(s => s.SerialNumber);

            if (groupSensorLookup == null || !groupSensorLookup.Any())
            {
                return null;
            }

            var allDAS = DataPROWin7.DataModel.Classes.Hardware.DASHardwareList.GetAllHardware();

            var dasSerialToId = GroupHelper.GetDAS(groupSensorLookup, allDAS);
            if (dasSerialToId.Count > 0)
            {
                using (var e = dasSerialToId.GetEnumerator())
                {
                    while (e.MoveNext())
                    {
                        testTemplate.AddHardware(e.Current.Value);
                    }
                }
            }

            int total = groupSensorLookup.Count;
            int current = 0;
            var displayOrder = 1;

            foreach (var group in groupSensorLookup)
            {
                // Make your template
                var newGroup = GroupHelper.CreateEmptyGroup();
                newGroup.Name = group.Key;
                newGroup.DisplayName = newGroup.Name;

                var importTemplateChannelList = group.Value;
                List<Interface.Channels.IGroupChannel> groupChannels = new List<Interface.Channels.IGroupChannel>();
                foreach (var ch in importTemplateChannelList)
                {
                    var groupChannel = new GroupChannel(false, newGroup.DisplayName, newGroup, channelDefaults);
                    if (!string.IsNullOrWhiteSpace(ch.DASSerialNumber) && dasSerialToId.ContainsKey(ch.DASSerialNumber))
                    {
                        groupChannel.DASId = dasSerialToId[ch.DASSerialNumber];
                    }
                    if (ch.DASChannelIndex >= 0)
                    {
                        groupChannel.DASChannelIndex = ch.DASChannelIndex;
                    }

                    if (sensorLookup.ContainsKey(ch.SerialNumber))
                    {
                        var sd = sensorLookup[ch.SerialNumber];
                        var tsetSetupImportSensorInfo = group.Value.Find(p => p.SerialNumber == ch.SerialNumber && p.DASSerialNumber == ch.DASSerialNumber);
                        if (tsetSetupImportSensorInfo != null)
                        {
                            groupChannel.IsoChannelName = tsetSetupImportSensorInfo.IsoChannelName;
                            groupChannel.UserChannelName = tsetSetupImportSensorInfo.UserChannelName;
                            groupChannel.UserCode = tsetSetupImportSensorInfo.UserCode;
                            groupChannel.IsoCode = tsetSetupImportSensorInfo.IsoCode;
                        }
                        else
                        {
                            groupChannel.IsoChannelName = sd.Comment;
                            groupChannel.UserChannelName = sd.Comment;
                            groupChannel.UserCode = ch.UserCode;
                            groupChannel.IsoCode = ch.IsoCode;
                        }

                        groupChannel.SetSensorData(sd, null, true);
                        groupChannel.SensorId = sd.DatabaseId;
                        groupChannel.Range = sd.Capacity;

                        //http://manuscript.dts.local/f/cases/43490/Full-scale-is-used-for-channel-desired-range-in-import
                        //set range using sd.Range if it's set and it's different than capacity and is valid
                        //the default value is 0 so if we have a non zero value it should have been explicitly set
                        //in the CSV import version this gets set to rangelow/rangehigh/rangemedium
                        if (!ParseParameters.ImportContainedSensorRanges && sd.RangeHigh == sd.RangeLow && sd.RangeLow == sd.RangeMedium && Math.Abs(sd.Capacity - sd.RangeLow) > .1 && sd.IsAnalog() && sd.RangeMedium > 1)
                        {
                            groupChannel.Range = sd.RangeLow;
                        }

                        groupChannel.FilterClass = sd.FilterClass;
                        groupChannel.Polarity = sd.Polarity;

                        groupChannel.SquibLimitDuration = sd.LimitSquibFireDuration;
                        groupChannel.SquibDuration = sd.SquibFireDurationMS;
                        groupChannel.SquibDelay = sd.SquibFireDelayMS;
                        groupChannel.SquibFireMode = sd.SquibFireMode;
                        groupChannel.SquibCurrent = sd.SquibOutputCurrent;

                        groupChannel.DigitalOutputMode = sd.DigitalOutputMode;
                        groupChannel.DigitalOutDelay = sd.DigitalOutputDelayMS;
                        groupChannel.DigitalOutDuration = sd.DigitalOutputDurationMS;

                        groupChannel.DigitalInputMode = sd.InputMode;
                        groupChannel.ActiveValue = sd.InputActiveValue.ToString("N0");
                        groupChannel.DefaultValue = sd.InputDefaultValue.ToString("N0");

                        if (null != sd.Calibration)
                        {
                            groupChannel.AvailableInitialOffsets = sd.Calibration.InitialOffsets.Offsets;
                            groupChannel.InitialOffset = sd.Calibration.InitialOffsets.DefaultOffset;
                            //FB 36905 & 35530 check for null 
                            groupChannel.ZeroMethod = sd.Calibration.ZeroMethods.Methods[0].Method;
                            groupChannel.ZeroMethodStart = sd.Calibration.ZeroMethods.Methods[0].Start;
                            groupChannel.ZeroMethodEnd = sd.Calibration.ZeroMethods.Methods[0].End;
                        }

                        groupChannel.GroupChannelOrder = 1 + sensors.IndexOf(sd);
                        groupChannel.TestSetupOrder = 1 + sensors.IndexOf(sd);
                    }
                    groupChannels.Add(groupChannel);
                }
                newGroup.GroupChannelList = groupChannels;
                if (!createDynamicGroups)
                {
                    staticGroups.Add(newGroup);
                }
                newGroup.DisplayOrder = displayOrder++;
                testTemplate.Groups.Add(newGroup);
                testTemplate.ChannelsForGroup[newGroup] = groupChannels.ToArray();

                setProgress(100D * current / total);
                current++;
            }
            return Tuple.Create(testTemplate, staticGroups);

        }

        public Dictionary<string, List<TsetSetupImportSensorInfo>> GetGroupSensorLookup(List<SensorData> sensors, Dictionary<string, string> sensorGroupNameLookup, Dictionary<string, List<string>> groupNameSensorListLookup)
        {
            Dictionary<string, List<TsetSetupImportSensorInfo>> groupSensorLookup = new Dictionary<string, List<TsetSetupImportSensorInfo>>();
            //FB 30358 Either sensorGroupNameLookup or groupNameSensorListLookup will be populated. dependes on the child class
            if (sensorGroupNameLookup != null && sensorGroupNameLookup.Any())
            {
                groupSensorLookup = sensorGroupNameLookup.Values.Distinct().AsEnumerable().
                   ToDictionary(groupName => groupName, groupName => new List<TsetSetupImportSensorInfo>());

                foreach (var s in sensors)
                {
                    // Build the group sensor and group type dictionary
                    if (!sensorGroupNameLookup.ContainsKey(s.SerialNumber)) continue;

                    GroupHelper.GetTestSensorParameters(out var isoCode, out var isoChannelName, out var userCode, out var userChannelName, ParseParameters,
                        s, out var dasSerialNumber, out var dasChannelIdx);

                    // add to group dictionary
                    groupSensorLookup[sensorGroupNameLookup[s.SerialNumber]].Add(new TsetSetupImportSensorInfo(s.SerialNumber, isoCode,
                        isoChannelName, userCode, userChannelName, dasSerialNumber, dasChannelIdx));
                }
            }

            if (groupNameSensorListLookup != null && groupNameSensorListLookup.Any())
            {
                foreach (var g in groupNameSensorListLookup)
                {
                    groupSensorLookup.Add(g.Key, new List<TsetSetupImportSensorInfo>());
                    foreach (var sensorSerialNumber in g.Value)
                    {
                        var sd = sensors.Find(s => s.SerialNumber == sensorSerialNumber);

                        if (sd != null)
                        {
                            GroupHelper.GetTestSensorParameters(out var isoCode, out var isoChannelName, out var userCode, out var userChannelName,
                                ParseParameters, sd, out var dasSerialNumber, out var dasChannelIdx);
                            groupSensorLookup[g.Key].Add(new TsetSetupImportSensorInfo(sd.SerialNumber, sd.ISOCode,
                                isoChannelName, userCode, userChannelName, dasSerialNumber, dasChannelIdx));
                        }
                    }
                }
            }

            return groupSensorLookup;
        }
    }
}