private void PrepareProfileModel(ImportProfileModel model, ImportProfile profile, bool forEdit, ColumnMap invalidMap = null)
        {
            if (profile == null)
            {
                if (model.Name.IsEmpty())
                {
                    var defaultNames = T("Admin.DataExchange.Import.DefaultProfileNames").Text.SplitSafe(";");

                    model.Name = defaultNames.SafeGet((int)model.EntityType);
                }

                model.ExistingFileNames = new List <string>();
                return;
            }

            model.Id                = profile.Id;
            model.Name              = profile.Name;
            model.EntityType        = profile.EntityType;
            model.Enabled           = profile.Enabled;
            model.Skip              = profile.Skip;
            model.Take              = profile.Take;
            model.UpdateOnly        = profile.UpdateOnly;
            model.KeyFieldNames     = profile.KeyFieldNames.SplitSafe(",").Distinct().ToArray();
            model.ScheduleTaskId    = profile.SchedulingTaskId;
            model.ScheduleTaskName  = profile.ScheduleTask.Name.NaIfEmpty();
            model.IsTaskRunning     = profile.ScheduleTask.IsRunning;
            model.IsTaskEnabled     = profile.ScheduleTask.Enabled;
            model.LogFileExists     = System.IO.File.Exists(profile.GetImportLogPath());
            model.EntityTypeName    = profile.EntityType.GetLocalizedEnum(_services.Localization, _services.WorkContext);
            model.UnspecifiedString = T("Common.Unspecified");
            model.AddNewString      = T("Common.AddNew");
            model.DeleteString      = T("Common.Delete");
            model.IgnoreString      = T("Admin.Common.Ignore");

            model.ExistingFileNames = profile.GetImportFiles()
                                      .Select(x => Path.GetFileName(x))
                                      .ToList();

            if (profile.ResultInfo.HasValue())
            {
                model.ImportResult = XmlHelper.Deserialize <SerializableImportResult>(profile.ResultInfo);
            }

            if (!forEdit)
            {
                return;
            }

            CsvConfiguration csvConfiguration = null;

            if (profile.FileType == ImportFileType.CSV)
            {
                var csvConverter = new CsvConfigurationConverter();
                csvConfiguration = csvConverter.ConvertFrom <CsvConfiguration>(profile.FileTypeConfiguration) ?? CsvConfiguration.ExcelFriendlyConfiguration;

                model.CsvConfiguration = new CsvConfigurationModel(csvConfiguration);
            }
            else
            {
                csvConfiguration = CsvConfiguration.ExcelFriendlyConfiguration;
            }

            // column mapping
            model.AvailableSourceColumns    = new List <ColumnMappingItemModel>();
            model.AvailableEntityProperties = new List <SelectListItem>();
            model.AvailableKeyFieldNames    = new List <SelectListItem>();
            model.ColumnMappings            = new List <ColumnMappingItemModel>();

            try
            {
                string[] availableKeyFieldNames = null;
                var      mapConverter           = new ColumnMapConverter();
                var      storedMap         = mapConverter.ConvertFrom <ColumnMap>(profile.ColumnMapping);
                var      hasStoredMappings = (storedMap != null && storedMap.Mappings.Any());
                var      map = (invalidMap ?? storedMap) ?? new ColumnMap();

                // property name to localized property name
                var allProperties = _importService.GetImportableEntityProperties(profile.EntityType);

                switch (profile.EntityType)
                {
                case ImportEntityType.Product:
                    availableKeyFieldNames = ProductImporter.SupportedKeyFields;
                    break;

                case ImportEntityType.Category:
                    availableKeyFieldNames = CategoryImporter.SupportedKeyFields;
                    break;

                case ImportEntityType.Customer:
                    availableKeyFieldNames = CustomerImporter.SupportedKeyFields;
                    break;

                case ImportEntityType.NewsLetterSubscription:
                    availableKeyFieldNames = NewsLetterSubscriptionImporter.SupportedKeyFields;
                    break;
                }

                model.AvailableEntityProperties = allProperties
                                                  .Select(x => new SelectListItem {
                    Value = x.Key, Text = x.Value
                })
                                                  .OrderBy(x => x.Text)
                                                  .ToList();

                model.AvailableKeyFieldNames = availableKeyFieldNames
                                               .Select(x =>
                {
                    var item = new SelectListItem {
                        Value = x, Text = x
                    };

                    if (x == "Id")
                    {
                        item.Text = T("Admin.Common.Entity.Fields.Id");
                    }
                    else if (allProperties.ContainsKey(x))
                    {
                        item.Text = allProperties[x];
                    }

                    return(item);
                })
                                               .ToList();

                model.ColumnMappings = map.Mappings
                                       .Select(x =>
                {
                    var mapping = new ColumnMappingItemModel
                    {
                        Column   = (x.Value.Property.IsEmpty() ? null : x.Key),
                        Property = (x.Value.Property.IsEmpty() ? x.Key : x.Value.Property),
                        Default  = x.Value.Default
                    };

                    // add localized to make mappings sortable
                    if (allProperties.ContainsKey(mapping.Property))
                    {
                        mapping.ColumnLocalized = allProperties[mapping.Property];
                    }

                    return(mapping);
                })
                                       .ToList();

                var files = profile.GetImportFiles();
                if (!files.Any())
                {
                    return;
                }

                var filePath = files.First();

                using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    var dataTable = LightweightDataTable.FromFile(Path.GetFileName(filePath), stream, stream.Length, csvConfiguration, 0, 1);

                    foreach (var column in dataTable.Columns.Where(x => x.Name.HasValue()))
                    {
                        string columnWithoutIndex, columnIndex;
                        ColumnMap.ParseSourceColumn(column.Name, out columnWithoutIndex, out columnIndex);

                        var mapModel = new ColumnMappingItemModel
                        {
                            Index              = dataTable.Columns.IndexOf(column),
                            Column             = column.Name,
                            ColumnWithoutIndex = columnWithoutIndex,
                            ColumnIndex        = columnIndex,
                            ColumnLocalized    = (allProperties.ContainsKey(column.Name) ? allProperties[column.Name] : column.Name)
                        };

                        model.AvailableSourceColumns.Add(mapModel);

                        // auto map where field equals property name
                        if (!hasStoredMappings && !model.ColumnMappings.Any(x => x.Column == column.Name))
                        {
                            var kvp = allProperties.FirstOrDefault(x => x.Key.IsCaseInsensitiveEqual(column.Name));

                            if (kvp.Key.HasValue())
                            {
                                model.ColumnMappings.Add(new ColumnMappingItemModel
                                {
                                    Column          = column.Name,
                                    Property        = kvp.Key,
                                    ColumnLocalized = kvp.Value
                                });
                            }
                            else
                            {
                                var alternativeName = LightweightDataTable.GetAlternativeColumnNameFor(column.Name);
                                kvp = allProperties.FirstOrDefault(x => x.Key.IsCaseInsensitiveEqual(alternativeName));

                                if (kvp.Key.HasValue())
                                {
                                    model.ColumnMappings.Add(new ColumnMappingItemModel
                                    {
                                        Column          = column.Name,
                                        Property        = kvp.Key,
                                        ColumnLocalized = kvp.Value
                                    });
                                }
                            }
                        }
                    }

                    // sorting
                    model.AvailableSourceColumns = model.AvailableSourceColumns
                                                   .OrderBy(x => x.ColumnLocalized)
                                                   .ToList();

                    model.ColumnMappings = model.ColumnMappings
                                           .OrderBy(x => x.ColumnLocalized)
                                           .ToList();
                }
            }
            catch (Exception exception)
            {
                NotifyError(exception, true, false);
            }
        }