using Api.SeaHavenIndustries.DTOs;
using Data.SeaHavenIndustries;
using FluentValidation;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using SeaHaven.Services.Interfaces;
using SeaHaven.Services.DTOs;
using SeaHaven.DataServices.Interfaces;
using System.Security.Claims;

namespace Api.SeaHavenIndustries.Controllers
{
    [Authorize]
    [ApiController]
    [Route("api/[controller]")]
    [Route("api/locations")]
    public class LocationController : Controller
    {
        private readonly ILocationService _locationService;
        private readonly ILocationDataService _locationDataService; // Keep for direct entity operations

        public LocationController(ILocationService locationService, ILocationDataService locationDataService)
        {
            _locationService = locationService;
            _locationDataService = locationDataService;
        }

        [HttpGet("GetLocationList")]
        public async Task<IActionResult> GetLocationList(string? search = "", int page = 1, int pageSize = 10)
        {
            var pagedResult = await _locationService.GetLocationsPagedAsync(page, pageSize, search);

            var data = pagedResult.Items.Select(l => new
            {
                Id = l.Id,
                Name = l.Name,
                Title = l.Title,
                Address = l.Address1,
                Address1 = l.Address1,
                Address2 = l.Address2,
                City = l.City,
                State = l.State,
                ZipCode = l.Zip,
                Phone = l.PhoneNumber,
                Contact = (string?)null,
                ContactEmail = l.Email,
                Status = l.Status
            });

            var viewModel = new Pagination_DTO
            {
                Data = data,
                PageNumber = page,
                PageSize = pageSize,
                TotalCount = pagedResult.TotalCount,
                TotalPages = (int)Math.Ceiling(pagedResult.TotalCount / (double)pageSize)
            };

            return Ok(viewModel);
        }

        [HttpGet("{id}")]
        public async Task<IActionResult> GetLocationById(int id)
        {
            var location = await _locationDataService.GetByIdAsync(id);

            if (location == null)
                return NotFound(new Response { Status = "Error", Message = "Location not found" });

            var result = new
            {
                location.Id,
                location.Name,
                location.Title,
                Address = location.Address1,
                location.Address1,
                location.Address2,
                location.City,
                location.State,
                ZipCode = location.Zip,
                Phone = location.PhoneNumber,
                Contact = (string?)null,
                ContactEmail = location.Email,
                location.Status
            };

            return Ok(result);
        }

        [HttpPost]
        public async Task<IActionResult> AddLocation([FromBody] Location_DTO model)
        {
            try
            {
                var location = new Locations
                {
                    Name = model.Name,
                    Title = model.Title,
                    Address1 = model.Address,
                    City = model.City,
                    State = model.State,
                    Zip = model.ZipCode,
                    PhoneNumber = model.Phone,
                    Email = model.ContactEmail,
                    Status = model.Status,
                    CreatedDate = DateTime.Now
                };

                await _locationDataService.AddAsync(location);
                return Ok(new DataResponse { Message = "Location Created Successfully", Status = "200" });
            }
            catch (ValidationException vex)
            {
                var errors = string.Join(", ", vex.Errors.Select(e => e.ErrorMessage));
                return BadRequest(new Response { Status = "Validation Error", Message = errors });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new Response { Status = "Error", Message = ex.Message });
            }
        }

        [HttpPut("{id}")]
        public async Task<IActionResult> EditLocation(int id, [FromBody] EditLocation_DTO model)
        {
            try
            {
                var exist = await _locationDataService.GetByIdAsync(id);
                if (exist == null)
                    return NotFound(new Response { Status = "Error", Message = "Location not found" });

                exist.Name = model.Name;
                exist.Title = model.Title;
                exist.Address1 = model.Address;
                exist.City = model.City;
                exist.State = model.State;
                exist.Zip = model.ZipCode;
                exist.PhoneNumber = model.Phone;
                exist.Email = model.ContactEmail;
                exist.Status = model.Status;
                exist.LastModificationTime = DateTime.Now;

                await _locationDataService.UpdateAsync(exist);
                return Ok(new DataResponse { Message = "Location Updated Successfully", Status = "200" });
            }
            catch (ValidationException vex)
            {
                var errors = string.Join(", ", vex.Errors.Select(e => e.ErrorMessage));
                return BadRequest(new Response { Status = "Validation Error", Message = errors });
            }
            catch (KeyNotFoundException)
            {
                return NotFound(new Response { Status = "Error", Message = "Location not found" });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new Response { Status = "Error", Message = ex.Message });
            }
        }

        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteLocation(int id)
        {
            try
            {
                var exist = await _locationDataService.GetByIdAsync(id);
                if (exist == null)
                    return NotFound(new Response { Status = "Error", Message = "Location not found" });

                await _locationDataService.DeleteAsync(id);
                return Ok(new DataResponse { Message = "Location Deleted Successfully", Status = "200" });
            }
            catch (KeyNotFoundException)
            {
                return NotFound(new Response { Status = "Error", Message = "Location not found" });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new Response { Status = "Error", Message = ex.Message });
            }
        }

        [HttpGet("DeleteLocation")]
        public async Task<IActionResult> DeleteLocationByQuery(int id)
        {
            return await DeleteLocation(id);
        }
    }
}