DamageAssessment_Backend/DamageAssesmentApi/DamageAssesment.Api.Answers/Controllers/AnswersController.cs

using DamageAssesment.Api.Answers.Interfaces;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.OpenApi.Any;

namespace DamageAssesment.Api.Answers.Controllers
{
    [ApiController]
    public class AnswersController: ControllerBase
    {
        private IAnswersProvider answerProvider;

        public AnswersController(IAnswersProvider answersProvider) { 
        this.answerProvider=answersProvider;
        }
        /// <summary>
        /// Get all answers
        /// </summary>
        
        [HttpGet("answers")]
        public async Task<ActionResult> GetAnswersAsync() {
        
            var result = await answerProvider.GetAnswersAsync();
           if(result.IsSuccess)
            {
                return Ok(result.Answers);
            }
               return NoContent();

        }
        /// <summary>
        /// Get an answer based on answerId.
        /// </summary>


        [HttpGet("answers/{id}")]
        public async Task<ActionResult> GetAnswerByIdAsync(int id)
        {

            var result = await answerProvider.GetAnswerByIdAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.Answer);
            }
            return NotFound();

        }
        /// <summary>
        /// Get all answers based on responseId.
        /// </summary>
        [HttpGet("answers/byresponse/{responseid}")]
        public async Task<IActionResult> GetAnswersByResponseId(int responseid)
        {
            var result = await this.answerProvider.GetAnswersAsync(responseid);
            if(result.IsSuccess)
            {
                return Ok(result.Answers);
            }
            return NoContent();
        }
        /// <summary>
        /// Get all answers based on questionId.
        /// </summary>

        [HttpGet("answers/byquestion/{questionid}")]
        public async Task<IActionResult> AnswersByQuestionId(int questionid)
        {
            var result = await this.answerProvider.GetAnswersByQuestionAsync(questionid);
            if (result.IsSuccess)
            {
                return Ok(result.Answers);
            }
            return NotFound();
        }
        /// <summary>
        /// Update an existing answer.
        /// </summary>

        [HttpPut("answers")]
        public async Task<IActionResult> UpdateAnswer(Models.Answer answer)
        {
            if (answer != null)
            {
                var result = await this.answerProvider.UpdateAnswerAsync(answer);
                if (result.IsSuccess)
                {
                    return Ok(result.Answer);
                }
                if (result.ErrorMessage == "Not Found")
                    return NotFound(result.ErrorMessage);

                return BadRequest(result.ErrorMessage);
            }
            return NotFound();
        }
        /// <summary>
        /// Save a new answer.
        /// </summary>

        [HttpPost("answers")]
        public async Task<IActionResult> CreateAnswer(Models.Answer answer)
        {
            if (answer != null)
            {
                var result =  await this.answerProvider.PostAnswerAsync(answer);
                if (result.IsSuccess)
                {
                    return Ok(result.Answer);
                }
                return BadRequest(result.ErrorMessage);
            }
            return CreatedAtRoute("DefaultApi", new { id = answer.Id }, answer);
        }
        /// <summary>
        ///  Delete an existing answer.
        /// </summary>

        [HttpDelete("answers/{id}")]
        public async Task<IActionResult> DeleteAnswer(int id)
        {
            var result = await this.answerProvider.DeleteAnswerAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.Answer);
            }
            return NotFound();
        }

    }
}