DP44/Common/DTS.Common.Import/ImportObject.cs

using DataPROWin7.DataModel;
using DTS.Common.Import.Enums;
using DTS.Common.Interface.Sensors;
using DTS.Common.ISO;
using DTS.SensorDB;
using DTS.Slice.Users;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using DTS.Common.Classes.Sensors;

namespace DTS.Common.Import
{
    public class ImportObject
    {
        public ImportFormats SourceFormat { get; set; } = ImportFormats.NOT_SPECIFIED;

        private readonly List<TestTemplate> _testSetups = new List<TestTemplate>();
        private readonly List<SensorCalibration> _calibrations = new List<SensorCalibration>();

        private readonly List<DataPROWin7.DataModel.TestObjectTemplate> _groupTemplates = new List<DataPROWin7.DataModel.TestObjectTemplate>();

        private readonly List<SensorData> _sensors = new List<SensorData>();
        private readonly List<DASHardware> _hardware = new List<DASHardware>();

        private readonly List<Interface.Groups.GroupList.IGroup> _iGroups = new List<Interface.Groups.GroupList.IGroup>();
        private readonly List<DataPROWin7.DataModel.TestObject> _groupList = new List<DataPROWin7.DataModel.TestObject>();

        private readonly List<MMEPositions> _positions = new List<MMEPositions>();
        private readonly List<MMEPhysicalDimensions> _physicalDimensions = new List<MMEPhysicalDimensions>();
        private readonly List<MMETransducerMainLocation> _mainLocations = new List<MMETransducerMainLocation>();
        private readonly List<MMEDirections> _directions = new List<MMEDirections>();
        private readonly List<MMEFilterClasses> _filterClasses = new List<MMEFilterClasses>();
        private readonly List<MMEFineLocations1> _fineLoc1s = new List<MMEFineLocations1>();
        private readonly List<MMEFineLocations2> _fineLoc2s = new List<MMEFineLocations2>();
        private readonly List<MMEFineLocations3> _fineLoc3s = new List<MMEFineLocations3>();
        private readonly List<MMETestObjects> _testObjects = new List<MMETestObjects>();
        private readonly List<MMEPossibleChannels> _customChannels = new List<MMEPossibleChannels>();

        private readonly List<ISO.CustomerDetails> _customerDetails = new List<ISO.CustomerDetails>();
        private readonly List<ISO.TestEngineerDetails> _testEngineerDetails = new List<ISO.TestEngineerDetails>();
        private readonly List<ISO.LabratoryDetails> _labDetails = new List<ISO.LabratoryDetails>();

        private Dictionary<string, string> _globalSettings = new Dictionary<string, string>();
        private readonly List<User> _users = new List<User>();

        private Dictionary<string, SensorData> _sensorLookup = new Dictionary<string, SensorData>();
        private Dictionary<string, SensorModel> _sensorModelLookup = new Dictionary<string, SensorModel>();
        private readonly List<SensorModel> _sensorModels = new List<SensorModel>();

        private Dictionary<string, List<SensorCalibration>> _calibrationLookup = new Dictionary<string, List<SensorCalibration>>();

        private readonly Dictionary<string, string> _sensorChannelCodeLookup = new Dictionary<string, string>();
        private Dictionary<string, string> _sensorGroupNameLookup = new Dictionary<string, string>();
        private Dictionary<string, string> _sensorGroupTypeLookup = new Dictionary<string, string>();
        private Dictionary<string, string> _groupNameTestObjectLookup = new Dictionary<string, string>();
        private Dictionary<string, List<string>> _groupNameSensorsLookup = new Dictionary<string, List<string>>();

        private Dictionary<int, int> _oldSensorDatabaseIdToNew = new Dictionary<int, int>();

        private readonly List<ImportError> _errors = new List<ImportError>();
        //FB 36879 Added parse parameters
        private ParseParameters _parseParameters = new ParseParameters();


        public ImportFileFormat GetImportFileFormat()
        {
            var testSetupCount = _testSetups.Count;

            return GetImportFileFormat(testSetupCount);
        }

        public static ImportFileFormat GetImportFileFormat(int testSetupCount)
        {
            if (testSetupCount == 1)
            {
                return ImportFileFormat.SingleTestSetup;
            }

            if (testSetupCount > 1)
            {
                return ImportFileFormat.MultipleTestSetup;
            }

            return ImportFileFormat.NoTestSetup;
        }

        public void AssignParseParameters(ParseParameters parseParameters)
        {
            _parseParameters = parseParameters;
        }

        public ParseParameters ParseParameters() => _parseParameters;

        public void ClearErrors() => _errors.Clear();
        public void AddErrors(IEnumerable<ImportError> d) => _errors.AddRange(d);
        public void AddError(ImportError d) => _errors.Add(d);
        public IEnumerable<ImportError> Errors() => _errors;
        //FB 40758
        /// <summary>
        /// Specify the type of test setup file, single, multiple, no test setup
        /// </summary>
        public ImportFileFormat TestSetupImportFileFormat { get; set; } = ImportFileFormat.NoTestSetup;

        public void AssignOldSensorDatabaseIdToNew(Dictionary<int, int> oldSensorDatabaseIdToNew)
        {
            _oldSensorDatabaseIdToNew = new Dictionary<int, int>(oldSensorDatabaseIdToNew);
        }
        public void AddOldSensorDatabaseIdToNew(int key, int value)
        {
            _oldSensorDatabaseIdToNew[key] = value;
        }
        public int OldSensorDatabaseIdToNew(int key)
        {
            return _oldSensorDatabaseIdToNew[key];
        }
        public Dictionary<int, int> OldSensorDatabaseIdsToNew()
        {
            return _oldSensorDatabaseIdToNew;
        }

        public void AssignGlobalSettings(Dictionary<string, string> settings) => _globalSettings = new Dictionary<string, string>(settings);
        public void AddGlobalSettings(string key, string value) => _globalSettings[key] = value;
        public string GlobalSetting(string key) => _globalSettings[key];
        public Dictionary<string, string> GlobalSettings() => _globalSettings;

        public void AddCustomPhysicalDimensions(IEnumerable<MMEPhysicalDimensions> d) => _physicalDimensions.AddRange(d);
        public void AddCustomPhysicalDimension(MMEPhysicalDimensions d) => _physicalDimensions.Add(d);
        public IEnumerable<MMEPhysicalDimensions> PhysicalDimensions() => _physicalDimensions;

        public void AddCustomPositions(IEnumerable<MMEPositions> d) => _positions.AddRange(d);
        public void AddCustomPosition(MMEPositions d) => _positions.Add(d);
        public IEnumerable<MMEPositions> CustomPositions() => _positions;

        public void AddCustomFilterClasses(IEnumerable<MMEFilterClasses> d) => _filterClasses.AddRange(d);
        public void AddCustomFilterClass(MMEFilterClasses d) => _filterClasses.Add(d);
        public IEnumerable<MMEFilterClasses> CustomFilterClasses() => _filterClasses;


        public void AddCustomFineLoc1s(IEnumerable<MMEFineLocations1> d) => _fineLoc1s.AddRange(d);
        public void AddCustomFineLoc1(MMEFineLocations1 d) => _fineLoc1s.Add(d);
        public IEnumerable<MMEFineLocations1> CustomFineLoc1s() => _fineLoc1s;

        public void AddCustomFineLoc2s(IEnumerable<MMEFineLocations2> d) => _fineLoc2s.AddRange(d);
        public void AddCustomFineLoc2(MMEFineLocations2 d) => _fineLoc2s.Add(d);
        public IEnumerable<MMEFineLocations2> CustomFineLoc2s() => _fineLoc2s;

        public void AddCustomFineLoc3s(IEnumerable<MMEFineLocations3> d) => _fineLoc3s.AddRange(d);
        public void AddCustomFineLoc3(MMEFineLocations3 d) => _fineLoc3s.Add(d);
        public IEnumerable<MMEFineLocations3> CustomFineLoc3s() => _fineLoc3s;

        public void AddDirections(IEnumerable<MMEDirections> d) => _directions.AddRange(d);
        public void AddDirection(MMEDirections d) => _directions.Add(d);
        public IEnumerable<MMEDirections> Directions() => _directions;

        public void AddCustomMainLocations(IEnumerable<MMETransducerMainLocation> d) => _mainLocations.AddRange(d);
        public void AddCustomMainLocation(MMETransducerMainLocation d) => _mainLocations.Add(d);
        public IEnumerable<MMETransducerMainLocation> CustomMainLocations() => _mainLocations;

        public void AddUsers(IEnumerable<User> users) => _users.AddRange(users);
        public void AddUser(User user) => _users.Add(user);
        public IEnumerable<User> Users() => _users;

        public void AddSensorModels(IEnumerable<SensorModel> s) => _sensorModels.AddRange(s);
        public void AddSensorModel(SensorModel s) => _sensorModels.Add(s);
        public IEnumerable<SensorModel> SensorModels() => _sensorModels;


        public void AddCustomChannels(IEnumerable<MMEPossibleChannels> channels) => _customChannels.AddRange(channels);
        public void AddCustomChannel(MMEPossibleChannels channel) => _customChannels.Add(channel);
        public IEnumerable<MMEPossibleChannels> CustomChannels() => _customChannels;


        public void AddTestObjects(IEnumerable<MMETestObjects> objects) => _testObjects.AddRange(objects);
        public void AddTestObject(MMETestObjects objects) => _testObjects.Add(objects);
        public IEnumerable<MMETestObjects> TestObjects() => _testObjects;

        public void AddHardwareList(IEnumerable<DASHardware> hardwareList)
        {
            _hardware.AddRange(hardwareList);
        }
        public void AddHardware(DASHardware hardware)
        {
            _hardware.Add(hardware);
        }
        public IEnumerable<DASHardware> Hardware()
        {
            return _hardware;
        }

        public void AddCalibrations(IEnumerable<SensorCalibration> sensorCalibrations)
        {
            _calibrations.AddRange(sensorCalibrations);
        }
        public void AddCalibration(SensorCalibration sensorCalibration)
        {
            _calibrations.Add(sensorCalibration);
        }
        public IEnumerable<SensorCalibration> Calibrations()
        {
            return _calibrations;
        }

        public void AddTestSetups(IEnumerable<TestTemplate> testTemplates)
        {
            _testSetups.AddRange(testTemplates);
        }
        public void AddTestSetup(TestTemplate testTemplate)
        {
            _testSetups.Add(testTemplate);
        }
        public IEnumerable<TestTemplate> TestSetups()
        {
            return _testSetups;
        }
        public void ClearTestSetups()
        {
            _testSetups.Clear();
        }

        public void AddGroups(IEnumerable<DataPROWin7.DataModel.TestObject> groups)
        {
            _groupList.AddRange(groups);
        }
        public void AddGroup(DataPROWin7.DataModel.TestObject group)
        {
            _groupList.Add(group);
        }
        public IEnumerable<DataPROWin7.DataModel.TestObject> Groups()
        {
            return _groupList;
        }

        public void AddSensors(IEnumerable<SensorData> sensorsData)
        {
            _sensors.AddRange(sensorsData);
        }
        public void AddSensor(SensorData sensorData)
        {
            _sensors.Add(sensorData);
        }
        public IEnumerable<SensorData> Sensors()
        {
            return _sensors;
        }

        public IReadOnlyDictionary<int, ISensorData> GetSensorLookup()
        {
            var lookup = new Dictionary<int, ISensorData>();

            var sensors = Sensors();
            foreach (var sensor in sensors)
            {
                if (lookup.ContainsKey(sensor.DatabaseId))
                {
                    //I would prefer this in the APIlog, but it doesn't seem to be accessible here
                    //and I didn't think it work of putting a delegate around
                    System.Diagnostics.Trace.WriteLine($"sensor {sensor.SerialNumber} [{sensor.DatabaseId}] is a duplicate of {lookup[sensor.DatabaseId].SerialNumber}");
                }
                else { lookup[sensor.DatabaseId] = sensor; }
            }

            return lookup;
        }
        public void ClearSensors()
        {
            _sensors.Clear();
        }

        public void AddGroupTemplates(IEnumerable<DataPROWin7.DataModel.TestObjectTemplate> templates)
        {
            _groupTemplates.AddRange(templates);
        }
        public void AddGroupTemplate(DataPROWin7.DataModel.TestObjectTemplate template)
        {
            _groupTemplates.Add(template);
        }
        public IEnumerable<DataPROWin7.DataModel.TestObjectTemplate> GroupTemplates()
        {
            return _groupTemplates;
        }


        public void AddCustomerDetailsList(IEnumerable<ISO.CustomerDetails> details)
        {
            _customerDetails.AddRange(details);
        }
        public void AddCustomerDetails(ISO.CustomerDetails details)
        {
            _customerDetails.Add(details);
        }
        public IEnumerable<ISO.CustomerDetails> CustomerDetails()
        {
            return _customerDetails;
        }


        public void AddLabDetailsList(IEnumerable<ISO.LabratoryDetails> details)
        {
            _labDetails.AddRange(details);
        }
        public void AddLabDetails(ISO.LabratoryDetails details)
        {
            _labDetails.Add(details);
        }
        public IEnumerable<ISO.LabratoryDetails> LabDetails()
        {
            return _labDetails;
        }

        public void AddTestEngineerDetailsList(IEnumerable<ISO.TestEngineerDetails> details)
        {
            _testEngineerDetails.AddRange(details);
        }
        public void AddTestEngineerDetails(ISO.TestEngineerDetails details)
        {
            _testEngineerDetails.Add(details);
        }
        public IEnumerable<ISO.TestEngineerDetails> TestEngineerDetails()
        {
            return _testEngineerDetails;
        }

        public void AddStaticGroups(IEnumerable<Interface.Groups.GroupList.IGroup> groups)
        {
            _iGroups.AddRange(groups);
        }
        public void AddStaticGroup(Interface.Groups.GroupList.IGroup group)
        {
            _iGroups.Add(group);
        }
        public IEnumerable<Interface.Groups.GroupList.IGroup> StaticGroups()
        {
            return _iGroups;
        }

        public void AssignSensorLookup(Dictionary<string, SensorData> sensorLookup)
        {
            _sensorLookup = new Dictionary<string, SensorData>(sensorLookup);
        }
        public void AddSensorLookup(string serial, SensorData sensorData)
        {
            _sensorLookup[serial] = sensorData;
        }
        public SensorData SensorLookup(string serial)
        {
            return _sensorLookup[serial];
        }
        public Dictionary<string, SensorData> SensorsLookup()
        {
            return _sensorLookup;
        }

        public void AssignCalibrationLookup(Dictionary<string, List<SensorCalibration>> calibrationLookup)
        {
            _calibrationLookup = new Dictionary<string, List<SensorCalibration>>(calibrationLookup);
        }
        public void AddCalibrationLookup(string serial, List<SensorCalibration> sensorCalibrations)
        {
            _calibrationLookup[serial] = sensorCalibrations;
        }
        public List<SensorCalibration> CalibrationLookup(string serial)
        {
            return _calibrationLookup[serial];
        }
        public Dictionary<string, List<SensorCalibration>> CalibrationsLookup()
        {
            return _calibrationLookup;
        }

        public void AssignSensorModelLookup(Dictionary<string, List<SensorCalibration>> calibrationLookup)
        {
            _sensorModelLookup = new Dictionary<string, SensorModel>();
        }
        public void AddSensorModelLookup(string key, SensorModel sensorModel)
        {
            _sensorModelLookup[key] = sensorModel;
        }
        public SensorModel SensorModelLookup(string key)
        {
            return _sensorModelLookup[key];
        }
        public Dictionary<string, SensorModel> SensorModelsLookup()
        {
            return _sensorModelLookup;
        }

        public void AssignSensorGroupNameLookup(Dictionary<string, string> sensorGroupNameLookup)
        {
            _sensorGroupNameLookup = new Dictionary<string, string>(sensorGroupNameLookup);
        }
        public void AddSensorGroupNameLookup(string serial, string name)
        {
            _sensorGroupNameLookup[serial] = name;
        }
        public string SensorGroupNameLookup(string serial)
        {
            return _sensorGroupNameLookup[serial];
        }
        public Dictionary<string, string> SensorGroupNamesLookup()
        {
            return _sensorGroupNameLookup;
        }
        public void AssignSensorGroupTypeLookup(Dictionary<string, string> sensorGroupTypeLookup)
        {
            _sensorGroupTypeLookup = new Dictionary<string, string>(sensorGroupTypeLookup);
        }
        public void AddSensorGroupTypeLookup(string serial, string name)
        {
            _sensorGroupTypeLookup[serial] = name;
        }
        public string SensorGroupTypeLookup(string serial)
        {
            return _sensorGroupTypeLookup[serial];
        }
        public Dictionary<string, string> SensorGroupTypesLookup()
        {
            return _sensorGroupTypeLookup;
        }


        public void AssignGroupNameTestObjectLookup(Dictionary<string, string> groupNameTestObjectLookup)
        {
            _groupNameTestObjectLookup = new Dictionary<string, string>(groupNameTestObjectLookup);
        }
        public void AddGroupNameTestObjectLookup(string serial, string name)
        {
            _groupNameTestObjectLookup[serial] = name;
        }
        public string GroupNameTestObjectLookup(string serial)
        {
            return _groupNameTestObjectLookup[serial];
        }
        public Dictionary<string, string> GroupNameTestObjectsLookup()
        {
            return _groupNameTestObjectLookup;
        }


        public void AssignGroupNameSensorsLookup(Dictionary<string, List<string>> groupNameSensorsLookup)
        {
            _groupNameSensorsLookup = new Dictionary<string, List<string>>(groupNameSensorsLookup);
        }
        public void AddGroupNameSensorsLookup(string name, List<string> sensors)
        {
            _groupNameSensorsLookup[name] = sensors;
        }
        public List<string> GroupNameSensorsLookup(string name)
        {
            return _groupNameSensorsLookup[name];
        }
        public Dictionary<string, List<string>> GroupNameSensorsListLookup()
        {
            return _groupNameSensorsLookup;
        }

        public void AddSensorChannelCodeLookup(string settingName, string serial)
        {
            _sensorChannelCodeLookup[settingName] = serial;
        }
        public string SensorChannelCodeLookup(string settingName)
        {
            return _sensorChannelCodeLookup[settingName];
        }

    }
}