using System;
using System.Threading.Tasks;
using LCU.Shared.Collections.RepoApiLib.Models.Settings;
using LCU.API.Collections.RepoApi.Services;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using LCU.API.Collections.RepoApi.Configuration;
using LCU.API.Collections.RepoApi.Extensions;
using Microsoft.FeatureManagement.Mvc;
using Serilog;

namespace LCU.API.Collections.RepoApi.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    [FeatureGate(FeatureFlags.EnableControllers)]
    public class SettingsController : RepoControllerBase
    {
        private readonly ISettingsService _settingsService;

        public SettingsController(
            ISettingsService settingsService,
            IHttpContextAccessor httpContextAccessor) : base(httpContextAccessor)
        {
            _settingsService = settingsService;
        }

        // GET: api/Settings
        [HttpGet]
        [ProducesResponseType(typeof(Settings), 200)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> Get()
        {
            try
            {
                var results = await _settingsService.ListAllSettingsAsync();
                return Ok(results);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        // PUT: api/Settings/[method]
        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AccountType), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PutAccountType([FromBody] AccountType accountType)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.UpdateAsync(accountType);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AllowedStatusChange), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PutAllowedStatusChange([FromBody] AllowedStatusChange statusChange)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.UpdateAsync(statusChange);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AllowedStatusChange), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PutBodyStyle([FromBody] BodyStyle bodyStyle)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.UpdateAsync(bodyStyle);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AllowedStatusChange), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PutCleaningLevel([FromBody] CleaningLevel cleaningLevel)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.UpdateAsync(cleaningLevel);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AllowedStatusChange), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PutCollateralType([FromBody] CollateralType collateralType)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.UpdateAsync(collateralType);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AllowedStatusChange), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PutCollateralTypeToVehicleType(
            [FromBody] CollateralTypeToVehicleType collateralToVehicle)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.UpdateAsync(collateralToVehicle);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AllowedStatusChange), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PutHoldStatus([FromBody] HoldStatus holdStatus)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.UpdateAsync(holdStatus);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AllowedStatusChange), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PutLoanCategory([FromBody] LoanCategory loanCategory)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.UpdateAsync(loanCategory);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AllowedStatusChange), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PutLocationType([FromBody] LocationType locationType)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.UpdateAsync(locationType);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AllowedStatusChange), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PutVehicleType([FromBody] VehicleType vehicleType)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.UpdateAsync(vehicleType);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        // POST: api/Settings/[method]
        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AccountType), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PostAccountType([FromBody] AccountType accountType)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.SaveAsync(accountType);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AccountType), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PostAllowedStatusChange([FromBody] AllowedStatusChange statusChange)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.SaveAsync(statusChange);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AccountType), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PostBodyStyle([FromBody] BodyStyle bodyStyle)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.SaveAsync(bodyStyle);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AccountType), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PostCleaningLevel([FromBody] CleaningLevel cleaningLevel)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.SaveAsync(cleaningLevel);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AccountType), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PostCollateralType([FromBody] CollateralType collateralType)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.SaveAsync(collateralType);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AccountType), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PostCollateralTypeToVehicleType(
            [FromBody] CollateralTypeToVehicleType collateralToVehicle)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.SaveAsync(collateralToVehicle);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AccountType), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PostHoldStatus([FromBody] HoldStatus holdStatus)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.SaveAsync(holdStatus);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AccountType), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PostLoanCategory([FromBody] LoanCategory loanCategory)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.SaveAsync(loanCategory);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AccountType), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PostLocationType([FromBody] LocationType locationType)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.SaveAsync(locationType);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost]
        [Route("[action]")]
        [ProducesResponseType(typeof(AccountType), 201)]
        [ProducesResponseType(typeof(List<string>), 400)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> PostVehicleType([FromBody] VehicleType vehicleType)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState.GetErrorMessages());
                }

                var result = await _settingsService.SaveAsync(vehicleType);
                return Ok(result);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure in {GetType().Name} at {GetInvokerAsyncMethodName()}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }
    }
}