using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using xCommons.Extensions;
using xHttpService.Constants;
using xHttpService.Extensions;
using xIdentityModels.Dtos;
using xIdentityModels.Models;
using xIdentityModels.Navigations;
using xIdentityService.Constants;
using xModels.Dtos;

namespace xIdentityService.Providers {
    public partial class XIdentityProvider {
        //
        #region User Actions ...
        /// <summary>
        /// Retrieve User Names based on UserIds
        /// </summary>
        /// <param name="tokens">Authentication Tokens</param>
        /// <param name="ids">a comma seperated list of UserIds</param>
        /// <returns>a collection of UserNames</returns>
        public async Task<IEnumerable<string>> GetUserNames (
            XTokenResponse tokens,
            string ids
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (tokens)
                .AddNotEmpty (ids, tokens.AccessToken)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient (tokens);
            var request = GetRestRequet (
                XApiAccountEndpoint.GetNames,
                @params : new Dictionary<string, string> { { XParam.XIds.GetStringValue (), ids } }
            );

            //
            var response = await RunRestRequest<IEnumerable<string>> (
                client,
                request,
                XHttpMethod.GET
            );
            return response;
        }

        /// <summary>
        /// get user ids and retrieve corresponding user names
        /// </summary>
        /// <param name="tokens">Authentication Tokens</param>
        /// <param name="model">an instance of <see>XUserNameIdRequest</see> which represent required UserIds collection</param>
        /// <returns>a collection of <see>XUserNameIdResponse</see> instance</returns>
        public async Task<IEnumerable<XUserNameIdResponse>> GetUserNameIds (
            XTokenResponse tokens,
            XUserNameIdRequest model
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (model, tokens)
                .AddNotZeroChilds (model.Ids)
                .AddNotEmpty (tokens.AccessToken)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient (tokens);
            var request = GetRestRequet (XApiAccountEndpoint.GetNameIds);
            request.AddJsonBody (model);

            //
            var response = await RunRestRequest<IEnumerable<XUserNameIdResponse>> (
                client,
                request,
                XHttpMethod.POST
            );
            return response;
        }
        #endregion

        //
        #region Profile Actions ...
        /// <summary>
        /// Get Profile Object of Specific User 
        /// </summary>
        /// <param name="tokens">Authentication Tokens</param>
        /// <param name="userSelectByParam">determine's which user profile must be retrieved</param>
        /// <returns>an instance of <see>XUserProfileDto</see></returns>
        public async Task<XUserProfileDto> GetUserProfile (
            XTokenResponse tokens,
            string userSelectByParam
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (tokens)
                .AddNotEmpty (userSelectByParam, tokens.AccessToken)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient (tokens);

            //
            var request = GetRestRequet (
                XApiAccountEndpoint.GetProfile,
                @params : new Dictionary<string, string> { { XParam.XUserSelectByParam.GetStringValue (), userSelectByParam } }
            );

            //
            var response = await RunRestRequest<XUserProfileDto> (
                client,
                request,
                XHttpMethod.GET
            );
            return response;
        }

        /// <summary>
        /// Retrieve Users Based On Query
        /// </summary>
        /// <param name="tokens">Authentication Tokens</param>
        /// <param name="query">how to filter results based on <see>XQuery</see> structure</param>
        /// <returns>an instance of <see>XQueryResult</see> of <see>XUserProfileDto</see></returns>
        public async Task<XQueryResult<XUserProfileDto>> QueryUsers (
            XTokenResponse tokens,
            XQuery query
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (tokens, query)
                .AddNotEmpty (tokens.AccessToken)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient (tokens);

            //
            var request = GetRestRequet (XApiAccountEndpoint.QueryProfiles);

            //
            // Attach XQuery to Request ...
            request = request.AttachXQuery (query);

            //
            var response = await RunRestRequest<XQueryResult<XUserProfileDto>> (
                client,
                request,
                XHttpMethod.GET
            );
            return response;
        }

        /// <summary>
        /// Retrieve Users Based On Query and Specified role
        /// </summary>
        /// <param name="tokens">Authentication Tokens</param>
        /// <param name="role">an string which represent user role</param>
        /// <param name="query">how to filter results based on <see>XQuery</see> structure</param>
        /// <param name="forceRole">if it's true the user must has exact role, otherwise top level users also listed</param>
        /// <returns>an instance of <see>XQueryResult</see> of <see>XUserProfileDto</see></returns>
        public async Task<XQueryResult<XUserProfileDto>> QueryInRoleUsers (
            XTokenResponse tokens,
            string role,
            XQuery query,
            bool forceRole = false
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (tokens, query)
                .AddNotEmpty (tokens.AccessToken, role)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient (tokens);

            //
            var request = GetRestRequet (
                XApiAccountEndpoint.QueryProfiles,
                headers : new Dictionary<string, string> { { XParam.XRole.GetStringValue (), role },
                    { XParam.XForceRole.GetStringValue (), forceRole.AsHttpParamString () }
                }
            );

            //
            // Attach XQuery to Request ...
            request = request.AttachXQuery (query);

            //
            var response = await RunRestRequest<XQueryResult<XUserProfileDto>> (
                client,
                request,
                XHttpMethod.GET
            );
            return response;
        }

        /// <summary>
        /// Query Specified User's Profile Images
        /// </summary>
        /// <param name="tokens">Authentication Tokens</param>
        /// <param name="userSelectByParam">determine's which user profile must be retrieved</param>
        /// <param name="query">how to filter results based on <see>XQuery</see> structure</param>
        /// <returns>an instance of <see>XQueryResult</see> of <see>XProfileImage</see></returns>
        public async Task<XQueryResult<XProfileImage>> QueryAvatars (
            XTokenResponse tokens,
            string userSelectByParam,
            XQuery query
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (tokens, query)
                .AddNotEmpty (tokens.AccessToken, userSelectByParam)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient (tokens);

            //
            var request = GetRestRequet (
                XApiAccountEndpoint.QueryAvatars,
                @params : new Dictionary<string, string> { { XParam.XUserSelectByParam.GetStringValue (), userSelectByParam }
                }
            );

            //
            // Attach XQuery to Request ...
            request = request.AttachXQuery (query);

            //
            var response = await RunRestRequest<XQueryResult<XProfileImage>> (
                client,
                request,
                XHttpMethod.GET
            );
            return response;
        }

        /// <summary>
        /// Update User Profile based on <see>XProfileUpdateRequest</see> (FirstName/LastName/DateOfBirth)
        /// </summary>
        /// <param name="tokens">Authentication Tokens</param>
        /// <param name="userSelectByParam">determine's which user profile must be retrieved</param>
        /// <param name="model">user update info, an instance of <see>XProfileUpdateRequest</see></param>
        /// <returns>an instance of <see>XUserProfileDto</see></returns>
        public async Task<XUserProfileDto> ProfileUpdateAsync (
            XTokenResponse tokens,
            string userSelectByParam,
            XProfileUpdateRequest model
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (tokens, model)
                .AddNotEmpty (tokens.AccessToken, userSelectByParam)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient (tokens);

            //
            var request = GetRestRequet (
                XApiAccountEndpoint.UpdateProfile,
                @params : new Dictionary<string, string> { { XParam.XUserSelectByParam.GetStringValue (), userSelectByParam }
                }
            );
            request.AddJsonBody (model);

            //
            var response = await RunRestRequest<XUserProfileDto> (
                client,
                request,
                XHttpMethod.POST
            );
            return response;
        }

        /// <summary>
        /// Update a User Profile based on <see>XProfileUpdateRequest</see> Full
        /// </summary>
        /// <param name="tokens">Authentication Tokens</param>
        /// <param name="userSelectByParam">determine's which user profile must be retrieved</param>
        /// <param name="model">user update info, an instance of <see>XProfileUpdateRequest</see></param>
        /// <returns>an instance of <see>XUserProfileDto</see></returns>
        public async Task<XUserProfileDto> FullProfileUpdateAsync (
            XTokenResponse tokens,
            string userSelectByParam,
            XProfileUpdateRequest model
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (tokens, model)
                .AddNotEmpty (tokens.AccessToken, userSelectByParam)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient (tokens);

            //
            var request = GetRestRequet (
                XApiAccountEndpoint.FullUpdateProfile,
                @params : new Dictionary<string, string> { { XParam.XUserSelectByParam.GetStringValue (), userSelectByParam }
                }
            );
            request.AddJsonBody (model);

            //
            var response = await RunRestRequest<XUserProfileDto> (
                client,
                request,
                XHttpMethod.POST
            );
            return response;
        }

        /// <summary>
        /// Add a New Profile Image
        /// </summary>
        /// <param name="tokens">Authentication Tokens</param>
        /// <param name="file">an specific File to upload, <see>IFormFile</see></param>
        /// <returns>an instance of <see>XUserProfileDto</see></returns>
        public async Task<XUserProfileDto> AddAvatar (
            XTokenResponse tokens,
            IFormFile file
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (tokens, file)
                .AddNotEmpty (tokens.AccessToken)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient (tokens);

            //
            var request = GetRestRequet (XApiAccountEndpoint.AddAvatar);
            request.AlwaysMultipartFormData = true;
            request.AddFileBytes (
                XParam.XFile.GetStringValue (),
                file.ToByteArray (),
                file.FileName,
                file.ContentType
            );

            //
            var response = await RunRestRequest<XUserProfileDto> (
                client,
                request,
                XHttpMethod.POST
            );
            return response;
        }

        /// <summary>
        /// Add a New Collection of Profile Images
        /// </summary>
        /// <param name="tokens">Authentication Tokens</param>
        /// <param name="files">a collection of Files to upload, <see>IFormFileCollection</see></param>
        /// <returns>an instance of <see>XUserProfileDto</see></returns>
        public async Task<XUserProfileDto> AddAvatars (
            XTokenResponse tokens,
            IFormFileCollection files
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (tokens)
                .AddNotZeroChilds (files)
                .AddNotEmpty (tokens.AccessToken)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient (tokens);

            //
            var request = GetRestRequet (XApiAccountEndpoint.AddAvatars);
            request.AlwaysMultipartFormData = true;

            //
            // Add Files ...
            foreach (var file in files) {
                //
                // Add Single file ...
                request.AddFileBytes (
                    XParam.XFiles.GetStringValue (),
                    file.ToByteArray (),
                    file.FileName,
                    file.ContentType
                );
            }

            //
            var response = await RunRestRequest<XUserProfileDto> (
                client,
                request,
                XHttpMethod.POST
            );
            return response;
        }

        /// <summary>
        /// set Specified Profile Image as Avatar
        /// </summary>
        /// <param name="tokens">Authentication Tokens</param>
        /// <param name="id">an integer which reperesent AvatarId to set as current Avatar</param>
        /// <returns>an instance of <see>XUserProfileDto</see></returns>
        public async Task<XUserProfileDto> SetAvatar (
            XTokenResponse tokens,
            int id
        ) {
            //
            // Validate Args ...
            id.ValidateIntId ();

            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (tokens)
                .AddNotEmpty (tokens.AccessToken)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient (tokens);

            //
            var request = GetRestRequet (
                XApiAccountEndpoint.SetAvatar,
                @params : new Dictionary<string, string> { { XParam.XId.GetStringValue (), id.ToString () }
                }
            );

            //
            var response = await RunRestRequest<XUserProfileDto> (
                client,
                request,
                XHttpMethod.POST
            );
            return response;
        }

        /// <summary>
        /// Remove Profile Images
        /// </summary>
        /// <param name="tokens">Authentication Tokens</param>
        /// <param name="avatarIds">a comma seperated list of avatarIds to remove</param>
        /// <returns>an instance of <see>XUserProfileDto</see></returns>
        public async Task<XUserProfileDto> RemoveAvatars (
            XTokenResponse tokens,
            string avatarIds
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (tokens)
                .AddNotEmpty (avatarIds, tokens.AccessToken)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient (tokens);

            //
            var request = GetRestRequet (
                XApiAccountEndpoint.RemoveAvatars,
                @params : new Dictionary<string, string> { { XParam.XIds.GetStringValue (), avatarIds }
                }
            );

            //
            var response = await RunRestRequest<XUserProfileDto> (
                client,
                request,
                XHttpMethod.DELETE
            );
            return response;
        }
        #endregion
    }
}