using DamageAssesment.Api.SurveyResponses.Interfaces;
using DamageAssesment.Api.SurveyResponses.Models;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;

namespace DamageAssesment.Api.SurveyResponses.Controllers
{
    [ApiController]
    public class SurveyResponsesController : ControllerBase
    {
        private readonly ISurveysResponse surveyResponseProvider;

        public SurveyResponsesController(ISurveysResponse surveyResponseProvider)
        {
            this.surveyResponseProvider = surveyResponseProvider;
        }
        /// <summary>
        /// GET request for retrieving survey responses.
        /// </summary>

        [HttpGet("Responses")]
        public async Task<ActionResult> GetSurveyResponsesAsync()
        {
            var result = await this.surveyResponseProvider.GetSurveyResponsesAsync();
            if (result.IsSuccess)
            {
                return Ok(result.surveyResponses);
            }

            if (result.ErrorMessage == "No Data Found")
                return NoContent();

            return BadRequest(result.ErrorMessage);
        }
        /// <summary>
        /// GET request for retrieving survey responses by survey ID.
        /// </summary>
       
        [HttpGet("Responses/BySurvey/{surveyid}")]
        public async Task<ActionResult> GetSurveyResponsesAsync(int surveyid)
        {
            var result = await this.surveyResponseProvider.GetSurveyResponsesBySurveyAsync(surveyid);
            if (result.IsSuccess)
            {
                return Ok(result.SurveyResponses);
            }
            return NoContent();
        }
        /// <summary>
        /// GET request for retrieving survey responses by survey and location IDs.
        /// </summary>
        /// <param name="surveyid">The ID of the survey for which responses are to be retrieved.</param>
        /// <param name="locationid">The ID of the location for which responses are to be retrieved.</param>

        [HttpGet("Responses/{surveyid}/{locationid}")]
        public async Task<ActionResult> GetSurveyResponsesBySurveyAndLocationAsync(int surveyid, int locationid)
        {
            var result = await this.surveyResponseProvider.GetSurveyResponsesBySurveyAndLocationAsync(surveyid, locationid);
            if (result.IsSuccess)
            {
                return Ok(result.SurveyResponses);
            }

            return NoContent();
        }
        /// <summary>
        /// GET request for retrieving survey responses by survey, question, and answer.
        /// </summary>
        /// <param name="surveyId">The ID of the survey for which responses are to be retrieved.</param>
        /// <param name="questionId">The ID of the question for which responses are to be retrieved.</param>
        /// <param name="answer">The answer for which responses are to be retrieved.</param>

        [HttpGet("Responses/ByAnswer/{surveyid}/{questionid}/{answer}")]
        public async Task<ActionResult> GetSurveyResponsesByAnswerAsyncAsync(int surveyid, int questionid, string answer)
        {       
            var result = await surveyResponseProvider.GetResponsesByAnswerAsync(surveyid, questionid, answer);
            if (result.IsSuccess)
            {
                return Ok(result.SurveyResponses);
            }

            return NoContent();
        }
        /// <summary>
        /// GET request for retrieving answers from survey responses by survey ID and region.
        /// </summary>
        /// <param name="surveyId">The ID of the survey for which answers are to be retrieved.</param>

        [HttpGet("Responses/ByRegion/{surveyid}")]
        public async Task<ActionResult> GetAnswersByRegionAsync(int surveyid)
        {
            var result = await this.surveyResponseProvider.GetAnswersByRegionAsync(surveyid);
            if (result.IsSuccess)
            {
                return Ok(result.Answers);
            }
            return NoContent();
        }
        /// <summary>
        /// GET request for retrieving survey responses by survey ID and maintenance center.
        /// </summary>
        /// <param name="surveyId">The ID of the survey for which responses are to be retrieved.</param>

        [HttpGet("Responses/ByMaintenanceCenter/{surveyid}")]
        public async Task<ActionResult> GetAnswersByMaintenaceCentersync(int surveyid)
        {
            var result = await this.surveyResponseProvider.GetSurveyResponsesByMaintenanceCenterAsync(surveyid);
            if (result.IsSuccess)
            {
                return Ok(result.SurveyResponses);
            }
            return NoContent();
        }
        /// <summary>
        /// GET request for retrieving a survey response by response ID.
        /// </summary>
        /// <param name="responseId">The ID of the survey response to be retrieved.</param>

        [HttpGet("Responses/{id}")]
        public async Task<ActionResult> GetSurveyResponseByIdAsync(int id)
        {
            var result = await this.surveyResponseProvider.GetSurveyResponseByIdAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.SurveyResponse);
            }
            return NoContent();
        }

        /// <summary>
        /// POST request for creating a new survey response.
        /// </summary>
        /// <param name="surveyResponse">The survey response object to be created.</param>

        [HttpPost("Responses")]
        public async Task<ActionResult> PostSurveysAsync(Models.SurveyResponse surveyResponse)
        {
            var result = await this.surveyResponseProvider.PostSurveyResponseAsync(surveyResponse);
            if (result.IsSuccess)
            {
                return Ok(result.SurveyResponse);
            }
            return BadRequest(result.ErrorMessage);
        }
        /// <summary>
        /// PUT request for updating an existing survey response.
        /// </summary>
        /// <param name="Id">The ID of the survey response to be updated.</param>
        /// <param name="surveyResponse">The updated survey response object.</param>

        [HttpPut("Responses/{id}")]
        public async Task<ActionResult> PutSurveyResponseAsync(int id, Models.SurveyResponse surveyResponse)
        {
            var result = await this.surveyResponseProvider.PutSurveyResponseAsync(id, surveyResponse);
            if (result.IsSuccess)
            {
                return Ok(result.SurveyResponse);
            }
            if (result.ErrorMessage == "Not Found")
                return NotFound(result.ErrorMessage);

            return BadRequest(result.ErrorMessage);
        }
        /// <summary>
        /// DELETE request for deleting an existing survey response.
        /// </summary>
       
        [HttpDelete("Responses/{id}")]
        public async Task<ActionResult> DeleteSurveyResponseAsync(int id)
        {
            var result = await this.surveyResponseProvider.DeleteSurveyResponseAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.SurveyResponse);
            }
            return NotFound();
        }
        /// <summary>
        /// POST request for submitting survey with multiple answers.
        /// </summary>
        /// <param name="request">The answers to be submitted for the survey.</param>

        [HttpPost("Responses/Answers")]
        public async Task<ActionResult> PostSurveyAnswersAsync(Request request)
        {
            var result = await this.surveyResponseProvider.PostSurveyAnswersAsync(request);

            if (result.IsSuccess)
                return Ok(result.SurveyResponse);
            else
                return BadRequest(result.ErrorMessage);
        }
    }
}