using DamageAssesment.Api.Questions.Db;
using DamageAssesment.Api.Questions.Interfaces;
using DamageAssesment.Api.Questions.Models;
using DamageAssesment.Api.Questions.Providers;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace DamageAssesment.Api.Questions.Controllers
{
    [Route("api")]
    [ApiController]
    public class QuestionsController : ControllerBase
    {
        private readonly IQuestionsProvider questionsProvider;

        public QuestionsController(IQuestionsProvider questionsProvider)
        {

            this.questionsProvider = questionsProvider;

        }
        /// <summary>
        /// GET request for retrieving questions.
        /// </summary>

        [HttpGet("Questions")]
        public async Task<IActionResult> GetQuestionsAsync()
        {
            var result = await this.questionsProvider.GetQuestionsAsync();
            if (result.IsSuccess)
            {
                return Ok(result.Questions);
            }
            return NoContent();
        }
        /// <summary>
        /// GET request for retrieving a question by ID.
        /// </summary>

        [HttpGet("Questions/{id}")]
        public async Task<IActionResult> GetQuestionAsync(int id)
        {
            var result = await this.questionsProvider.GetQuestionAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.Question);
            }
            return NotFound();
        }
        /// <summary>
        /// GET request for retrieving survey questions based on a survey ID.
        /// Uri: {Optional language}/GetSurveyQuestions/{surveyId} :Default returns question in all languages 
        /// </summary>

        [HttpGet("GetSurveyQuestions/{surveyId}")]
        public async Task<IActionResult> GetSurveyQuestions(int surveyId,string? Language)
        {
            if (string.IsNullOrEmpty(Language)) Language = "en";
            var result = await this.questionsProvider.GetSurveyQuestionAsync(surveyId, Language);
            if (result.IsSuccess)
            {
                return Ok(result.SurveyQuestions);
            }
            return NotFound();
        }
        /// <summary>
        /// PUT request for updating a question (multilingual).
        /// </summary>

        [HttpPut("Questions")]
        public async Task<IActionResult> UpdateQuestion(Models.Question question)
        {
            if (question != null)
            {
                var result = await this.questionsProvider.UpdateQuestionAsync(question);
                if (result.IsSuccess)
                {
                    return Ok(result.Question);
                }
                if (result.ErrorMessage == "Not Found")
                    return NotFound(result.ErrorMessage);

                return BadRequest(result.ErrorMessage);
            }
            return CreatedAtRoute("DefaultApi", new { id = question.Id }, question);
        }
        /// <summary>
        /// POST request for creating a new question (multilingual).
        /// </summary>

        [HttpPost("Questions")]
        public async Task<IActionResult> CreateQuestion(Models.Question question)
        {
            if (question != null)
            {
                var result = await this.questionsProvider.PostQuestionAsync(question);
                if (result.IsSuccess)
                {
                    return Ok(result.Question);
                }
                return BadRequest(result.ErrorMessage);
            }
            return CreatedAtRoute("DefaultApi", new { id = question.Id }, question);
        }
        /// <summary>
        /// DELETE request for deleting a question based on ID.
        /// </summary>

        [HttpDelete("Questions/{id}")]
        public async Task<IActionResult> DeleteQuestion(int id)
        {
            var result = await this.questionsProvider.DeleteQuestionAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.Question);
            }
            return NotFound();
        }


        /// <summary>
        /// GET request for retrieving question categories.
        /// </summary>

        [HttpGet("QuestionCategories")]
        public async Task<IActionResult> GetQuestionCategoriesAsync()
        {
            var result = await this.questionsProvider.GetQuestionCategoriesAsync();
            if (result.IsSuccess)
            {
                return Ok(result.QuestionCategories);
            }
            return NoContent();
        }
        /// <summary>
        /// GET request for retrieving a question category by ID.
        /// </summary>

        [HttpGet("QuestionCategories/{id}")]
        public async Task<IActionResult> GetQuestionCategoryAsync(int id)
        {
            var result = await this.questionsProvider.GetQuestionCategoryAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.QuestionCategory);
            }
            return NotFound();
        }


        /// <summary>
        /// PUT request for updating a question category.
        /// </summary>

        [HttpPut("QuestionCategories")]
        public async Task<IActionResult> UpdateQuestionCategory(Models.QuestionCategory questionCategory)
        {
            if (questionCategory != null)
            {
                var result = await this.questionsProvider.UpdateQuestionCategoryAsync(questionCategory);
                if (result.IsSuccess)
                {
                    return Ok(result.QuestionCategory);
                }
                if (result.ErrorMessage == "Not Found")
                    return NotFound(result.ErrorMessage);

                return BadRequest(result.ErrorMessage);
            }
            return CreatedAtRoute("DefaultApi", new { id = questionCategory.Id }, questionCategory);
        }
        /// <summary>
        /// POST request for creating a new question category.
        /// </summary>

        [HttpPost("QuestionCategories")]
        public async Task<IActionResult> CreateQuestionCategory(Models.QuestionCategory questionCategory)
        {
            if (questionCategory != null)
            {
                var result = await this.questionsProvider.PostQuestionCategoryAsync(questionCategory);
                if (result.IsSuccess)
                {
                    return Ok(result.QuestionCategory);
                }
                return BadRequest(result.ErrorMessage);
            }
            return CreatedAtRoute("DefaultApi", new { id = questionCategory.Id }, questionCategory);
        }
        /// <summary>
        /// DELETE request for deleting a question category based on ID.
        /// </summary>

        [HttpDelete("QuestionCategories/{id}")]
        public async Task<IActionResult> DeleteQuestionCategory(int id)
        {
            var result = await this.questionsProvider.DeleteQuestionCategoryAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.QuestionCategory);
            }
            return NotFound();
        }
    }
}