using DTS.Common.Enums.DBExport;
using DTS.Common.Import.Interfaces;
using DTS.Common.Interface.Groups.GroupList;
using DTS.Common.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Policy;
using System.Text;
using System.Threading.Tasks;
using System.Xml;

namespace DTS.Common.Import.XML
{
    public class XMLParseGroups : XMLParseBase
    {

        public XMLParseGroups(XmlElement root, double importedVersion, Func<bool> isCancelled = null) : base(root, importedVersion, isCancelled)
        {
            _groupIdMapping.Clear();
        }
        public IImportNotification ImportNotification { get; set; }
        public override void Parse(ref ImportObject importObject)
        {
            ImportNotification?.SetStatus(new ImportStatus { PossibleStatus = Enums.PossibleStatus.Reading, ExtraStatus = Enums.ImportExtraStatus.ReadingGroups });
            var staticGroups = ParseGroups(_root, ref importObject);
            if (!staticGroups.Any())
            {
                return;
            }
            var newRoot = ConvertGroups(staticGroups);
            if (newRoot == null)
            {
                return;
            }
            staticGroups = ParseGroups(newRoot, ref importObject);
            importObject.AddStaticGroups(staticGroups);

        }
        private XmlElement ConvertGroups(List<IGroup> staticGroups)
        {
            _writer.WriteStartElement(TopLevelFields.Groups.ToString());
            var count = -2; //Start the normalization at -2, to be consistent with channel mapping(?)
            foreach (var g in staticGroups)
            {
                if (_importedVersion >= FileUtils.DataPRO21XmlVersion)
                {
                    _groupIdMapping[g.Id.ToString()] = count;
                }
                else
                {
                    //Must be an export from 2.0 or earlier
                    _groupIdMapping[g.Name] = count;
                }
                g.Id = count;
                count--;
                foreach (var channel in g.GroupChannelList)
                {
                    if (_dasIdMapping.ContainsKey(channel.DASId))
                    {
                        channel.DASId = _dasIdMapping[channel.DASId];
                    }
                    if (_sensorIdMapping.ContainsKey(channel.SensorId))
                    {
                        channel.SensorId = _sensorIdMapping[channel.SensorId];
                    }
                    else
                    {
                        //FB 14308 - Don't fail Group import if it was 
                        //exported with a deleted sensor.
                        channel.SensorId = 0;
                    }
                }
                _writer.Flush();
                g.WriteXML(ref _writer);
                _writer.Flush();
            }
            _writer.WriteEndElement();
            return GetXmlElement();

        }

        public List<IGroup> ParseGroups(XmlElement root, ref ImportObject importObject)
        {
            List<IGroup> staticGroups = new List<IGroup>();
            var importedHardware = new Dictionary<string, DataPROWin7.DataModel.DASHardware>();
            foreach (var h in importObject.Hardware())
            {
                importedHardware[h.GetHardware().GetId()] = h;
            }
            foreach (var node in root.ChildNodes)
            {
                if (IsCancelled()) { return staticGroups; }
                if (!(node is XmlElement)) continue;

                IGroup groupInstance = GroupHelper.CreateEmptyGroup();
                if (groupInstance != null)
                {
                    var channelLookup = new Dictionary<long, Interface.Channels.IGroupChannel>();
                    var iSensors = new List<Interface.Sensors.ISensorData>();
                    foreach (var sensor in importObject.Sensors())
                    {
                        iSensors.Add(sensor);
                    }
                    var g = groupInstance.ReadXML(node as XmlElement, channelLookup, iSensors);
                    if (!string.IsNullOrWhiteSpace(g.Name))
                    {
                        var groupCopy = GroupHelper.CreateEmptyGroup();
                        groupCopy.Name = g.Name;
                        groupCopy.DisplayName = g.Name;
                        groupCopy.LastModified = g.LastModified;
                        groupCopy.Embedded = g.Embedded;
                        groupCopy.IncludedHardwareStringList = g.IncludedHardwareStringList;
                        groupCopy.Id = g.Id;
                        groupCopy.Tags = g.Tags;
                        staticGroups.Add(groupCopy);

                        foreach (var channel in channelLookup.Select(p => p.Value))
                        {
                            channel.Group = groupCopy;
                            groupCopy.GroupChannelList.Add(channel);
                        }
                    }
                }
            }
            return staticGroups;

        }
    }
}