using System.Net;
using DTO;
using Entity;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Shared;

namespace WfApi.Controllers
{
    [ApiController]
    [Route("api/v1/character")] //Version API
    public class CharacterController : ControllerBase
    {
        private readonly ICharacterService<CharacterDTO> _character;

        private readonly ILogger<CharacterController> _logger;

        public CharacterController(ICharacterService<CharacterDTO> characterService, ILogger<CharacterController> logger)
        {
            _character = characterService;
            _logger = logger;

        }

        [HttpGet("{id}")] // Indiquer que l'id est dans l'URL
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<IActionResult> GetCharacter(int id)
        {
            try
            {
                try
                {
                    var character = await _character.GetCharById(id);
                    return Ok(character);
                }
                catch(KeyNotFoundException)
                {
                    return NotFound();
                }
            }
            catch (Exception)
            {
                return StatusCode((int)HttpStatusCode.InternalServerError, new { message = "Internal Server Error" });
            }
        }

        [HttpGet("all")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<IActionResult> GetAllSource(int index = 0, int count = 10)
        {
            try
            {
                var result = await _character.GetSomeChar(index, count);

                if (result != null)
                {
                    return await Task.FromResult<IActionResult>(Ok(result));
                }
                else
                {
                    return NoContent();
                }
            }
            catch (Exception)
            {
                return StatusCode((int)HttpStatusCode.InternalServerError, new { message = "Internal Server Error" });
            }
        }

        [HttpPost]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status409Conflict)]
        public async Task<IActionResult> CreateCharacter([FromBody] CharacterDTO newCharacter)
        {
            try
            {
                if (newCharacter == null)
                {
                    return BadRequest(new { message = "Character data is required." });
                }
                try
                {
                    var existingSource = await _character.GetCharById(newCharacter.Id);
                    return Conflict(new { message = "A character with this ID already exists." });
                }
                catch (KeyNotFoundException)
                {
                    await _character.AddCharacter(newCharacter);
                    return Ok(newCharacter);
                }
            }
            catch (Exception)
            {
                return StatusCode((int)HttpStatusCode.InternalServerError, new { message = "Internal Server Error" });
            }
        }

        [HttpPut()]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        [ProducesResponseType(StatusCodes.Status409Conflict)]
        public async Task<IActionResult> UpdateCharacter([FromQuery] int id, [FromBody] CharacterDTO updatedCharacter)
        {
            try
            {
                if (updatedCharacter == null)
                {
                    return BadRequest(new { message = "new character data is required." });
                }
                try
                {
                    var existChar = await _character.GetCharById(id);
                    var result = _character.UpdateCharacter(id, updatedCharacter);
                    return Ok(result);
                }
                catch(KeyNotFoundException)
                {
                    return Conflict(new { message = "A character with this ID already exists." });
                }
            }
            catch (Exception)
            {
                return StatusCode((int)HttpStatusCode.InternalServerError, new { message = "Internal Server Error" });
            }
        }
    }
}