DamageAssessment_Backend/DamageAssesmentApi/DamageAssesment.Api.Questions/Providers/QuestionsProvider.cs

using AutoMapper;
using DamageAssesment.Api.Questions.Db;
using DamageAssesment.Api.Questions.Interfaces;
using DamageAssesment.Api.Questions.Models;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Internal;

namespace DamageAssesment.Api.Questions.Providers
{


    public class QuestionsProvider : IQuestionsProvider, IQuestionTypesProvider
    {
        private QuestionDbContext questionDbContext;
        private ILogger<QuestionsProvider> logger;
        private IMapper mapper;

        public QuestionsProvider(QuestionDbContext questionDbContext, ILogger<QuestionsProvider> logger, IMapper mapper)
        {
            this.questionDbContext = questionDbContext;
            this.logger = logger;
            this.mapper = mapper;
            SeedData();
        }

        public void SeedData()
        {

            if (!questionDbContext.QuestionsTranslations.Any())
            {
                questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { Id = 1, QuestionId = 1, QuestionText = "Can You Open ?", Language = "en" });
                questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { Id = 2, QuestionId = 1, QuestionText = "Peux-tu ouvrir ?", Language = "fr" });
                questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { Id = 3, QuestionId = 2, QuestionText = "Are the grounds flodded ?", Language = "en" });
                questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { Id = 4, QuestionId = 2, QuestionText = "Les terrains sont-ils inondés ?", Language = "fr" });
                questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { Id = 5, QuestionId = 3, QuestionText = "Is the access blocked by flooding ?", Language = "en" });
                questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { Id = 6, QuestionId = 3, QuestionText = "L'accès est-il bloqué par les inondations ?", Language = "fr" });
                questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { Id = 7, QuestionId = 1, QuestionText = "Puedes abrir ?", Language = "es" });
                questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { Id = 8, QuestionId = 2, QuestionText = "¿Están inundados los terrenos?", Language = "es" });
                questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { Id = 9, QuestionId = 3, QuestionText = "¿El acceso está bloqueado por inundaciones?", Language = "es" });
                questionDbContext.SaveChanges();
            }
            if (!questionDbContext.Questions.Any())
            {
                questionDbContext.Questions.Add(new Db.Question() { Id = 1,  QuestionTypeId = 2, SurveyId = 1, QuestionNumber = 1, IsRequired = true, Comment = false, Key = true, CategoryId=1 });
                questionDbContext.Questions.Add(new Db.Question() { Id = 2,  QuestionTypeId = 1, SurveyId = 1, QuestionNumber = 2, IsRequired = false, Comment = true, Key = false,  CategoryId = 1 });
                questionDbContext.Questions.Add(new Db.Question() { Id = 3,  QuestionTypeId = 1, SurveyId = 1, QuestionNumber = 3, IsRequired = true, Comment = false, Key = true,  CategoryId = 2 });
                questionDbContext.SaveChanges();
            }
            if (!questionDbContext.QuestionTypes.Any())
            {
                questionDbContext.QuestionTypes.Add(new Db.QuestionType() { Id = 1, TypeText = "RadioButton" });
                questionDbContext.QuestionTypes.Add(new Db.QuestionType() { Id = 2, TypeText = "CheckBox" });
                questionDbContext.QuestionTypes.Add(new Db.QuestionType() { Id = 3, TypeText = "TextBox" });
                questionDbContext.SaveChanges();
            }

            if (!questionDbContext.QuestionCategories.Any())
            {
                questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { Id = 1, CategoryName = "Flooding", CategoryImage= "https://example.com/images/img1.png" });
                questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { Id = 2, CategoryName = "Electrical", CategoryImage = "https://example.com/images/img2.png" });
                questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { Id = 3, CategoryName = "Structural", CategoryImage = "https://example.com/images/img3.png" });
                questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { Id = 4, CategoryName = "Utility", CategoryImage = "https://example.com/images/img4.png" });
                questionDbContext.QuestionCategories.Add(new Db.QuestionCategory()   { Id = 5, CategoryName = "Debris", CategoryImage = "https://example.com/images/img5.png" });
                questionDbContext.SaveChanges();
            }
        }

        public async Task<(bool IsSuccess, IEnumerable<Models.Question> Questions, string ErrorMessage)> GetQuestionsAsync(string Language)
        {
            try
            {
                logger?.LogInformation("Query Question");
                var questions = await questionDbContext.Questions.Include("QuestionType").AsNoTracking().ToListAsync();
                if (questions != null)
                {

                    //logger?.LogInformation($"{question} customer(s) found");
                    var result = mapper.Map<IEnumerable<Db.Question>, IEnumerable<Models.Question>>(questions);


                    foreach (var question in result)
                    {
                        if (string.IsNullOrEmpty(Language))
                        {
                            question.Questions = mapper.Map<List<Db.QuestionsTranslation>, List<Models.QuestionsTranslation>>(
                            questionDbContext.QuestionsTranslations.Where(a => a.QuestionId == question.Id).ToList());
                        }
                        else
                        {
                            question.Questions = mapper.Map<List<Db.QuestionsTranslation>, List<Models.QuestionsTranslation>>(
                            questionDbContext.QuestionsTranslations.Where(a => a.QuestionId == question.Id && a.Language == Language).ToList());
                        }
                    }
                    return (true, result, null);
                }
                return (false, null, "Not found");
            }
            catch (Exception ex)
            {
                logger?.LogError(ex.ToString());
                return (false, null, ex.Message);
            }
        }
        public async Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> GetQuestionAsync(int Id, string Language)
        {
            try
            {
                logger?.LogInformation("Query Question");
                var question = await questionDbContext.Questions.Include("QuestionType").AsNoTracking().FirstOrDefaultAsync(q => q.Id == Id);
                if (question != null)
                {
                    logger?.LogInformation($"{question} customer(s) found");
                    var result = mapper.Map<Db.Question, Models.Question>(question);

                    if (string.IsNullOrEmpty(Language))
                    {
                        result.Questions = mapper.Map<List<Db.QuestionsTranslation>, List<Models.QuestionsTranslation>>(
                                questionDbContext.QuestionsTranslations.Where(a => a.QuestionId == result.Id).ToList());
                    }
                    else
                    {
                        result.Questions = mapper.Map<List<Db.QuestionsTranslation>, List<Models.QuestionsTranslation>>(
                     questionDbContext.QuestionsTranslations.Where(a => a.QuestionId == result.Id && a.Language == Language).ToList());
                    }
                    return (true, result, null);
                }
                return (false, null, "Not found");
            }
            catch (Exception ex)
            {
                logger?.LogError(ex.ToString());
                return (false, null, ex.Message);
            }
        }
        public List<Models.Question> GetSurveyQuestion(List<Models.Question> questions, string Language)
        {
            if (string.IsNullOrEmpty(Language))
            {
                foreach (var item in questions)
                {
                    item.Questions = mapper.Map<List<Db.QuestionsTranslation>, List<Models.QuestionsTranslation>>(
                                questionDbContext.QuestionsTranslations.Where(a => a.QuestionId == item.Id).ToList());
                }
            }
            else
            {
                foreach (var item in questions)
                {
                    item.Questions = mapper.Map<List<Db.QuestionsTranslation>, List<Models.QuestionsTranslation>>(
                                questionDbContext.QuestionsTranslations.Where(a => a.QuestionId == item.Id && a.Language == Language).ToList());
                }
            }
            return questions;
        }
        public async Task<(bool IsSuccess, List<SurveyQuestions> SurveyQuestions, string ErrorMessage)> GetSurveyQuestionAsync(int SurveyId, string Language)
        {
            try
            {
                logger?.LogInformation("Query Question");
                var questions = await questionDbContext.Questions.Include("QuestionType").Where(a => a.SurveyId == SurveyId).AsNoTracking().ToListAsync();
                if (questions != null)
                {
                    List<SurveyQuestions> surveyQuestionsList = new List<SurveyQuestions>();
                    List<int> CategoryIds = questions.Select(a => a.CategoryId).Distinct().ToList();
                    var questioncategories = await questionDbContext.QuestionCategories.Where(a => CategoryIds.Contains(a.Id)).ToListAsync();
                    //logger?.LogInformation($"{question} customer(s) found");
                    foreach (var item in questioncategories)
                    {
                        surveyQuestionsList.Add(new SurveyQuestions()
                        {
                            CategoryId = item.Id,
                            CategoryImage = item.CategoryImage,
                            CategoryName = item.CategoryName,
                            Questions = GetSurveyQuestion(mapper.Map<List<Db.Question>, List<Models.Question>>(questions.Where(a => a.CategoryId == item.Id).ToList()), Language)
                        });
                    }

                    //var result = mapper.Map<IEnumerable<Db.Question>, IEnumerable<Models.Question>>(questions);
                    return (true, surveyQuestionsList, null);
                }
                return (false, null, "Not found");
            }
            catch (Exception ex)
            {
                logger?.LogError(ex.ToString());
                return (false, null, ex.Message);
            }
        }
        public async Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> PostQuestionAsync(Models.Question Question)
        {
            try
            {
                logger?.LogInformation("Query Question");
                var dbquestion = mapper.Map<Models.Question, Db.Question>(Question);
                var dbquestiontranslation = mapper.Map<List<Models.QuestionsTranslation>, List<Db.QuestionsTranslation>>(Question.Questions);
                dbquestion.QuestionTypeId = questionDbContext.QuestionTypes.Where(a => a.TypeText == Question.TypeText).Select(a => a.Id).FirstOrDefault();
                questionDbContext.Questions.Add(dbquestion);
                dbquestiontranslation.ForEach(i => i.QuestionId = dbquestion.Id);
                questionDbContext.QuestionsTranslations.AddRange(dbquestiontranslation);
                questionDbContext.SaveChanges();
                Question.Id = dbquestion.Id;
                return (true, Question, null);
            }
            catch (Exception ex)
            {
                logger?.LogError(ex.ToString());
                return (false, null, ex.Message);
            }
        }
        public async Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> UpdateQuestionAsync(Models.Question Question)
        {
            try
            {
                var dbquestion = mapper.Map<Models.Question, Db.Question>(Question);
                var dbquestiontranslation = mapper.Map<List<Models.QuestionsTranslation>, List<Db.QuestionsTranslation>>(Question.Questions);
                dbquestion.QuestionTypeId = questionDbContext.QuestionTypes.Where(a => a.TypeText == Question.TypeText).Select(a => a.Id).FirstOrDefault();
                questionDbContext.Entry(dbquestion).State = EntityState.Modified;
                var oldquestions = questionDbContext.QuestionsTranslations.Where(a => a.QuestionId == dbquestion.Id).ToList();
                if (oldquestions != null)
                    questionDbContext.QuestionsTranslations.RemoveRange(oldquestions);
                dbquestiontranslation.ForEach(i => i.QuestionId = dbquestion.Id);
                questionDbContext.QuestionsTranslations.AddRange(dbquestiontranslation);
                questionDbContext.SaveChanges();
                return (true, Question, null);
            }
            catch (Exception ex)
            {

                logger?.LogError(ex.ToString());
                return (false, null, ex.Message);
            }
        }
        public async Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> DeleteQuestionAsync(int Id)
        {
            try
            {
                var question = await questionDbContext.Questions.Where(x => x.Id == Id).FirstOrDefaultAsync();

                if (question != null)
                {
                    questionDbContext.Questions.Remove(question);
                    questionDbContext.SaveChanges();
                    return (true, mapper.Map<Db.Question, Models.Question>(question), $"QuestionID {Id} deleted Successfuly");
                }
                else
                {
                    logger?.LogInformation($"QuestionID: {Id} Not found");
                    return (false, null, "Not Found");
                }
            }
            catch (Exception ex)
            {
                logger?.LogError(ex.ToString());
                return (false, null, ex.Message);
            }
        }

        //Question Category Logic

        public async Task<(bool IsSuccess, IEnumerable<Models.QuestionCategory> QuestionCategories, string ErrorMessage)> GetQuestionCategoriesAsync()
        {
            try
            {
                logger?.LogInformation("Query Question");
                var questionCategories = await questionDbContext.QuestionCategories.AsNoTracking().ToListAsync();
                if (questionCategories != null)
                {
                    //logger?.LogInformation($"{question} customer(s) found");
                    var result = mapper.Map<IEnumerable<Db.QuestionCategory>, IEnumerable<Models.QuestionCategory>>(questionCategories);
                    return (true, result, null);
                }
                return (false, null, "Not found");
            }
            catch (Exception ex)
            {
                logger?.LogError(ex.ToString());
                return (false, null, ex.Message);
            }
        }
        public async Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> GetQuestionCategoryAsync(int Id)
        {
            try
            {
                logger?.LogInformation("Query Question");
                var questioncategory = await questionDbContext.QuestionCategories.AsNoTracking().FirstOrDefaultAsync(q => q.Id == Id);
                if (questioncategory != null)
                {
                    logger?.LogInformation($"{questioncategory} customer(s) found");
                    var result = mapper.Map<Db.QuestionCategory, Models.QuestionCategory>(questioncategory);
                    return (true, result, null);
                }
                return (false, null, "Not found");
            }
            catch (Exception ex)
            {
                logger?.LogError(ex.ToString());
                return (false, null, ex.Message);
            }
        }
        public async Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> PostQuestionCategoryAsync(Models.QuestionCategory QuestionCategory)
        {
            try
            {
                logger?.LogInformation("Query Question");
                var dbQuestionCategory = mapper.Map<Models.QuestionCategory, Db.QuestionCategory>(QuestionCategory);
                // Question.QuestionType = GetQuestionType(Question.QuestionTypeId);
                questionDbContext.QuestionCategories.Add(dbQuestionCategory);
                questionDbContext.SaveChanges();
                QuestionCategory.Id = dbQuestionCategory.Id;
                return (true, QuestionCategory, null);
            }
            catch (Exception ex)
            {
                logger?.LogError(ex.ToString());
                return (false, null, ex.Message);
            }
        }
        public async Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> UpdateQuestionCategoryAsync(Models.QuestionCategory QuestionCategory)
        {
            try
            {
                var dbQuestionCategory = mapper.Map<Models.QuestionCategory, Db.QuestionCategory>(QuestionCategory);
                questionDbContext.Entry(dbQuestionCategory).State = EntityState.Modified;

                questionDbContext.SaveChanges();
                return (true, QuestionCategory, null);
            }
            catch (Exception ex)
            {

                logger?.LogError(ex.ToString());
                return (false, null, ex.Message);
            }
        }
        public async Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> DeleteQuestionCategoryAsync(int Id)
        {
            try
            {
                var questioncategory = await questionDbContext.QuestionCategories.Where(x => x.Id == Id).FirstOrDefaultAsync();
                if (questioncategory != null)
                {
                    var question = await questionDbContext.Questions.Where(x => x.Id == Id).ToListAsync();
                    questionDbContext.Questions.RemoveRange(question);
                    questionDbContext.QuestionCategories.Remove(questioncategory);
                    questionDbContext.SaveChanges();
                    return (true, mapper.Map<Db.QuestionCategory, Models.QuestionCategory>(questioncategory), $"QuestionID {Id} deleted Successfuly");
                }
                else
                {
                    logger?.LogInformation($"QuestionID: {Id} Not found");
                    return (false, null, "Not Found");
                }
            }
            catch (Exception ex)
            {
                logger?.LogError(ex.ToString());
                return (false, null, ex.Message);
            }
        }
        private bool QuestionExists(int id)
        {
            return questionDbContext.Questions.AsNoTracking().Count(e => e.Id == id) > 0;
        }
        private QuestionType GetQuestionType(int Id)
        {
            return questionDbContext.QuestionTypes.Where(a => a.Id == Id).FirstOrDefault();
        }

        public async Task<(bool IsSuccess, QuestionType QuestionType, string ErrorMessage)> GetQuestionTypeAsync(int Id)
        {
            try
            {
                logger?.LogInformation("Query Question");
                var questiontype = await questionDbContext.QuestionTypes.FirstOrDefaultAsync(q => q.Id == Id);
                if (questiontype != null)
                {
                    logger?.LogInformation($"{questiontype} customer(s) found");
                    return (true, questiontype, null);
                }
                return (false, null, "Not found");
            }
            catch (Exception ex)
            {
                logger?.LogError(ex.ToString());
                return (false, null, ex.Message);
            }
        }

        public async Task<(bool IsSuccess, IEnumerable<QuestionType> QuestionTypes, string ErrorMessage)> GetQuestionTypesAsync()
        {
            try
            {
                logger?.LogInformation("Query Question");
                var questionTypes = await questionDbContext.QuestionTypes.ToListAsync();
                if (questionTypes != null)
                {
                    //logger?.LogInformation($"{question} customer(s) found");
                    return (true, questionTypes, null);
                }
                return (false, null, "Not found");
            }
            catch (Exception ex)
            {
                logger?.LogError(ex.ToString());
                return (false, null, ex.Message);
            }
        }
    }
}