using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using xIdentityHelper;
using xCommons.Attributes;
using xCommons.Extensions;
using xExceptions.Constants;
using xIdentityModels.Constants;
using xIdentityModels.Models;
using static IdentityServer4.IdentityServerConstants;

namespace xIds.Controllers
{
    public partial class AccountController
    {
        //
        #region CanRegister ...
        /// <summary>
        /// Check a UserName is Available For Registration or not
        /// </summary>
        /// <param name="userName">an string value which represent desired username</param>
        /// <returns>a boolean value</returns>
        [AllowAnonymous]
        [RequireXPowered]
        [HttpGet("CanRegisterUserName/{userName?}")]
        public async Task<ActionResult<bool>> CanRegisterUserName(
            [FromRoute] string userName
        )
        {
            //
            // Validate Args ...
            if (userName.IsNullOrEmpty())
            {
                return BadRequest(
                    XException.InvalidArgs
                    .ToXError()
                );
            }

            //
            // Do Action ...
            try
            {
                //
                var result = await IdentityManager
                    .CanRegister(userName);

                //
                // Return Result
                return Ok(result);
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);

                //
                return result;
            }
        }

        /// <summary>
        /// Check a Mobile Number is Available For Registration or not
        /// </summary>
        /// <param name="mobileNumber">an string value which represent desired mobile number</param>
        /// <returns>a boolean value</returns>
        [AllowAnonymous]
        [RequireXPowered]
        [HttpGet("CanRegisterMobileNumber/{mobileNumber?}")]
        public async Task<ActionResult<bool>> CanRegisterMobileNumber(
            [FromRoute] string mobileNumber
        )
        {
            //
            // Validate Args ...
            if (mobileNumber.IsNullOrEmpty())
            {
                return BadRequest(
                    XException.InvalidArgs
                    .ToXError()
                );
            }
            if (!mobileNumber.IsValidMobileNumber())
            {
                return BadRequest(
                    XException.InvalidMobileNumber
                    .ToXError()
                );
            }

            //
            // Do Action ...
            try
            {
                //
                var result = await IdentityManager
                    .CanRegister(mobileNumber);

                //
                // Return Result
                return Ok(result);
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);

                //
                return result;
            }
        }

        /// <summary>
        /// Check a Email Address is Available For Registration or not
        /// </summary>
        /// <param name="email">an string value which represent desired email address</param>
        /// <returns>a boolean value</returns>
        [AllowAnonymous]
        [RequireXPowered]
        [HttpGet("CanRegisterEmail/{email?}")]
        public async Task<ActionResult<bool>> CanRegisterEmail(
            [FromRoute] string email
        )
        {
            //
            // Validate Args ...
            if (email.IsNullOrEmpty())
            {
                return BadRequest(
                    XException.InvalidArgs
                    .ToXError()
                );
            }
            if (!email.IsValidEmail())
            {
                return BadRequest(
                    XException.InvalidEmailAddress
                    .ToXError()
                );
            }

            //
            // Do Action ...
            try
            {
                //
                var result = await IdentityManager
                    .CanRegister(email);

                //
                // Return Result
                return Ok(result);
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);

                //
                return result;
            }
        }
        #endregion

        //
        #region Confirmations ...
        /// <summary>
        /// Check User is Confirmed Email or not
        /// </summary>
        /// <returns>a boolean value</returns>
        [RequireXPowered]
        [HttpGet("IsConfirmedEmail")]
        [Authorize(Policy = XPolicies.User)]
        [Authorize(Policy = LocalApi.PolicyName)]
        public async Task<ActionResult<bool>> IsConfirmedEmail()
        {
            //
            // Do Action ...
            try
            {
                //
                var result = await IdentityManager
                    .IsConfirmedEmail(User.Identity.Name);

                //
                // Return Result
                return Ok(result);
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);

                //
                return result;
            }
        }

        /// <summary>
        /// Check User is Confirmed Mobile or not
        /// </summary>
        /// <returns>a boolean value</returns>
        [RequireXPowered]
        [HttpGet("IsConfirmedMobile")]
        [Authorize(Policy = XPolicies.User)]
        [Authorize(Policy = LocalApi.PolicyName)]
        public async Task<ActionResult<bool>> IsConfirmedMobile()
        {
            //
            // Do Action ...
            try
            {
                //
                var result = await IdentityManager
                    .IsConfirmedMobile(User.Identity.Name);

                //
                // Return Result
                return Ok(result);
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);

                //
                return result;
            }
        }

        /// <summary>
        /// Confirm Registration
        /// </summary>
        /// <remarks>
        ///     for this action you have to provide:
        ///         - Lang: client device currently used locale, such as: en-US.
        ///         - ActionToken: user's requested action token for this action.
        ///         - Device: user's client device which is an instance of XDevice.
        ///         - ReturnUrl: client application Login URL.
        /// 
        /// Sample request:
        /// 
        ///     {
        ///         "lang": "fa-IR",
        ///         "actionToken": ""
        ///         "returnUrl": "http://localhost/login",
        ///         "device": {
        ///             "os":"Mac",
        ///             "browser":"Chrome",
        ///             "osVersion":"mac-os-x-15",
        ///             "userAgent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36",
        ///             "deviceType":3,
        ///             "identifier":"[Mac]-[mac-os-x-15]-[3]-[Chrome]-[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36]",
        ///             "token":"96f400dd9aa5c57a8cec9d6f4775bad3"
        ///         }
        ///     }
        /// 
        /// </remarks>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns></returns>
        [AllowAnonymous]
        [RequireXPowered]
        [HttpPost("ConfirmRegistration")]
        public async Task<ActionResult> ConfirmRegistration(
            [FromBody] XActionRequest model
        )
        {
            //
            // Do Action ...
            try
            {
                //
                // Validate Args ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(
                        model.Lang,
                        model.ActionToken,
                        model.ReturnUrl
                    )
                    .AddNotNull(model.Device)
                    .ValidateGroupAsync();

                //
                // Get Request ...
                await IdentityManager
                    .ConfirmRegistration(
                        model.Lang,
                        model.Device,
                        model.ActionToken,
                        model.ReturnUrl
                    );

                //
                return Ok();
            }
            catch (Exception ex)
            {
                //
                var exResult = GetExceptionActionResult(ex);
                return exResult;
            }
        }

        /// <summary>
        /// Confirm Requested Mobile Number
        /// </summary>
        /// <remarks>
        ///     for this action you have to provide:
        ///         - Lang: client device currently used locale, such as: en-US. 
        ///         - ActionToken: user's requested action token for this action. 
        ///         - Device: user's client device which is an instance of XDevice. 
        ///         - MobileVerificationCode: a verification code which produced due Request Action.
        /// 
        /// Sample request:
        /// 
        ///     {
        ///         "lang": "fa-IR",
        ///         "actionToken": ""
        ///         "mobileVerificationCode": "",
        ///         "device": {
        ///             "os":"Mac",
        ///             "browser":"Chrome",
        ///             "osVersion":"mac-os-x-15",
        ///             "userAgent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36",
        ///             "deviceType":3,
        ///             "identifier":"[Mac]-[mac-os-x-15]-[3]-[Chrome]-[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36]",
        ///             "token":"96f400dd9aa5c57a8cec9d6f4775bad3"
        ///         }
        ///     }
        /// 
        /// </remarks>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        [AllowAnonymous]
        [RequireXPowered]
        [HttpPost("ConfirmMobileNumber")]
        public async Task<ActionResult<XActionResponse>> ConfirmMobileNumber(
            [FromBody] XActionRequest model
        )
        {
            //
            // Do Action ...
            try
            {
                //
                // Validate Args ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(
                        model.Lang,
                        model.ActionToken,
                        model.MobileVerificationCode
                    )
                    .AddNotNull(model.Device)
                    .ValidateGroupAsync();

                //
                // Get Request ...
                var result = await IdentityManager
                    .ConfirmMobileNumber(
                        model.Lang,
                        model.Device,
                        model.ActionToken,
                        model.MobileVerificationCode
                    );

                //
                return Ok(result
                    .ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var exResult = GetExceptionActionResult(ex);
                return exResult;
            }
        }

        /// <summary>
        /// Confirm Requested Email Address
        /// </summary>
        /// <remarks>
        ///     for this action you have to provide: 
        ///         - Lang: client device currently used locale, such as: en-US. 
        ///         - ActionToken: user's requested action token for this action. 
        ///         - Device: user's client device which is an instance of XDevice. 
        ///         - EmailVerificationCode: a verification code which produced due Request Action.
        /// 
        /// Sample request:
        /// 
        ///     {
        ///         "lang": "fa-IR",
        ///         "actionToken": ""
        ///         "emailVerificationCode": "",
        ///         "device": {
        ///             "os":"Mac",
        ///             "browser":"Chrome",
        ///             "osVersion":"mac-os-x-15",
        ///             "userAgent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36",
        ///             "deviceType":3,
        ///             "identifier":"[Mac]-[mac-os-x-15]-[3]-[Chrome]-[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36]",
        ///             "token":"96f400dd9aa5c57a8cec9d6f4775bad3"
        ///         }
        ///     }
        /// 
        /// </remarks>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        [AllowAnonymous]
        [RequireXPowered]
        [HttpPost("ConfirmEmailAddress")]
        public async Task<ActionResult<XActionResponse>> ConfirmEmailAddress(
            [FromBody] XActionRequest model
        )
        {
            //
            // Do Action ...
            try
            {
                //
                // Validate Args ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(
                        model.Lang,
                        model.ActionToken,
                        model.EmailVerificationCode
                    )
                    .AddNotNull(model.Device)
                    .ValidateGroupAsync();

                //
                // Get Request ...
                var result = await IdentityManager
                    .ConfirmEmailAddress(
                        model.Lang,
                        model.Device,
                        model.ActionToken,
                        model.EmailVerificationCode
                    );

                //
                return Ok(result
                    .ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var exResult = GetExceptionActionResult(ex);
                return exResult;
            }
        }
        #endregion

        //
        #region Request for Actions ...
        /// <summary>
        /// Request For Mobile Number Change/Confirm 
        /// </summary>
        /// <remarks>
        ///     for this action you have to provide: 
        ///         - Lang: client device currently used locale, such as: en-US.
        ///         - Password: user's current active password.
        ///         - MobileNumber: which phone number is going to confirm.
        ///         - Device: user's client device which is an instance of XDevice.
        /// 
        /// Sample request:
        /// 
        ///     {
        ///         "lang": "fa-IR",
        ///         "password": "",
        ///         "mobileNumber": "",
        ///         "device": {
        ///             "os":"Mac",
        ///             "browser":"Chrome",
        ///             "osVersion":"mac-os-x-15",
        ///             "userAgent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36",
        ///             "deviceType":3,
        ///             "identifier":"[Mac]-[mac-os-x-15]-[3]-[Chrome]-[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36]",
        ///             "token":"96f400dd9aa5c57a8cec9d6f4775bad3"
        ///         }
        ///     }
        /// 
        /// </remarks>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        [AllowAnonymous]
        [RequireXPowered]
        [HttpPost("RequestConfirmMobile")]
        public async Task<ActionResult<XActionResponse>> RequestConfirmMobile(
            [FromBody] XActionRequest model
        )
        {
            //
            // Do Action ...
            try
            {
                //
                // Validate Args ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(
                        model.Lang,
                        model.Password,
                        model.MobileNumber
                    )
                    .AddNotNull(model.Device)
                    .AddMobileNumber(model.MobileNumber)
                    .ValidateGroupAsync();

                //
                // Get UserSelect By Param ...
                var userSelectByParam = GetUserSelectByParam(
                    model,
                    excludes: new List<XUserSelectBy> {
                        XUserSelectBy.Email,
                        XUserSelectBy.MobileNumber
                    });

                //
                // Get Request ...
                var result = await IdentityManager
                    .RequestConfirmMobile(
                        model.Lang,
                        model.Device,
                        userSelectByParam,
                        model.Password,
                        model.MobileNumber
                    );

                //
                return Ok(result
                    .ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var exResult = GetExceptionActionResult(ex);
                return exResult;
            }
        }

        /// <summary>
        /// Request For Email Address Change/Confirm
        /// </summary>
        /// <remarks>
        ///     for this action you have to provide:
        ///         - Lang: client device currently used locale, such as: en-US.
        ///         - Password: user's current active password.
        ///         - Email: which email address is going to confirm.
        ///         - Device: user's client device which is an instance of XDevice.
        /// 
        /// Sample request:
        /// 
        ///     {
        ///         "lang": "fa-IR",
        ///         "password": "",
        ///         "email": "",
        ///         "device": {
        ///             "os":"Mac",
        ///             "browser":"Chrome",
        ///             "osVersion":"mac-os-x-15",
        ///             "userAgent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36",
        ///             "deviceType":3,
        ///             "identifier":"[Mac]-[mac-os-x-15]-[3]-[Chrome]-[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36]",
        ///             "token":"96f400dd9aa5c57a8cec9d6f4775bad3"
        ///         }
        ///     }
        /// 
        /// </remarks>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        [AllowAnonymous]
        [RequireXPowered]
        [HttpPost("RequestConfirmEmail")]
        public async Task<ActionResult<XActionResponse>> RequestConfirmEmail(
            [FromBody] XActionRequest model
        )
        {
            //
            // Do Action ...
            try
            {
                //
                // Validate Args ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(
                        model.Lang,
                        model.Email,
                        model.Password)
                    .AddNotNull(model.Device)
                    .AddEmailAddress(model.Email)
                    .ValidateGroupAsync();

                //
                // Get UserSelect By Param ...
                var userSelectByParam = GetUserSelectByParam(
                    model,
                    excludes: new List<XUserSelectBy> {
                        XUserSelectBy.Email,
                        XUserSelectBy.MobileNumber
                    });

                //
                // Get Request ...
                var result = await IdentityManager
                    .RequestConfirmEmail(
                        model.Lang,
                        model.Device,
                        userSelectByParam,
                        model.Password,
                        model.Email
                    );

                //
                return Ok(result
                    .ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var exResult = GetExceptionActionResult(ex);
                return exResult;
            }
        }

        /// <summary>
        /// Request Reset Password Action
        /// </summary>
        /// <remarks>
        ///     for this action you have to provide:
        ///         - Lang: client device currently used locale, such as: en-US.
        ///         - Device: user's client device which is an instance of XDevice.
        ///         - ReturnUrl: client application ResetPassword URL.
        /// 
        /// Sample request:
        /// 
        ///     {
        ///         "lang": "fa-IR",
        ///         "returnUrl": "http://localhost/reset-password",
        ///         "device": {
        ///             "os":"Mac",
        ///             "browser":"Chrome",
        ///             "osVersion":"mac-os-x-15",
        ///             "userAgent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36",
        ///             "deviceType":3,
        ///             "identifier":"[Mac]-[mac-os-x-15]-[3]-[Chrome]-[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36]",
        ///             "token":"96f400dd9aa5c57a8cec9d6f4775bad3"
        ///         }
        ///     }
        /// 
        /// </remarks>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        [AllowAnonymous]
        [RequireXPowered]
        [HttpPost("RequestResetPassword")]
        public async Task<ActionResult<XActionResponse>> RequestResetPassword(
            [FromBody] XActionRequest model
        )
        {
            //
            // Do Action ...
            try
            {
                //
                // Validate Args ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(
                        model.Lang,
                        model.ReturnUrl)
                    .AddNotNull(model.Device)
                    .AddUrl(model.ReturnUrl)
                    .ValidateGroupAsync();

                //
                // Get UserSelect By Param ...
                var userSelectByParam = GetUserSelectByParam(model);

                //
                // Get Request ...
                var result = await IdentityManager
                    .RequestResetPassword(
                        model.Lang,
                        model.Device,
                        userSelectByParam,
                        model.ReturnUrl
                    );

                //
                return Ok(result
                    .ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var exResult = GetExceptionActionResult(ex);
                return exResult;
            }
        }

        /// <summary>
        /// Reset a User's Password
        /// </summary>
        /// <remarks>
        ///     for this action you have to provide:
        ///         - Lang: client device currently used locale, such as: en-US.
        ///         - ActionToken: user's requested action token for this action.
        ///         - NewPassword: user's new password to change.
        ///         - Device: user's client device which is an instance of XDevice.
        ///         - ReturnUrl: client application Login URL.
        /// 
        /// Sample request:
        /// 
        ///     {
        ///         "lang": "fa-IR",
        ///         "actionToken": "",
        ///         "newPassword": "",
        ///         "returnUrl": "http://localhost/login",
        ///         "device": {
        ///             "os":"Mac",
        ///             "browser":"Chrome",
        ///             "osVersion":"mac-os-x-15",
        ///             "userAgent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36",
        ///             "deviceType":3,
        ///             "identifier":"[Mac]-[mac-os-x-15]-[3]-[Chrome]-[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36]",
        ///             "token":"96f400dd9aa5c57a8cec9d6f4775bad3"
        ///         }
        ///     }
        /// 
        /// </remarks>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns></returns>
        [AllowAnonymous]
        [RequireXPowered]
        [HttpPost("ResetPassword")]
        public async Task<ActionResult> ResetPassword(
            [FromBody] XActionRequest model
        )
        {
            //
            // Do Action ...
            try
            {
                //
                // Validate Args ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(
                        model.Lang,
                        model.ActionToken,
                        model.NewPassword,
                        model.ReturnUrl)
                    .AddNotNull(model.Device)
                    .ValidateGroupAsync();

                //
                // Get Request ...
                await IdentityManager
                    .ResetPassword(
                        model.Lang,
                        model.Device,
                        model.ActionToken,
                        model.NewPassword,
                        model.ReturnUrl
                    );

                //
                return Ok();
            }
            catch (Exception ex)
            {
                //
                var exResult = GetExceptionActionResult(ex);
                return exResult;
            }
        }

        /// <summary>
        /// Request Registration Confirm
        /// </summary>
        /// <remarks>
        ///     for this action you have to provide:
        ///         - a UserSelectedBy identifier which represet User.
        ///         - Lang: client device currently used locale, such as: en-US.
        ///         - Password: user's current active password.
        ///         - Device: user's client device which is an instance of XDevice.
        ///         - ReturnUrl: client application Confirm Registration URL.
        /// 
        /// Sample request:
        /// 
        ///     {
        ///         "lang": "fa-IR",
        ///         "userId": ""
        ///         "password": "",
        ///         "returnUrl": "http://localhost/confirm",
        ///         "device": {
        ///             "os":"Mac",
        ///             "browser":"Chrome",
        ///             "osVersion":"mac-os-x-15",
        ///             "userAgent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36",
        ///             "deviceType":3,
        ///             "identifier":"[Mac]-[mac-os-x-15]-[3]-[Chrome]-[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36]",
        ///             "token":"96f400dd9aa5c57a8cec9d6f4775bad3"
        ///         }
        ///     }
        /// 
        /// </remarks>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns></returns>
        [AllowAnonymous]
        [RequireXPowered]
        [HttpPost("RequestConfirmRegistration")]
        public async Task<ActionResult> RequestConfirmRegistration(
            [FromBody] XActionRequest model
        )
        {
            //
            // Do Action ...
            try
            {
                //
                // Validate Args ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(
                        model.Lang,
                        model.Password,
                        model.ReturnUrl)
                    .AddNotNull(model.Device)
                    .AddUrl(model.ReturnUrl)
                    .ValidateGroupAsync();

                //
                // Get UserSelect By Param ...
                var userSelectByParam = GetUserSelectByParam(model);

                //
                // Get Request ...
                await IdentityManager
                    .RequestConfirmRegistration(
                        model.Lang,
                        model.Device,
                        userSelectByParam,
                        model.Password,
                        model.ReturnUrl
                    );

                //
                return Ok();
            }
            catch (Exception ex)
            {
                //
                var exResult = GetExceptionActionResult(ex);
                return exResult;
            }
        }
        #endregion

        //
        #region Registration ...
        /// <summary>
        /// Invite a User to Register on Dashboard
        /// </summary>
        /// <remarks>
        ///     for this action you have to provide: 
        ///         - Lang: client device currently used locale, such as: en-US.
        ///         - Email: which email address is going to invite.
        ///         - Device: user's client device which is an instance of XDevice.
        ///         - ReturnUrl: client application Registration URL.
        ///     notice in this step you had to provide all this informations as FormData
        /// 
        /// Sample request:
        /// 
        ///     {
        ///         "lang": "fa-IR",
        ///         "email": "",
        ///         "returnUrl": "",
        ///         "device": {
        ///             "os":"Mac",
        ///             "browser":"Chrome",
        ///             "osVersion":"mac-os-x-15",
        ///             "userAgent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36",
        ///             "deviceType":3,
        ///             "identifier":"[Mac]-[mac-os-x-15]-[3]-[Chrome]-[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36]",
        ///             "token":"96f400dd9aa5c57a8cec9d6f4775bad3"
        ///         }
        ///     }
        /// 
        /// </remarks>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        [RequireXPowered]
        [HttpPost("InviteUser")]
        [Authorize(Policy = LocalApi.PolicyName)]
        [Authorize(Policy = XPolicies.EnabledAdmin)]
        [Authorize(Policy = XPolicies.EnabledAgent)]
        public async Task<ActionResult<XActionResponse>> InviteUser(
            [FromBody] XActionRequest model
        )
        {
            //
            // Do Action ...
            try
            {
                //
                // Validate Args ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }

                //
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(
                        model.Lang,
                        model.Email,
                        model.ReturnUrl)
                    .AddEmailAddress(model.Email)
                    .AddNotNull(model.Device)
                    .ValidateGroupAsync();

                //
                var result = await IdentityManager
                    .InviteUser(
                        model.Lang,
                        model.Device,
                        model.Email,
                        model.ReturnUrl);

                //
                return Ok(result
                    .ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Recieve some Basic Informations and Start Registration Proccess
        /// if they Valid 
        /// 
        /// Registration Proccess Starts with Invoking this Action
        /// </summary>
        /// <remarks>
        ///     for this action you have to provide: 
        ///         - Lang: client device currently used locale, such as: en-US.
        ///         - FirstName: user's FirstName.
        ///         - LastName: user's LastName.
        ///         - DateOfBirth: user's dob date.
        ///         - MobileNumber: user's MobileNumber optional.
        ///         - Email: user's Email optional.
        ///         - ActionToken: user's requested action token for this action (if user invited). 
        ///         - Device: user's client device which is an instance of XDevice.
        /// 
        /// Sample request:
        /// 
        ///     {
        ///         "lang": "fa-IR",
        ///         "firstName": "",
        ///         "lastName": "",
        ///         "dateOfBirth": "",
        ///         "email": "",
        ///         "mobileNumber": "",
        ///         "actionToken": "",
        ///         "device": {
        ///             "os":"Mac",
        ///             "browser":"Chrome",
        ///             "osVersion":"mac-os-x-15",
        ///             "userAgent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36",
        ///             "deviceType":3,
        ///             "identifier":"[Mac]-[mac-os-x-15]-[3]-[Chrome]-[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36]",
        ///             "token":"96f400dd9aa5c57a8cec9d6f4775bad3"
        ///         }
        ///     }
        /// 
        /// </remarks>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        [AllowAnonymous]
        [RequireXPowered]
        [HttpPost("RequestRegistration")]
        public async Task<ActionResult<XActionResponse>> RequestRegistration(
            [FromBody] XActionRequest model
        )
        {
            //
            // Do Action ...
            try
            {
                //
                // Validate Args ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(
                        model.Lang,
                        model.FirstName,
                        model.LastName)
                    .AddNotNull(
                        model.Device,
                        model.DateOfBirth)
                    .ValidateGroupAsync();

                //
                // Check Date Of Birth ...
                if (!model.DateOfBirth.HasValue)
                {
                    XException.InvalidArgs.Throw(); ;
                }

                //
                // Validate Mobile Number if Exists ...
                if (!model.MobileNumber.IsNullOrEmpty())
                {
                    ValidationProvider.MobileNumber(model.MobileNumber);
                }

                //
                // Validate Email Address if Exists ...
                if (!model.Email.IsNullOrEmpty())
                {
                    ValidationProvider.EmailAddress(model.Email);
                }

                //
                // Get Request ...
                var result = await IdentityManager
                    .RequestRegistration(
                        model.Lang,
                        model.Device,
                        model.ActionToken,
                        model.FirstName,
                        model.LastName,
                        model.DateOfBirth.GetValueOrDefault(),
                        model.MobileNumber,
                        model.Email
                    );

                //
                return Ok(result
                    .ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var exResult = GetExceptionActionResult(ex);

                //
                return exResult;
            }
        }

        /// <summary>
        /// Add User Account Informations
        /// </summary>
        /// <remarks>
        ///     for this action you have to provide: 
        ///         - Lang: client device currently used locale, such as: en-US.
        ///         - ActionToken: user's requested action token for this action.
        ///         - UserName: user name.
        ///         - Password: assigne password.
        ///         - Device: user's client device which is an instance of XDevice.
        /// 
        /// Sample request:
        /// 
        ///     {
        ///         "lang": "fa-IR",
        ///         "userName": "",
        ///         "password": "",
        ///         "actionToken": "",
        ///         "device": {
        ///             "os":"Mac",
        ///             "browser":"Chrome",
        ///             "osVersion":"mac-os-x-15",
        ///             "userAgent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36",
        ///             "deviceType":3,
        ///             "identifier":"[Mac]-[mac-os-x-15]-[3]-[Chrome]-[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36]",
        ///             "token":"96f400dd9aa5c57a8cec9d6f4775bad3"
        ///         }
        ///     }
        /// 
        /// </remarks>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        [AllowAnonymous]
        [RequireXPowered]
        [HttpPost("AddAccountInfo")]
        public async Task<ActionResult<XActionResponse>> AddAccountInfo(
            [FromBody] XActionRequest model
        )
        {
            //
            // Do Action ...
            try
            {
                //
                // Validate Args ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(
                        model.Lang,
                        model.ActionToken,
                        model.UserName,
                        model.Password)
                    .AddNotNull(model.Device)
                    .ValidateGroupAsync();

                //
                // Get Request ...
                var result = await IdentityManager
                    .AddAcountInfo(
                        model.Lang,
                        model.Device,
                        model.ActionToken,
                        model.UserName,
                        model.Password);

                //
                return Ok(result
                    .ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var exResult = GetExceptionActionResult(ex);
                return exResult;
            }
        }

        /// <summary>
        /// Upload and Attach a Profile Image for User. this is an Optional Step
        /// </summary>
        /// <param name="actionToken">user's requested action token</param>
        /// <param name="file">an instance of <see>IFormFile</see> for user's Avatar</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        [AllowAnonymous]
        [RequireXPowered]
        [HttpPost("AttachProfileImage")]
        public async Task<ActionResult<XActionResponse>> AttachProfileImage(
            [FromForm] string actionToken, [FromForm] IFormFile file
        )
        {
            //
            // Do Action ...
            try
            {
                // 
                // Validate Args ...
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(actionToken)
                    .AddNotNull(file)
                    .ValidateGroupAsync();

                //
                var result = await IdentityManager
                    .AttachProfileImage(actionToken, file);

                //
                return Ok(result
                    .ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var exResult = GetExceptionActionResult(ex);
                return exResult;
            }
        }

        /// <summary>
        /// Finish Registrationn Proccess 
        /// </summary>
        /// <remarks>
        ///     for this action you have to provide: 
        ///         - a proper User Identifier such as: (UserId, UserName, Email or MobileNumber).
        ///         - Lang: client device currently used locale, such as: en-US.
        ///         - ActionToken: user's requested action token for this action.
        ///         - Password: assigne password.
        ///         - Device: user's client device which is an instance of XDevice.
        ///         - ReturnUrl: client application Login URL.
        /// 
        /// Sample request:
        /// 
        ///     {
        ///         "lang": "fa-IR",
        ///         "userName": "",
        ///         "password": "",
        ///         "returnUrl": "",
        ///         "device": {
        ///             "os":"Mac",
        ///             "browser":"Chrome",
        ///             "osVersion":"mac-os-x-15",
        ///             "userAgent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36",
        ///             "deviceType":3,
        ///             "identifier":"[Mac]-[mac-os-x-15]-[3]-[Chrome]-[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) x-framework-test/0.0.0 Chrome/87.0.4280.141 Electron/11.2.0 Safari/537.36]",
        ///             "token":"96f400dd9aa5c57a8cec9d6f4775bad3"
        ///         }
        ///     }
        /// 
        /// </remarks>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns></returns>
        [AllowAnonymous]
        [RequireXPowered]
        [HttpPost("FinishRegistration")]
        public async Task<ActionResult> FinishRegistration(
            [FromBody] XActionRequest model
        )
        {
            //
            // Do Action ...
            try
            {
                //
                // Validate Args ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(
                        model.Lang,
                        model.Password,
                        model.ReturnUrl)
                    .AddNotNull(model.Device)
                    .AddUrl(model.ReturnUrl)
                    .ValidateGroupAsync();

                //
                var userSelectByParam = IdentityManager
                    .GetUserSelectByParam(model);
                ValidationProvider
                    .NotEmpty(userSelectByParam);

                //
                // Get Request ...
                await IdentityManager
                    .FinishRegistration(
                        model.Lang,
                        model.Device,
                        userSelectByParam,
                        model.Password,
                        model.ReturnUrl
                    );

                //
                return Ok();
            }
            catch (Exception ex)
            {
                //
                var exResult = GetExceptionActionResult(ex);

                //
                return exResult;
            }
        }
        #endregion
    }
}