using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using xCommons.Extensions;
using xExceptions.Constants;
using xIdentityModels.Dtos;

namespace xIds.Providers
{
    public partial class XIdentityManager
    {
        //
        #region OpenGet ...
        public async Task<XOpenActionInnerDto> OpenGet(
            XOpenActionInnerDto model
        )
        {
            //
            // Validate Args ...
            await ValidationProvider
                .GroupValidationBuilder()
                .AddNotNull(model)
                .AddNotEmpty(model.Token)
                .AddNotEmpty(model.Payload)
                .ValidateGroupAsync();

            //
            return await OpenGet(
                token: model.Token,
                actionRequest: model.Payload
            );
        }

        //
        public async Task<XOpenActionInnerDto> OpenGet(
            string token,
            string actionRequest
        )
        {
            //
            // Validatr Args ...
            await ValidationProvider
                .GroupValidationBuilder()
                .AddNotEmpty(token)
                .AddNotEmpty(actionRequest)
                .ValidateGroupAsync();
            //
            // Try to Decrypt Request ...
            var requestModel = ParseModel(
                token: token,
                request: actionRequest
            );
            if (requestModel.IsNull() ||
                requestModel.Action.IsNullOrEmpty())
            {
                XException.BadRequest.Throw();
            }

            //
            var responseJson = string.Empty;
            switch (requestModel.Action)
            {
                //
                case XOpenActions.GetUserInfo:
                    //
                    ValidationProvider.NotEmpty(requestModel.Payload);
                    var userInfo = await GetUserInfo(requestModel);
                    if (userInfo.IsNull())
                    {
                        XException.InvalidData.Throw();
                    }

                    //
                    responseJson = userInfo.ToJSON();
                    break;

                //
                case XOpenActions.GetUserInfos:
                    ValidationProvider.NotEmpty(requestModel.Payload);
                    var userInfos = await GetUserInfos(requestModel);
                    if (userInfos.IsNull())
                    {
                        XException.InvalidData.Throw();
                    }

                    //
                    responseJson = userInfos.ToJSON();
                    break;
            }

            //
            // Encrypt Json Str ...
            var responseStr = SecurityProvider.Encrypt(responseJson);
            requestModel.Payload = responseStr;
            requestModel.Timestamp = DateTime.UtcNow
                .AddMinutes(5)
                .ToTimestamp()
                .ToString();

            //
            token = requestModel.ToOpenActionToken();
            requestModel.Checksum = token;
            var result = new XOpenActionInnerDto
            {
                Token = token,
                Payload = requestModel.ToJSON()
            };

            //
            // Check Result ...
            if (result.IsNull())
            {
                XException.ActionFailed.Throw();
            }

            //
            return result;
        }
        #endregion

        public async Task<XOpenActionUserInfoDto> GetUserInfo(
            XOpenActionRequestDto model
        )
        {
            //
            // Retrieve User Profile ...
            var userProfile = await GetUserProfileAsync(
                checkIsBanned: false,
                checkCanLoginPolicies: false,
                requestedUserSelectByParam: "",
                forceCheckRequestedUser: false,
                userSelectByParam: model.Payload
            );

            //
            //  Generate a Dynamic Object ...
            var result = new XOpenActionUserInfoDto
            {
                Username = userProfile.UserName,
                Firstname = userProfile.FirstName,
                Lastname = userProfile.LastName,
                Avatar = userProfile.Avatar
            };

            //
            return result;
        }

        public async Task<IEnumerable<XOpenActionUserInfoDto>> GetUserInfos(
            XOpenActionRequestDto model
        )
        {
            //
            var ids = model.Payload.ParseListString<string>().ToList();
            var profiles = await GetUserProfilesAsync(
                ids: ids,
                checkIsBanned: false,
                checkCanLoginPolicies: false,
                requestedUserSelectByParam: "",
                forceCheckRequestedUser: false
            );
            var result = profiles.Select(x => new XOpenActionUserInfoDto
            {
                Avatar = x.Avatar,
                Username = x.UserName,
                Lastname = x.LastName,
                Firstname = x.FirstName,
            });

            //
            return result;
        }

        //
        #region Private ...
        private XOpenActionRequestDto ParseModel(
            string token,
            string request
        )
        {
            //
            // Decript request to get Json string of request object ...
            var result = new XOpenActionRequestDto();

            //
            var jsonStr = SecurityProvider.Decrypt(request);
            result = jsonStr.FromJSON<XOpenActionRequestDto>();
            if (result.IsNull() ||
                !result.Validate() ||
                token != result.Checksum
            )
            {
                //
                result = null;
                return result;
            }

            //
            var modelChecksum = result.ToOpenActionToken();
            result =
                token == modelChecksum
                ? result
                : null;

            //
            return result;
        }
        #endregion
    }
}