using Microsoft.Rest;
using Orchestrator.Exporter.Models;
using Orchestrator.Web.Client;
using Orchestrator.Web.Client.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Orchestrator.Exporter
{
    public partial class OrchestratorImporter
    {
        private readonly List<string> _folderPostPermissions = new List<string>
        {
            PermissionsConstants.FoldersView,
            PermissionsConstants.FoldersCreate,
            PermissionsConstants.FoldersEdit
        };

        private async Task PostFoldersWithPermissionsAsync(System.Threading.CancellationToken ct)
        {
            await ExecuteWithPermissionsAsync(
                () => PostFoldersAsync(ct), _folderPostPermissions);
        }

        private async Task PostFoldersAsync(System.Threading.CancellationToken ct)
        {
            if (Model.Units == null)
            {
                return;
            }

            var foldersImport = GetListOfFoldersFromModel();

            var folderLevels = GroupByLevels(foldersImport);

            var foldersDtoLevels = MapListOfListsOfExtendedFolders(folderLevels);

            var folderDtoNames = foldersImport.ToDictionary(f => f.Id.Value, f => f.DisplayName);

            for(int level = 0; level < foldersDtoLevels.Count(); ++level)
            {
                var folderLevel = foldersDtoLevels[level];

                if(level != 0)
                {
                    var parents = foldersDtoLevels[level - 1];

                    UpdateParentsIds(folderDtoNames, folderLevel, parents);
                }

                await PostFoldersLevelAsync(folderLevel, ct);

                var extendedFoldersExport = await GetFoldersWithPermissionsAsync(ImportPageSize, ct);

                var newFolders = extendedFoldersExport.Select(folder => MapExtendedFolder(folder)).ToList();

                UpdateFoldersIds(folderLevel, newFolders);
            }

            var foldersExport = foldersDtoLevels.SelectMany(folder => folder).ToList();

            UpdateFoldersIds(foldersImport, foldersExport);

            await AssignUserToFolders(foldersImport, ct);
        }

        private FolderDto MapExtendedFolder(ExtendedFolderDto folder)
        {
            return new FolderDto
            {
                Id = folder.Id,
                DisplayName = folder.DisplayName,
                Description = folder.Description,
                FullyQualifiedName = folder.FullyQualifiedName,
                ParentId = folder.ParentId,
                PermissionModel = (FolderDtoPermissionModel?)folder.PermissionModel,
                ProvisionType = (FolderDtoProvisionType?)folder.ProvisionType,
            };
        }

        private List<List<FolderDto>> MapListOfListsOfExtendedFolders(List<List<ExtendedFolderDto>> extendedFolderDtos)
        {
            return extendedFolderDtos.Select(folderLevel => folderLevel.Select(folder => MapExtendedFolder(folder)).ToList())
                .ToList();
        }

        private List<ExtendedFolderDto> GetListOfFoldersFromModel()
        {
            return Model.Units.Where(folder => folder is FolderModel)
                .Select(folder => ((FolderModel)folder).Entity)
                .ToList();
        }

        private List<List<ExtendedFolderDto>> GroupByLevels(List<ExtendedFolderDto> folders)
        {
            return folders
                .GroupBy(folder => folder.Level.Value)
                .Select(folderGroup => folderGroup.ToList())
                .ToList();

        }

        private void UpdateParentsIds(Dictionary<long, string> folderDtoNames, List<FolderDto> folders, List<FolderDto> parents)
        {
            var parentNewIds = parents.ToDictionary(f => f.DisplayName, f => f.Id.Value);

            foreach (var folder in folders)
            {
                long? id = folder.ParentId;

                if (id != null)
                {
                    var parentName = folderDtoNames[id.Value];
                    var parentNewId = parentNewIds[parentName];
                    folder.Id = parentNewId;
                }
            }
        }

        private async Task PostFoldersLevelAsync(List<FolderDto> folderLevel, System.Threading.CancellationToken ct)
        {
            await PostAllAsync(
                    (folder) => ExecuteRequestAsync(
                        () => Api.Folders.PostAsync(folder), ct),
                folderLevel, ImportPageSize);
        }

        private async Task AssignUserToFolders(List<ExtendedFolderDto> folders, System.Threading.CancellationToken ct)
        {
            var currentUser = await ExecuteRequestAsync(() => Api.Users.GetCurrentUserAsync(), ct);

            var folderRoles = folders.Select(folder => new FolderRolesDto(folder.Id)).ToList();

            var usersIds = new List<long?> { currentUser.Id, };

            await PostAllAsync((folderRole) => ExecuteRequestAsync(() =>
                Api.Folders.AssignUsersAsync(new AssignUsersActionParameters(
                    new UserAssignmentsDto(usersIds, new List<FolderRolesDto> { folderRole }))), ct), folderRoles, ImportPageSize);
        }

        private void UpdateFoldersIds(List<FolderDto> foldersImport, List<FolderDto> extendendFolders)
        {
            if(foldersImport == null || extendendFolders == null)
            {
                return;
            }

            var foldersIds = extendendFolders.ToDictionary(f => f.DisplayName, f => f.Id);

            foreach (var folder in foldersImport)
            {
                if (foldersIds.TryGetValue(folder.DisplayName, out var folderId))
                {
                    folder.Id = folderId;
                }
            }

        }

        private void UpdateFoldersIds(List<ExtendedFolderDto> foldersImport, List<FolderDto> extendendFolders)
        {
            if (foldersImport == null || extendendFolders == null)
            {
                return;
            }

            var foldersIds = extendendFolders.ToDictionary(f => f.DisplayName, f => f.Id);

            foreach (var folder in foldersImport)
            {
                if (foldersIds.TryGetValue(folder.DisplayName, out var folderId))
                {
                    folder.Id = folderId;
                }
            }

        }
    }
}