using Microsoft.AspNetCore.Mvc;
using Diligent.WebAPI.Business.MongoServices;
using Diligent.WebAPI.Data.Entities;
using AutoMapper;
using Diligent.WebAPI.Host.Exceptions;
using Diligent.WebAPI.Host.MongoDTOs.InsuranceCompanyMongo;
using Diligent.WebAPI.Host.MongoDTOs.InsurancePolicyMongo;
using Diligent.WebAPI.Host.MongoDTOs.InsurerMongo;

namespace Diligent.WebAPI.Host.MongoControllers
{
    [ApiVersion("1.0")]
    [ApiController]
    [Route("v{version:apiVersion}/[controller]")]
    public class InsurancePolicyController : ControllerBase
    {
        private readonly InsurancePolicyService _insurancePolicyService;
        private readonly InsurerService _insurerService;
        private readonly InsuranceCompanyService _insuranceCompanyService;
        private readonly IMapper _mapper;

        public InsurancePolicyController(InsurancePolicyService insurancePolicyService, IMapper mapper, InsurerService insurerService, InsuranceCompanyService insuranceCompanyService)
        {
            _insurancePolicyService = insurancePolicyService;
            _mapper = mapper;
            _insurerService = insurerService;
            _insuranceCompanyService = insuranceCompanyService;
        }

        [HttpGet]
        public async Task<List<InsurancePolicyReturnDTO>> Get()
        {
            var insuranceCompanies = await _insurancePolicyService.GetAllAsync();
            return _mapper.Map<List<InsurancePolicyReturnDTO>>(insuranceCompanies);
        }


        [HttpGet("{id:length(24)}")]
        public async Task<ActionResult<InsurancePolicyReturnDTO>> Get(string id)
        {
            var insuranceCompany = await _insurancePolicyService.GetByIdAsync(id);

            if (insuranceCompany is null)
            {
                throw new NotFoundException("Policy not found");
            }

            var returnPolicy = _mapper.Map<InsurancePolicyReturnDTO>(insuranceCompany);

            if (returnPolicy.InsurerId != null)
            {
                var insurer = _mapper.Map<InsurerReturnDTO>(await _insurerService.GetByIdAsync(returnPolicy.InsurerId));
                returnPolicy.Insurer = insurer;
            }

            if (returnPolicy.InsuranceCompanyId != null)
            {
                var insuranceCompanyDTO = _mapper.Map<InsuranceCompanyReadDTO>(await _insuranceCompanyService.GetByIdAsync(returnPolicy.InsuranceCompanyId));
                returnPolicy.InsuranceCompany = insuranceCompanyDTO;
            }

            return returnPolicy;
        }

        [HttpPost]
        public async Task<ActionResult> Post(InsurancePolicySaveDTO insurancePolicyCreateDTO)
        {
            var insurancePolicy = _mapper.Map<InsurancePolicyMongo>(insurancePolicyCreateDTO);
            await _insurancePolicyService.CreateInsurancePolicy(insurancePolicy);

            var returnPolicy = _mapper.Map<InsurancePolicyReturnDTO>(insurancePolicy);

            if (returnPolicy.InsurerId != null)
            {
                var insurer = _mapper.Map<InsurerReturnDTO>(await _insurerService.GetByIdAsync(returnPolicy.InsurerId));
                returnPolicy.Insurer = insurer;
            }

            if (returnPolicy.InsuranceCompanyId != null)
            {
                var insuranceCompanyDTO = _mapper.Map<InsuranceCompanyReadDTO>(await _insuranceCompanyService.GetByIdAsync(returnPolicy.InsuranceCompanyId));
                returnPolicy.InsuranceCompany = insuranceCompanyDTO;
            }

            return CreatedAtAction(nameof(Get), new { id = returnPolicy.Id }, returnPolicy);
        }

        [HttpPut("{id:length(24)}")]
        public async Task<ActionResult> Update(string id, InsurancePolicyMongo updatedBook)
        {
            var insuranceCompany = await _insurancePolicyService.GetByIdAsync(id);

            if (insuranceCompany is null)
            {
                throw new NotFoundException("Policy not found");
            }

            updatedBook.Id = insuranceCompany.Id;

            await _insurancePolicyService.UpdateInsurancePolicy(id, updatedBook);

            return Ok();
        }

        [HttpDelete("{id:length(24)}")]
        public async Task<ActionResult> Delete(string id)
        {
            var insuranceCompany = await _insurancePolicyService.GetByIdAsync(id);

            if (insuranceCompany is null)
            {
                throw new NotFoundException("Policy not found");
            }

            await _insurancePolicyService.DeleteInsurancePolicy(id);

            return Ok();
        }
    }
}