using AutoMapper;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using REC_HUMA.CORE.DTOs;
using REC_HUMA.CORE.Entities;
using REC_HUMA.CORE.Interfaces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace REC_HUMA.API.Controllers
{
    
    [Route("api/[controller]")]
    [ApiController]
    public class HabilitadoController : ControllerBase
    {
        private readonly IHabilitadoRepo _HabilitadoRepo;
        private readonly IMapper _mapper;
        private readonly ILogger<HabilitadoController> _logger;

        public HabilitadoController(IHabilitadoRepo HabilitadoRepo, IMapper mapper, ILogger<HabilitadoController> logger)
        {
            _HabilitadoRepo = HabilitadoRepo;
            _mapper = mapper;
            _logger = logger;
        }
      
        [HttpGet]
        public async Task<IEnumerable<HabilitadoDto>> GetHabilitados()
        {
            try
            {
                var habilitados = await _HabilitadoRepo.GetHabilitados();
                var habilitadoDto = _mapper.Map<IEnumerable<HabilitadoDto>>(habilitados);
                return habilitadoDto;
            }
            catch (Exception ex)
            {
                var habilitadoDTO = new List<HabilitadoDto>
                {
                    new HabilitadoDto() { CodResultado = 500, Mensaje = "Error" }
                };
                _logger.LogError(ex, ex.Message);
                return habilitadoDTO;
            }
        }
      
        [HttpGet("{id}")]
        public async Task<HabilitadoDto> GetHabilitado(int id)
        {
            try
            {
                var habilitados = await _HabilitadoRepo.GetHabilitado(id);
                var habilitadoDto = _mapper.Map<HabilitadoDto>(habilitados);
                return habilitadoDto;
            }
            catch (Exception ex)
            {
                var habilitadoDTO = new HabilitadoDto
                {
                    CodResultado = 500,
                    Mensaje = "Error"
                };
                _logger.LogError(ex, ex.Message);
                return habilitadoDTO;
            }
        }
     
        [HttpPut]
        public async Task<IActionResult> PutHabilitado(HabilitadoDto habilitadoDto)
        {
            try
            {
                var habilitado = _mapper.Map<Habilitado>(habilitadoDto);
                await _HabilitadoRepo.PutHabilitado(habilitado);
                return Ok();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                return StatusCode(500);

            }
        }
     
        [HttpPost]
        public async Task<IActionResult> PostHabilitado(HabilitadoDto habilitadoDto)
        {
            try
            {
                var habilitado = _mapper.Map<Habilitado>(habilitadoDto);
                await _HabilitadoRepo.PostHabilitado(habilitado);
                return Ok();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                return StatusCode(500);
            }
        }
      
        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteHabilitado(int id)
        {
            try
            {
                await _HabilitadoRepo.DeleteHabilitado(id);
                return Ok();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                return StatusCode(500);
            }
        }
    }
}