using DTS.Common.Import.Interfaces;
using DTS.Common.Import.Persist;
using DTS.Slice.Users;
using System;
using System.Collections.Generic;
using System.Linq;

namespace DTS.Common.Import.Factories
{
    public static class SaveVariantFactory
    {
        //FB 36854 Added cancel action
        public static List<IPersistImport> CreateVariants(ImportObject importObject, ImportNotification importNotification, User user, Func<bool> isCanceled, bool showCheckoutButton)
        {
            List<IPersistImport> saveHandlers = new List<IPersistImport>();

            IPersistCalculator persistCalculator = new PersistCalculator();

            if (importObject.CustomerDetails().Any())
            {
                persistCalculator.AddToTotal(importObject.CustomerDetails().Count());
                var saveCustomerDetails = new SaveCustomerDetails(importObject, persistCalculator, importNotification, isCanceled);
                saveHandlers.Add(saveCustomerDetails);
            }

            if (importObject.TestEngineerDetails().Any())
            {
                persistCalculator.AddToTotal(importObject.TestEngineerDetails().Count());
                var saveTestEngineerDetails = new SaveTestEngineerDetails(importObject, persistCalculator, importNotification, isCanceled);
                saveHandlers.Add(saveTestEngineerDetails);
            }

            if (importObject.LabDetails().Any())
            {
                persistCalculator.AddToTotal(importObject.LabDetails().Count());
                var saveLabDetails = new SaveLabDetails(importObject, persistCalculator, importNotification, isCanceled);
                saveHandlers.Add(saveLabDetails);
            }

            if (importObject.SensorModels().Any())
            {
                persistCalculator.AddToTotal(importObject.SensorModels().Count());
                var sensorModels = new SaveSensorModels(importObject, persistCalculator, importNotification, isCanceled);
                saveHandlers.Add(sensorModels);
            }

            if (importObject.Sensors().Any())
            {
                persistCalculator.AddToTotal(importObject.Sensors().Count());
                persistCalculator.AddToTotal(importObject.Calibrations().Count());

                if (importObject.SourceFormat == Enums.ImportFormats.DTS_CSV)
                {
                    var saveCsvSourceSensor = new SaveCsvSourceSensor(importObject, persistCalculator, importNotification, isCanceled);
                    saveCsvSourceSensor.CurrentUser = user;
                    saveHandlers.Add(saveCsvSourceSensor);
                }
                else
                {
                    var saveNonCsvSourceSensor = new SaveNonCsvSourceSensor(importObject, persistCalculator, importNotification, isCanceled);
                    saveNonCsvSourceSensor.CurrentUser = user;
                    saveHandlers.Add(saveNonCsvSourceSensor);
                }
            }

            if (importObject.Users().Any())
            {
                persistCalculator.AddToTotal(importObject.Users().Count());
                var saveUsers = new SaveUsers(importObject, persistCalculator, importNotification, isCanceled);
                saveHandlers.Add(saveUsers);
            }

            if (importObject.GlobalSettings().Any())
            {
                persistCalculator.AddToTotal(importObject.GlobalSettings().Count);
                var saveGlobalSettings = new SaveGlobalSettings(importObject, persistCalculator, importNotification, isCanceled);
                saveHandlers.Add(saveGlobalSettings);
            }

            SaveCustomChannels saveCustomChannels = new SaveCustomChannels(importObject, persistCalculator, importNotification, isCanceled);


            var saveHardware = new SaveHardware(importObject, persistCalculator, importNotification, isCanceled);

            if (importObject.Hardware().Any())
            {
                persistCalculator.AddToTotal(importObject.Hardware().Count());
                persistCalculator.AddToTotal(importObject.Hardware().Sum(h => h?.Channels.Length ?? 0));

                saveHandlers.Add(saveHardware);
            }

            if (importObject.GroupTemplates().Any())
            {
                persistCalculator.AddToTotal(importObject.GroupTemplates().Count());
                SaveGroupTemplates saveGroupTemplates = new SaveGroupTemplates(importObject, persistCalculator, importNotification, isCanceled);
                saveHandlers.Add(saveGroupTemplates);
            }

            SaveGroups saveGroups = new SaveGroups(importObject, persistCalculator, importNotification, saveHardware, isCanceled);

            if (importObject.Groups().Any() || importObject.StaticGroups().Any())
            {
                persistCalculator.AddToTotal(importObject.Groups().Count());
                persistCalculator.AddToTotal(importObject.StaticGroups().Count());

                saveHandlers.Add(saveGroups);
            }

            if (importObject.TestSetups().Any())
            {
                persistCalculator.AddToTotal(importObject.TestSetups().Count());
                SaveTestSetup saveTestSetup = new SaveTestSetup(importObject, persistCalculator, importNotification, saveCustomChannels, saveHardware, saveGroups, isCanceled);
                if (showCheckoutButton)
                {
                    //FB 38039 For now the checkout setting specifies if we are in GM parse mode.
                    //We concat Run Test at the end of file too
                    //We might use manufacturer to set this name later
                    saveTestSetup.TestSetupName = string.Concat(importObject.TestSetups()?.FirstOrDefault()?.Name, Serialization.RDF.File.SUFFIX_RUNTEST);
                }
                saveTestSetup.CurrentUser = user;
                saveHandlers.Add(saveTestSetup);
                if (showCheckoutButton)
                {
                    //FB 38039 create checkout test setup
                    SaveCheckoutTestSetup saveTestSetupCheckout = new SaveCheckoutTestSetup(importObject, persistCalculator, importNotification,
                        saveCustomChannels, saveHardware, saveGroups, isCanceled, string.Concat(importObject.TestSetups()?.FirstOrDefault()?.Name, Serialization.RDF.File.SUFFIX_CHECKOUT));
                    saveTestSetupCheckout.CurrentUser = user;
                    saveHandlers.Add(saveTestSetupCheckout);
                }
            }

            return saveHandlers;
        }
    }
}