using System.Collections.Generic;
using System.Threading.Tasks;
using IdentityModel.Client;
using Microsoft.AspNetCore.Http;
using RestSharp;
using xHttpService.Constants;
using xIdentityModels.Constants;
using xIdentityModels.Dtos;
using xIdentityModels.Models;
using xIdentityModels.Navigations;
using xModels.Dtos;

namespace xIdentityService.Interfaces
{
    public partial interface IXIdentityProvider
    {
        //
        string BaseUrl { get; }
        string RevisionSecretKey { get; }
        IXSecurityProvider SecurityProvider { get; }

        //
        #region Tools ...
        string GetUserSelectByParam(
            XActionRequest model,
            bool forceNotNull = true,
            ICollection<XUserSelectBy> excludes = null
        );
        #endregion

        //
        #region Tools ...
        Task<T> RunRestRequest<T>(
            RestClient client,
            RestRequest request,
            XHttpMethod method,
            bool supportRefreshingTokens = false
        );
        #endregion

        //
        #region Authentication ...
        Task<DiscoveryDocumentResponse> RequestDiscoveryDocument();
        Task<XTokenResponse> RequestScopeAccessToken(string scope);
        Task<TokenIntrospectionResponse> Introspection(XTokenResponse model);
        Task<XLoginResponse> Login(XLoginRequest model);
        Task Logout(XTokenResponse model);
        Task<XTokenResponse> Authenticate(XLoginRequest model);
        Task<XTokenResponse> RefreshTokens(XTokenResponse model);

        Task ChangePassword(
            XTokenResponse tokens,
            XActionRequest model
        );
        #endregion

        //
        #region Profile ...
        Task<IEnumerable<string>> GetUserNames(
            XTokenResponse tokens,
            string userIds
        );

        Task<IEnumerable<XUserNameIdResponse>> GetUserNameIds(
            XTokenResponse tokens,
            XUserNameIdRequest model
        );

        Task<XUserProfileDto> GetUserProfile(
            XTokenResponse tokens,
            string userSelectByParam
        );

        Task<XQueryResult<XUserProfileDto>> QueryUsers(
            XTokenResponse tokens,
            XQuery query
        );

        Task<XQueryResult<XUserProfileDto>> QueryInRoleUsers(
            XTokenResponse tokens,
            string role,
            XQuery query,
            bool forceRole = false
        );

        Task<XQueryResult<XProfileImage>> QueryAvatars(
            XTokenResponse tokens,
            string userSelectByParam,
            XQuery query
        );

        Task<XUserProfileDto> ProfileUpdateAsync(
            XTokenResponse tokens,
            string userSelectByParam,
            XProfileUpdateRequest model
        );

        Task<XUserProfileDto> FullProfileUpdateAsync(
            XTokenResponse tokens,
            string userSelectByParam,
            XProfileUpdateRequest request
        );

        Task<XUserProfileDto> AddAvatar(
            XTokenResponse tokens,
            IFormFile file
        );

        Task<XUserProfileDto> AddAvatars(
            XTokenResponse tokens,
            IFormFileCollection files
        );

        Task<XUserProfileDto> SetAvatar(
            XTokenResponse tokens,
            int avatarId
        );

        Task<XUserProfileDto> RemoveAvatars(
            XTokenResponse tokens,
            string avatarIds
        );
        #endregion

        //
        #region Search ...
        /// <summary>
        /// Query Open To Search User Profiles ...
        /// </summary>
        /// <param name="tokens">requested user's identifiers</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>
        Task<XQueryResult<XUserProfileDto>> QueryOpenToSearchUsers(
            XTokenResponse tokens,
            XQuery query
        );
        #endregion

        //
        #region Registration ...
        Task<bool> CanRegister(string userSelectByParam);

        Task<XActionResponse> InviteUser(
            XTokenResponse tokens,
            XActionRequest model
        );

        Task<XActionResponse> RequestRegistration(
            XActionRequest model
        );

        Task<XActionResponse> AddAccountInfo(
            XActionRequest model
        );

        Task<XActionResponse> AttachProfileImage(
            string actionToken,
            IFormFile file
        );

        Task FinishRegistration(XActionRequest model);

        Task<bool> IsConfirmedEmail(
            XTokenResponse tokens,
            string userSelectByParam
        );

        Task<bool> IsConfirmedMobile(
            XTokenResponse tokens,
            string userSelectByParam
        );

        Task RequestConfirmRegistration(XActionRequest model);

        Task ConfirmRegistration(
            XActionRequest model
        );

        Task<XActionResponse> RequestConfirmMobile(XActionRequest model);

        Task<XActionResponse> ConfirmMobileNumber(XActionRequest model);

        Task<XActionResponse> RequestConfirmEmail(XActionRequest model);

        Task<XActionResponse> ConfirmEmailAddress(XActionRequest model);

        Task<XActionResponse> RequestResetPassword(XActionRequest model);

        Task ResetPassword(XActionRequest model);
        #endregion

        //
        #region Friendship ...
        Task<XFriendshipFollowing> Follow(
            XTokenResponse tokens,
            string destUser
        );

        Task<bool> Cancel(
            XTokenResponse tokens,
            string destUser
        );

        Task UnFollowFollower(
            XTokenResponse tokens,
            string destUser
        );

        Task UnFollowFollowing(
            XTokenResponse tokens,
            string destUser
        );

        Task<XFriendshipFollowing> Block(
            XTokenResponse tokens,
            string destUser
        );

        Task<XFriendshipFollowing> UnBlock(
            XTokenResponse tokens,
            string destUser
        );

        Task<XFriendshipFollower> AcceptRequest(
            XTokenResponse tokens,
            string destUser
        );

        Task<XFriendshipFollower> RejectRequest(
            XTokenResponse tokens,
            string destUser
        );

        Task<XFriendshipInfoDto> GetFriendshipInfo(
            XTokenResponse tokens,
            string destUser
        );

        Task<bool> IsFollower(
            XTokenResponse tokens,
            string destUser
        );

        Task<XFriendshipFollower> GetFollower(
            XTokenResponse tokens,
            string destUser
        );

        Task<XFriendshipState> GetFollowerState(
            XTokenResponse tokens,
            string destUser
        );

        Task<IEnumerable<XFriendshipFollower>> GetFollowers(XTokenResponse tokens);

        Task<IEnumerable<XFriendshipFollower>> GetAllFollowers(XTokenResponse tokens);

        Task<IEnumerable<string>> GetFollowingList(XTokenResponse tokens);

        Task<XQueryResult<XFriendDto>> QueryFollowers(
            XQuery query,
            string destUser,
            XTokenResponse tokens
        );

        Task<bool> IsFollowing(
            XTokenResponse tokens,
            string destUser
        );

        Task<XFriendshipFollowing> GetFollowing(
            XTokenResponse tokens,
            string destUser
        );

        Task<XFriendshipState> GetFollowingState(
            XTokenResponse tokens,
            string destUser
        );

        Task<IEnumerable<XFriendshipFollowing>> GetFollowings(XTokenResponse tokens);

        Task<IEnumerable<XFriendshipFollowing>> GetAllFollowings(XTokenResponse tokens);

        Task<IEnumerable<string>> GetFollowersList(XTokenResponse tokens);

        Task<XQueryResult<XFriendDto>> QueryFollowings(
            XQuery query,
            string destUser,
            XTokenResponse tokens
        );
        #endregion

        //
        #region Admin ...
        Task<IEnumerable<string>> Ban(
            XTokenResponse tokens,
            XUserNameIdRequest model
        );

        Task<IEnumerable<string>> UnBan(
            XTokenResponse tokens,
            XUserNameIdRequest model
        );

        Task<bool> IsBanned(
            XTokenResponse tokens,
            string userSelectByParam
        );
        #endregion

        //
        #region Open Actions ...
        //
        XDeviceDto GetDevice();
        
        //
        Task<XOpenActionInnerDto> OpenGet(
            XOpenActionInnerDto model
        );

        //
        Task<XOpenActionUserInfoDto> GetUserInfo(
            XDeviceDto device,
            string userSelectByParam
        );
        Task<XOpenActionUserInfoDto> GetUserInfo(
            XOpenActionInnerDto dto
        );
        Task<XOpenActionUserInfoDto> GetUserInfo(
            string token,
            string request
        );

        //
        Task<IEnumerable<XOpenActionUserInfoDto>> GetUserInfos(
            XDeviceDto device,
            string ids
        );
        Task<IEnumerable<XOpenActionUserInfoDto>> GetUserInfos(
            XOpenActionInnerDto dto
        );
        Task<IEnumerable<XOpenActionUserInfoDto>> GetUserInfos(
            string token,
            string request
        );
        #endregion
    }
}