using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Xml.Linq;
using DataPROWin7.DataModel;
using DTS.Common.Import.ImportOptions;
using DTS.Common.Import.Parsers;
using DTS.Common.Interface.Groups.GroupList;
using DTS.Common.SharedResource.Strings;
using DTS.Common.Utilities.Logging;
using DTS.Common.Utils;
using DTS.SensorDB;

namespace DTS.Common.Import
{
    public class EQXTestSetupParser : ParseVariantBase
    {
        private readonly IImportNotification _importNotification;
        private readonly EqxImportOptions _eqxImportOptions;
        private readonly IGroupImport _groupImport;
        private readonly EquipmentExchange.EQXSensorDatabase _eqxSensorDatabase;
        private readonly bool _createDynamicGroups;
        public EQXTestSetupParser(IImportNotification importNotification, EqxImportOptions eqxImportOptions,
             IGroupImport groupImport, EquipmentExchange.EQXSensorDatabase eqxSensorDatabase, bool createDynamicGroups)
        {
            _eqxImportOptions = eqxImportOptions;
            _importNotification = importNotification;
            _groupImport = groupImport;
            _eqxSensorDatabase = eqxSensorDatabase;
            _createDynamicGroups = createDynamicGroups;
        }
        private void FixCalibrations(ImportObject importObject)
        {
            try
            {
                var sensors = importObject.Sensors().ToArray();
                foreach (var sensor in sensors)
                {
                    if (null == sensor) { continue; }
                    var cals = importObject.CalibrationLookup(sensor.SerialNumber);
                    if (null != cals && cals.Count > 0)
                    {
                        cals.Sort();
                        sensor.Calibration = cals[0];
                    }
                }
            }
            catch (Exception ex)
            {
                APILogger.Log("EQXTestSetupParser.FixCalibrations failed to fix calibrations", ex);
            }
        }
        public override void Parse(ref ImportObject importObject)
        {
            if (string.IsNullOrEmpty(FileName))
            {
                return;
            }

            if (importObject == null)
            {
                throw new ArgumentNullException("importObject", "importObject can't be null or empty");
            }

            var sensorImportData = _eqxSensorDatabase.GetImportData();
            //FB 40750 if there is not Group name test then the eqx file does not have any test setup
            if (sensorImportData.GroupNameTestObjectLookup == null || !sensorImportData.GroupNameTestObjectLookup.Any())
            {
                //abort the import process 
                importObject.AddError(new ImportError { ContinueImportOnError = false, Message = StringResources.Import_EQXFileNotForTestSetup, Severity = ImportSeverityError.Critical });
                return;
            }

            importObject.AssignGroupNameTestObjectLookup(sensorImportData.GroupNameTestObjectLookup);
            importObject.AssignGroupNameSensorsLookup(sensorImportData.GroupNameSensorListLookup);

            var testTemplate = new TestTemplate();
            var setupName = ParseSetupName(FileName);
            testTemplate.Name = setupName == string.Empty ? Path.GetFileNameWithoutExtension(FileName) : setupName;

            if (importObject.TestSetups().Any(p => p.Name == testTemplate.Name))
            {
                return;
            }

            FixCalibrations(importObject);

            var res = AssignGroupsToTestSetup(testTemplate, importObject, sensorImportData.GroupNameSensorListLookup,
                _groupImport, _importNotification);

            var sensors = res.Item3;
            var testSetup = res.Item1;
            var staticGroups = res.Item2;

            if (staticGroups != null)
            {
                importObject.AddStaticGroups(staticGroups);
            }
            var cleanedSensors = GroupHelper.CleanUneededSensorDataPlaceHolder(importObject.CalibrationsLookup(), sensors);

            importObject.ClearSensors();
            importObject.AddSensors(cleanedSensors);

            importObject.AddTestSetup(testSetup);
            //FB 38039,40758 Identify single test setup in import file
            importObject.TestSetupImportFileFormat = importObject.GetImportFileFormat();
        }
        
        //FB 36879 Single repsposibility principle , moved the method to this class
        private Tuple<TestTemplate, List<IGroup>, List<SensorData>> AssignGroupsToTestSetup(TestTemplate testTemplate, ImportObject importObject, Dictionary<string, List<string>> groupNameSensorListLookup,
           IGroupImport groupImport, IImportNotification importNotification)
        {
            var sensorGroupNameLookup = importObject.SensorGroupNamesLookup();
            var existingStaticGroups = importObject.StaticGroups().ToList();
            var sensors = importObject.Sensors().ToList();
            try
            {
                _ = GroupHelper.ReverseChannelOrder(testTemplate, sensorGroupNameLookup, sensors);

                var groupSensorLookup = groupImport.GetGroupSensorLookup(sensors, sensorGroupNameLookup, groupNameSensorListLookup);

                sensors = GroupHelper.NormalizeSensorIds(sensors);
                //http://manuscript.dts.local/f/cases/44105/EQX-Import-does-not-overwrite-zero-method-consistently-in-the-parameters-of-test-setup-but-consistently-for-sensor-database
                //normalizesensorids above can reset the calibrations for sensors - revert back to the calibration in the import ...
                FixCalibrations(importObject);
                //FB 36905
                var testAndGroups = groupImport.CreateGroups(sensors, groupSensorLookup, testTemplate, _createDynamicGroups, existingStaticGroups, importNotification.SetProgress);

                if (testAndGroups == null)
                {
                    TestTemplate noTestSetup = null;
                    List<IGroup> noGroup = null;
                    return Tuple.Create(noTestSetup, noGroup, sensors);
                }
                return Tuple.Create(testAndGroups.Item1, testAndGroups.Item2, sensors);
            }
            catch (Exception ex)
            {
                importNotification.ReportErrors(new List<string> { ex.Message });
                return null;
            }
        }

        //FB 39054 parse setup name from eqx
        private string ParseSetupName(string filename)
        {
            XDocument xDoc = null;
            try
            {
                xDoc = XDocument.Load(filename);
                var fields = xDoc.Elements("Sensors").Select(x => x.Elements("Fields")).FirstOrDefault();
                if (fields.Any())
                {
                    var setupName = fields.Select(x => x.Element("SetupName").Value).FirstOrDefault();
                    return setupName;
                }
            }
            catch
            {
                return string.Empty;
            }
            return string.Empty;
        }
    }
}