using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using xCommons.Extensions;
using xDataService.Extensions;
using xDataService.Models;
using xExceptions.Constants;
using xFileService.Interfaces;
using xFileService.Models.Dtos;
using xIdentityModels.Models;
using xModels.Dtos;
using XFileDto = xFileService.Models.Dtos.XFileDto;

namespace xFileService.Providers
{
    public abstract class XBaseFileProvider<TKey> : IXBaseFileProvider<TKey>
    {
        //
        #region Props ...
        /// <summary>
        /// Provider Identifier ...
        /// </summary>
        public string Provider { get; }

        /// <summary>
        /// Tag Provider for Maipulating Tags ...
        /// </summary>
        public IXFileProvider FileProvider { get; }
        #endregion

        //
        #region Constructor ...
        public XBaseFileProvider(
            string providedFor,
            IXFileProvider fileProvider
        )
        {
            //
            Provider = providedFor;
            FileProvider = fileProvider;
        }
        #endregion

        //
        #region Tools ...
        /// <summary>
        /// Stream Specified File ...
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<FileStreamResult> Stream(Guid id)
        {
            //
            // Check Validation and Owning ...
            var isValid = await IsOwned(id);
            if (!isValid)
            {
                XException.NotAllowed.Throw();
            }

            //
            var result = await FileProvider.Stream(id);
            return result;
        }

        /// <summary>
        /// Stream Specified File ...
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public async Task<FileStreamResult> Stream(string fileName)
        {
            //
            // Validate ...
            var isValid = !fileName.IsNullOrEmpty();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Retrieve Dto and also Checking Owned ...
            var dto = await GetDto(fileName);
            isValid = !dto.IsNullOrDefault();
            if (!isValid)
            {
                XException.NotAllowed.Throw();
            }

            //
            var result = await FileProvider.Stream(fileName);
            return result;
        }

        /// <summary>
        /// Download Specified File ...
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<PhysicalFileResult> Download(Guid id)
        {
            //
            // Validate ...
            var isValid = await IsOwned(id);
            if (!isValid)
            {
                XException.NotAllowed.Throw();
            }

            //
            var result = await FileProvider.Download(id);
            return result;
        }

        /// <summary>
        /// Download Specified File ...
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public async Task<PhysicalFileResult> Download(string fileName)
        {
            //
            // Validate ...
            var isValid = !fileName.IsNullOrEmpty();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Retrieve Dto and also Checking Owned ...
            var dto = await GetDto(fileName);
            isValid = !dto.IsNullOrDefault();
            if (!isValid)
            {
                XException.NotAllowed.Throw();
            }

            //
            var result = await FileProvider.Download(fileName);
            return result;
        }

        /// <summary>
        /// Upload Files ...
        /// </summary>
        /// <param name="providedForId"></param>
        /// <param name="files"></param>
        /// <param name="connectionId"></param>
        /// <param name="userInfo"></param>
        /// <returns></returns>
        public async Task<IEnumerable<XFileDto>> Upload(
            TKey providedForId,
            IFormFileCollection files,
            string connectionId = null,
            XUserClaimsInfoDto userInfo = null
        )
        {
            //
            // Validate ...
            var isValid = !providedForId.IsNull();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Here we are Following Custom Senario ...
            var dtos = await FileProvider.Upload(
                files: files,
                userInfo: userInfo,
                connectionId: connectionId
            );

            //
            // Validate Dtos ...
            isValid = !dtos.IsNull() && dtos.HasChild();
            if (isValid)
            {
                //
                var isReferenced = false;
                foreach (var dto in dtos)
                {
                    //
                    // Try to Add Reference to Specified DTO ...
                    isReferenced = await AddReference(
                        model: dto,
                        userInfo: userInfo,
                        connectionId: connectionId,
                        providedForId: providedForId
                    );
                }
            }

            //
            var result = new List<XFileDto>();

            //
            isValid = !dtos.IsNull() && dtos.HasChild();
            if (isValid)
            {
                //
                foreach (var dto in dtos)
                {
                    //
                    var idto = await FileProvider.Get(dto.Id);
                    isValid = !idto.IsNullOrDefault() &&
                        await IsOwned(idto.Id);
                    if (isValid)
                    {
                        result.Add(idto);
                    }
                }
            }

            //
            return result;
        }

        /// <summary>
        /// Retrieve Specified File Streaming Info ...
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<XFileStreamDescriptorDto> GetFileDescriptor(Guid id)
        {
            //
            // Validate ...
            var isValid = !id.IsNull() && !id.IsDefaultGuid();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Check Owned ...
            isValid = await IsOwned(id);
            if (!isValid)
            {
                XException.NotAllowed.Throw();
            }

            //
            var result = await FileProvider.GetFileDescriptor(id);
            return result;
        }

        /// <summary>
        /// Retrieve Specified File Streaming Info ...
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public async Task<XFileStreamDescriptorDto> GetFileDescriptor(string fileName)
        {
            //
            // Validate ...
            var isValid = !fileName.IsNullOrEmpty();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Check Owned ...
            var dto = GetDto(fileName);
            isValid = !dto.IsNullOrDefault();
            if (!isValid)
            {
                XException.NotAllowed.Throw();
            }

            //
            var result = await FileProvider.GetFileDescriptor(fileName);
            return result;
        }
        #endregion

        //
        #region Referenced Actions ...
        /// <summary>
        /// Get Specified Indexed Reference for Specific Provided ID ...
        /// </summary>
        /// <param name="providedForId"></param>
        /// <param name="forIndex"></param>
        /// <returns></returns>
        public async Task<XFileDto> GetReference(
            TKey providedForId,
            int forIndex = 0
        )
        {
            //
            // Validate ...
            if (providedForId.IsNull())
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Normalize ...
            if (forIndex < 0)
            {
                forIndex = 0;
            }

            //
            // Retrieve Last Index ...
            var maxIndex = (await GetReferencingIndexes(providedForId)).Max();
            if (forIndex > maxIndex)
            {
                XException.NotFound.Throw();
            }

            //
            var indexedIdentifier = GetIndexedProvidedID(
                forIndex: forIndex,
                providedForId: providedForId
            );
            var entity = FileProvider.FileRepository
                .AsQueryable()
                .Where(t => t.References.Contains(indexedIdentifier))
                .FirstOrDefault();
            if (entity.IsNullOrDefault())
            {
                XException.NotFound.Throw();
            }

            //
            var result = await FileProvider.ToDto(entity);
            return result;
        }

        /// <summary>
        /// Retrieve all Exists References of Specific Provided ID ...
        /// </summary>
        /// <param name="providedForId"></param>
        /// <returns></returns>
        public async Task<IEnumerable<XFileDto>> GetAllReferences(TKey providedForId)
        {
            //
            // Validate ...
            if (providedForId.IsNull())
            {
                XException.InvalidArgs.Throw();
            }

            //
            var identifier = GetProvidedID(providedForId);
            var entities = FileProvider.FileRepository
                .AsQueryable()
                .Where(t => t.References.Contains(identifier))
                .AsEnumerable();

            //
            var result = new List<XFileDto>();
            foreach (var entity in entities)
            {
                //
                var dto = await FileProvider.ToDto(entity);
                if (!dto.IsNullOrDefault())
                {
                    result.Add(dto);
                }
            }

            //
            return await Task.FromResult(result);
        }

        /// <summary>
        /// Extract all Referencing Models for Specified Key ...
        /// </summary>
        /// <param name="providedForId"></param>
        /// <returns></returns> 
        public async Task<IEnumerable<XReference<TKey>>> GetAllReferencings(TKey providedForId)
        {
            //
            // Validate ...
            var isValid =
                !providedForId.IsNull();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            var identifier = GetProvidedID(providedForId);

            //
            var result = FileProvider.FileRepository
                .AsQueryable()
                .Where(te => te.References.Contains(identifier))
                .Select(te => te.References)
                .ToList()
                .SelectMany(tr => tr.ParseXReferenceList<TKey>())
                .Where(tr => tr.ProvidedFor == Provider && $"{tr.ReferencedTo}" == $"{providedForId}")
                .OrderBy(tr => tr.Index)
                .AsEnumerable()
                ;

            //
            return await Task.FromResult(result);
        }

        /// <summary>
        /// Count References ...
        /// </summary>
        /// <param name="providedForId"></param>
        /// <returns></returns>
        public async Task<int> CountReferences(TKey providedForId)
        {
            //
            // Validate ...
            if (providedForId.IsNull())
            {
                XException.InvalidArgs.Throw();
            }

            //
            var identifier = GetProvidedID(providedForId);
            var result = FileProvider.FileRepository
                .AsQueryable()
                .Where(t => t.References.Contains(identifier))
                .Count();

            //
            return await Task.FromResult(result);
        }

        /// <summary>
        /// Retrieve References of Specific Provided ID as Query ...
        /// </summary>
        /// <param name="providedForId"></param>
        /// <returns></returns>
        public async Task<XQueryResult<XFileDto>> QueryReferences(
            XQuery query,
            TKey providedForId
        )
        {
            //
            // Validate ...
            if (query.IsNull() || providedForId.IsNull())
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Normalize ...
            query = query.NormalizeQuery(FileProvider.DataSercviceConfiguration);

            //
            var items = await GetAllReferences(providedForId);
            var totalItemsCount = items.Count();

            //
            // Apply Filter ...
            if (!query.Filter.IsNullOrEmpty())
            {
                //
                items = items
                    .ApplyFilter(query.Filter);
            }
            int filteredItemsCount = items.Count();

            //
            // Count Pages ...
            var totalPagesCount = query.CountPages(totalItemsCount);
            var filteredPagesCount = query.CountPages(filteredItemsCount);

            //
            // Apply Paging and Sorting ...
            if (totalItemsCount > 0 &&
                filteredItemsCount > 0)
            {
                //
                // Apply Sorting ...
                items = items
                    .ToList()
                    .ApplySorting(
                        query.SortBy,
                        query.IsAscending
                    );

                //
                // Apply Paging ...
                items = items
                    .ToList()
                    .ApplyPaging(
                        query.Page,
                        query.PageSize
                    );
            }

            //
            // Prepare Result ...
            var result = new XQueryResult<XFileDto>
            {
                Page = query.Page,
                Items = items.ToList(),
                PageSize = query.PageSize,
                TotalPages = totalPagesCount,
                TotalItems = totalItemsCount,
                TotalFilteredPages = filteredPagesCount,
                TotalFilteredItems = filteredItemsCount
            };

            //
            return result;
        }

        /// <summary>
        /// Add Reference a Model to Specific Provided ID ...
        /// </summary>
        /// <param name="model"></param>
        /// <param name="providedForId"></param>
        /// <param name="forIndex"></param>
        /// <param name="connectionId"></param>
        /// <param name="userInfo"></param>
        /// <returns></returns>
        public async Task<bool> AddReference(
            XFileDto model,
            TKey providedForId,
            string connectionId = null,
            XUserClaimsInfoDto userInfo = null
        )
        {
            //
            var result = false;

            //
            // Validate ...
            result = 
                !model.Id.IsNull() &&
                !providedForId.IsNull() &&
                !model.IsNullOrDefault() &&
                !model.Id.IsDefaultGuid() &&
                !model.Name.IsNullOrEmpty();
            if (!result)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Check Model Exists ...
            result = await FileProvider.IsExists(model.Id);
            if (!result)
            {
                XException.NotFound.Throw();
            }

            //
            // Update Model by Retrieving ...
            model = await FileProvider.Get(model.Id);

            //
            // Retrieve all References ...
            var references = await GetAllReferences(providedForId);

            //
            // Check isReferenced or not ...
            result = references.Any(r => r.Id == model.Id &&
                r.References.Any(rf => rf.ProvidedFor == Provider &&
                    rf.ReferencedTo == $"{providedForId}"));
            if (result)
            {
                return result;
            }

            //
            int forIndex = await CountReferences(providedForId);
            model.References.Add(new XReference<string>
            {
                Index = forIndex,
                ProvidedFor = Provider,
                ReferencedTo = $"{providedForId}"
            });

            //
            // Update Data Base ...
            model = await FileProvider
                .Update(
                    item: model,
                    id: model.Id,
                    userInfo: userInfo,
                    connectionId: connectionId
            );
            result = !model.IsNullOrDefault();

            //
            return result;
        }

        /// <summary>
        /// Add Reference a Model to Specific XRefence<TKey> ...
        /// </summary>
        /// <param name="model"></param>
        /// <param name="reference"></param>
        /// <param name="connectionId"></param>
        /// <param name="userInfo"></param>
        /// <returns></returns>
        public async Task<bool> AddReference(
            XFileDto model,
            XReference<TKey> reference,
            string connectionId = null,
            XUserClaimsInfoDto userInfo = null
        )
        {
            //
            // Validate ...
            // Since other Validations Handled in Calling, we Ignore them here ...
            var result = 
                !model.IsNullOrDefault() &&
                !model.Id.IsNull() &&
                !model.Id.IsDefaultGuid() && 
                !reference.IsNullOrDefault() &&
                !reference.ReferencedTo.IsNull() &&
                reference.ProvidedFor == Provider &&
                !reference.ProvidedFor.IsNullOrEmpty();                
            if (!result)
            {
                XException.InvalidArgs.Throw();
            }

            //
            result = await AddReference(
                model: model,
                userInfo: userInfo,
                connectionId: connectionId,
                providedForId: reference.ReferencedTo
            );

            //
            return result;
        }

        /// <summary>
        /// Remove Reference a Model for Specific Provided ID ...
        /// </summary>
        /// <param name="model"></param>
        /// <param name="providedForId"></param>
        /// <param name="forIndex">if null, removes all</param>
        /// <param name="connectionId"></param>
        /// <param name="userInfo"></param>
        /// <returns></returns>
        public async Task<bool> RemoveReference(
            XFileDto model,
            TKey providedForId,
            string connectionId = null,
            XUserClaimsInfoDto userInfo = null
        )
        {
            //
            // Validate ...
            var result =
                !model.Id.IsNull() &&
                !providedForId.IsNull() &&
                !model.IsNullOrDefault() &&
                !model.Id.IsDefaultGuid();
            if (!result)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Retrieve Model ...
            model = await FileProvider.Get(model.Id);
            if (model.IsNullOrDefault())
            {
                XException.NotFound.Throw();
            }

            //
            // Reading Referencing Indexes ...
            var indexes = await GetReferencingIndexes(providedForId);

            //
            // Check Model Reference to ID ...
            var referencesCount = await CountReferences(providedForId);
            result = referencesCount == 0;
            if (result)
            {
                //
                // There is not any Reference to Remove ...
                return result;
            }

            //
            // Check Model is Trully Referenced to ProvidedForId or not ...
            var reference = model.References
                .FirstOrDefault(r => r.ProvidedFor == Provider &&
                r.ReferencedTo == $"{providedForId}");
            result = !reference.IsNullOrDefault();
            if (!result)
            {
                XException.ActionFailed.Throw();
            }

            //
            // Remove Referenced Item from Model ...
            model.References = model.References
                .Where(r => !(r.ProvidedFor == Provider &&
                r.ReferencedTo == $"{providedForId}"))
                .ToList();

            //
            // Update DataBase ...
            model = await FileProvider.Update(
                id: model.Id,
                item: model,
                userInfo: userInfo,
                connectionId: connectionId
            );

            //
            result = !model.IsNullOrDefault();
            if (!result)
            {
                XException.ActionFailed.Throw();
            }

            //
            // Get Max Exists Indexes ...
            var maxIndex = indexes.Max();

            //
            // Here We Have to Re Arrange Indexed ...
            if (reference.Index < maxIndex)
            {
                //
                var startIndex = reference.Index + 1;
                for (int i = startIndex; i <= maxIndex; i++)
                {
                    //
                    var dto = await GetReference(
                        forIndex: i,
                        providedForId: providedForId
                    );
                    if (!dto.IsNullOrDefault())
                    {
                        //
                        dto.References
                        .ToList()
                        .ForEach(iref =>
                        {
                            //
                            if (
                                iref.Index == i &&
                                iref.ProvidedFor == Provider &&
                                iref.ReferencedTo == reference.ReferencedTo
                            )
                            {
                                iref.Index = i - 1;
                            }
                        });

                        //
                        dto = await FileProvider.Update(
                            item: dto,
                            id: dto.Id,
                            userInfo: userInfo,
                            connectionId: connectionId
                        );
                    }
                }
            }

            //
            return result;
        }

        /// <summary>
        /// Remove Reference a Model for Specific XRefence<TKey> ...
        /// </summary>
        /// <param name="model"></param>
        /// <param name="providedForId"></param>
        /// <param name="connectionId"></param>
        /// <param name="userInfo"></param>
        /// <returns></returns>
        public async Task<bool> RemoveReference(
            XFileDto model,
            XReference<TKey> reference,
            string connectionId = null,
            XUserClaimsInfoDto userInfo = null
        )
        {
            //
            if (model.IsNullOrDefault() ||
                reference.IsNullOrDefault() ||
                reference.ReferencedTo.IsNull() ||
                reference.ProvidedFor != Provider)
            {
                XException.InvalidArgs.Throw();
            }

            //
            var result = await RemoveReference(
                model: model,
                userInfo: userInfo,
                connectionId: connectionId,
                providedForId: reference.ReferencedTo
            );

            //
            return result;
        }

        /// <summary>
        /// Remove All References to Specified Key ...
        /// </summary>
        /// <param name="providedForId"></param>
        /// <param name="connectionId"></param>
        /// <param name="userInfo"></param>
        /// <returns></returns>
        public async Task<bool> RemoveReferences(
            TKey providedForId,
            string connectionId = null,
            XUserClaimsInfoDto userInfo = null
        )
        {
            //
            // Validate ...
            if (providedForId.IsNull())
            {
                XException.InvalidArgs.Throw();
            }

            //
            var result = false;
            var references = await GetAllReferences(providedForId);
            if (!references.IsNull() && references.HasChild())
            {
                //
                foreach (var reference in references)
                {
                    //
                    // Remove Reference ...
                    reference.References = reference.References
                        .Where(r =>
                            r.ProvidedFor != Provider ||
                            (r.ProvidedFor == Provider &&
                                r.ReferencedTo != $"{providedForId}"))
                        .ToList();
                    var updatedModel = await FileProvider.Update(
                        item: reference,
                        id: reference.Id,
                        userInfo: userInfo,
                        connectionId: connectionId
                    );
                    if (!updatedModel.IsNullOrDefault())
                    {
                        result = true;
                    }
                }
            }

            //
            return result;
        }
        #endregion

        //
        #region Private ...
        private string GetProvidedID(
            TKey providedForId,
            char splitter = '_'
        )
        {
            //
            // Validate ...
            if (providedForId.IsNull())
            {
                XException.InvalidArgs.Throw();
            }

            //
            var result = $"{Provider}{splitter}{providedForId}";
            return result;
        }

        private string GetIndexedProvidedID(
            TKey providedForId,
            int forIndex,
            char splitter = '_'
        )
        {
            //
            var result = $"{GetProvidedID(providedForId, splitter)}{splitter}{forIndex}";

            //
            return result;
        }

        private async Task<IEnumerable<int>> GetReferencingIndexes(TKey providedForId)
        {
            //
            // Validate ...
            var isValid =
                !providedForId.IsNull();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            var result = new List<int>();
            var referencings = await GetAllReferencings(providedForId);
            isValid = !referencings.IsNull() &&
                referencings.HasChild();
            if (!isValid)
            {
                return result;
            }

            //
            result =
                referencings
                    .OrderBy(r => r.Index)
                    .Select(r => r.Index)
                    .ToList();

            //
            return result;
        }

        /// <summary>
        /// Check Specified Dto is Has Reference to Provider ...
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        private async Task<bool> IsOwned(Guid id)
        {
            //
            // Validate ...
            var result = !id.IsNull() && !id.IsDefaultGuid();
            if (!result)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Check Exists ...
            result = await FileProvider.IsExists(id);
            if (!result)
            {
                XException.NotFound.Throw();
            }

            //
            // Retrieve Dto ...
            var dto = await FileProvider.Get(id);
            result = !dto.IsNullOrDefault();
            if (!result)
            {
                XException.ActionFailed.Throw();
            }

            //
            result = !dto.References.IsNull() &&
                dto.References.HasChild() &&
                dto.References.Any(r => r.ProvidedFor == Provider);

            //
            return result;
        }

        /// <summary>
        /// Get Specified Owned Dto by File Name ...
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        private async Task<XFileDto> GetDto(string fileName)
        {
            //
            XFileDto result = null;

            //
            if (!fileName.IsNullOrEmpty())
            {
                //
                try
                {
                    //
                    result = await FileProvider.FindOne(d =>
                        d.Name == fileName ||
                        d.Thumb == fileName ||
                        d.FileName == fileName ||
                        d.Path.Contains(fileName) ||
                        d.ThumbPath.Contains(fileName)
                    );
                    if (!result.IsNullOrDefault())
                    {
                        //
                        // Check Owning ...
                        var isOwned = await IsOwned(result.Id);
                        if (!isOwned)
                        {
                            result = null;
                        }
                    }
                }
                catch { }
            }

            //
            return result;
        }
        #endregion
    }
}