/// <summary>
 ///
 /// </summary>
 public QuestionController()
 {
     _coreModel = new QuestionCoreModel();
 }
        public Task <Result <UserSurveyModel> > Answer(SurveyAnswerModel model)
        => Result <UserSurveyModel> .TryAsync(async() =>
        {
            var results = await _repository.ListAsync <Answer>(a => model.AnswerIds.Contains(a.Id),
                                                               a => a.Question.Survey.Question.Select(q => q.Answer.Select(aa => aa.Action)),
                                                               a => a.Question.MustAnswered, a => a.Question.Survey.Question.Select(q => q.MustAnswered),
                                                               a => a.Question.Survey.Question.Select(q => q.MustAnswered)
                                                               , a => a.Action);


            if (!results.Success || results.Data == null || !results.Data.Any() ||
                results.Data.Count != model.AnswerIds.Count)
            {
                return(Result <UserSurveyModel> .Failed(Error.WithData(1000, new[] { "answer not found" })));
            }
            if (results.Data.GroupBy(a => a.Question).ToList().Count() != 1)
            {
                return(Result <UserSurveyModel> .Failed(Error.WithData(1000,
                                                                       new[] { "answers are not from one question" })));
            }


            var answers = results.Data;

            var resultUserSurvey = await _repository.FirstOrDefaultAsync <UserSurvey>(us =>
                                                                                      us.SurveyId == answers.FirstOrDefault().Question.Survey.Id&&
                                                                                      us.UserId == generalDataService.User.Id,
                                                                                      us => us.UserAnswer.Select(ua => ua.Answer.Question.Survey.Question.Select(q => q.Answer)),
                                                                                      us => us.Survey.Question.Select(q => q.MustAnswered),
                                                                                      us => us.Survey.Question.Select(question => question.Answer), us => us.UserDependentSurvey);

//                var resultUserSurvey = await _repository.FirstOrDefaultAsync<UserSurvey>(us =>
//                        us.SurveyId == answers.FirstOrDefault().Question.Survey.Id && us.UserId == generalDataService.User.Id,
//                    us => us.UserAnswer);

            UserSurvey userSurvey = null;
            if (resultUserSurvey.Data == null)     // first answer
            {
                userSurvey = new UserSurvey
                {
                    Id         = Guid.NewGuid(),
                    UserId     = generalDataService.User.Id,
                    Survey     = answers.FirstOrDefault().Question.Survey,
                    IsFinsihed = answers.FirstOrDefault().Question.Survey.Question.Count == 1,
                    UserAnswer = answers.Select(answer => new UserAnswer
                    {
                        Id = Guid.NewGuid(), Answer = answer, Text = model.UserAnswer
                    }).ToList()
                };
                _repository.Add(userSurvey);
            }
            else     // not the first answer
            {
                userSurvey = resultUserSurvey.Data;

                var questionsAnswered = userSurvey.UserAnswer.Select(ua => ua.Answer.Question).ToList();
                if (questionsAnswered.Select(qa => qa.Id).Contains(answers.FirstOrDefault().Question.Id)
                    ) // change answer
                {
                    var previousAnswers = userSurvey.UserAnswer.Where(ua =>
                                                                      answers.Any(aa => aa.Question.Id == ua.Answer.Question.Id)).ToList();
                    previousAnswers.AddRange(userSurvey.UserAnswer.Where(ua =>
                                                                         ua.Answer.Question.Number > answers.FirstOrDefault().Question.Number));
                    var actions = previousAnswers.Where(ua =>
                                                        ua.Answer.Question.Number > answers.FirstOrDefault().Question.Number).ToList()
                                  .SelectMany(ua => ua.Answer.Action);
                    if (actions.Any(a => a.Type == (int)ActionType.AddDependent))
                    {
                        if (previousAnswers.Any(ua => ua.Answer.Question.Text.ToLower().Contains("spouse")))
                        {
                            _repository.RemoveRange(userSurvey.UserDependentSurvey);
                            if (userSurvey.UserAssessmentSurvey != null && userSurvey.UserAssessmentSurvey.Any() &&
                                userSurvey.UserAssessmentSurvey
                                .Select(ua => ua.UserAssessmentBlob).Any())
                            {
                                _repository.RemoveRange(userSurvey.UserAssessmentSurvey
                                                        .Select(ua => ua.UserAssessmentBlob).ToList());
                            }
                            if (userSurvey.UserAssessmentSurvey != null && userSurvey.UserAssessmentSurvey.Any())
                            {
                                _repository.RemoveRange(userSurvey.UserAssessmentSurvey);
                            }
                        }
                        else
                        {
                            var allDependents =
                                await _membershipServiceApi.MembershipLinkedUserApiService.ListByUser(
                                    new MembershipService.ApiClient.Models.BaseModel
                            {
                                Id = generalDataService.User.Id
                            });
                            var dependentIds = allDependents.Data.Where(ad => ad.RelationType.ToLower() != "spouse")
                                               .ToList()
                                               .Select(ad => ad.FirstUser.Id).ToList();
                            _repository.RemoveRange(
                                userSurvey.UserDependentSurvey.Where(ud => dependentIds.Contains(ud.UserId))
                                .ToList());
                        }
                    }

                    if (actions.Any(a => a.Type == (int)ActionType.AddRelative))
                    {
                        _repository.RemoveRange(userSurvey.UserRelativeSurvey);
                    }


                    previousAnswers.ForEach(previousAnswer => userSurvey.UserAnswer.Remove(previousAnswer));
                    _repository.RemoveRange(previousAnswers);
                }

                answers.ToList().ForEach(
                    answer => userSurvey.UserAnswer.Add(new UserAnswer
                {
                    Id = Guid.NewGuid(), Answer = answer, Text = model.UserAnswer
                }));
            }

            QuestionCoreModel nextQuestionCoreModel = CalculateNextQuestion(answers.FirstOrDefault(), userSurvey);

            var userResult = await _membershipServiceApi.AuthAuthApiService.Setting(
                new MembershipService.ApiClient.Models.BaseModel
            {
                Id = generalDataService.User.Id
            });

            var profile = await _membershipServiceApi.AuthAuthApiService.Profile(
                new MembershipService.ApiClient.Models.BaseModel
            {
                Id = generalDataService.User.Id
            });

            var isFinished = SurveyIsFinished(userSurvey).Data;

            var makeAppointment = false;
            var userCartUpdated = false;
            Guid?invoiceId      = null;
            if (isFinished)     // Perform actions after survey is finished
            {
                var result      = (await PerformActions(userSurvey)).Data;
                invoiceId       = result.Item1;
                makeAppointment = result.Item2;

                await _messageBiz.Add(new CreateMessageModel
                {
                    Title = "Survey Finished",
                    Body  =
                        "you have successfully finished your survey , we will check and contact you about the results as soon as possible ",
                    Priority = MessagePriority.High
                });

                _coreSmtpClient.SendSurveySubmittedNotif(profile.Data.Email, profile.Data.Mobile,
                                                         profile.Data.Username,
                                                         DateTime.Now.ToString("F"));


//                    _coreSmtpClient.Send(userResult.Data.Email,
//                        $"Dear {userResult.Data.Firstname} {userResult.Data.Lastname} ,\n you have finished our survey , we will check and contact you about the results as soon as possible. \n Best Regards",
//                        "Finished Survey ");

//                    _smsHttpClient.Send(userResult.Data.Mobile,
//                        $"Dear {userResult.Data.Firstname} {userResult.Data.Lastname} , You have finished doing a survey, we will check and contact you about the results as soon as possible. \n Best Regards ");
            }

            userSurvey.IsFinsihed = isFinished;
            await _repository.CommitAsync();

            return(Result <UserSurveyModel> .Successful(new UserSurveyModel
            {
                NextQuestion = nextQuestionCoreModel,
                SurveyId = answers.FirstOrDefault().Question.Survey.Id,
                MakeAnAppointment = makeAppointment,
                UserCartUpdated = userCartUpdated,
                SurveyName = answers.FirstOrDefault().Question.Survey.Name,
                IsFinished = isFinished,
                IsStarted = true,
                QuestionCount = userSurvey.Survey.Question.Count,
                InvoiceId = invoiceId,
                User = userResult.Data
            }));
        });