using Api.SeaHavenIndustries.DTOs;
using Api.SeaHavenIndustries.Helper;
using Data.SeaHavenIndustries;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using SeaHaven.Services.DTOs;
using SeaHaven.Services.Interfaces;

namespace Api.SeaHavenIndustries.Controllers
{
    [Authorize]
    [ApiController]
    [Route("api/Calendar")]
    public class CalendarController : Controller
    {
        private readonly ICalendarService _calendarService;
        private readonly ILogger<CalendarController> _logger;

        public CalendarController(ICalendarService calendarService, ILogger<CalendarController> logger)
        {
            _calendarService = calendarService;
            _logger = logger;
        }

        // ===================================================================================
        // CREATE EVENT
        // ===================================================================================
        [HttpPost]
        [Route("AddEvent")]
        public async Task<IActionResult> AddEvent(EditEvent_DTO eventDto, CancellationToken cancellationToken)
        {
            try
            {
                await _calendarService.CreateEventAsync(MapToInput(eventDto), cancellationToken);

                return Ok(new DataResponse { Message = "Event Created Successfully", Status = "200" });
            }
            catch (Exception ex)
            {
                return BadRequest(new Response { Status = "Error", Message = _logger.Sanitize(ex) });
            }
        }

        // ===================================================================================
        // UPDATE EVENT
        // ===================================================================================
        [HttpPost]
        [Route("EditEvent")]
        public async Task<IActionResult> EditEvent(EditEvent_DTO eventDto, CancellationToken cancellationToken)
        {
            try
            {
                if (!eventDto.Id.HasValue)
                {
                    return BadRequest(new Response { Status = "Error", Message = "Event ID is required for editing" });
                }

                var updated = await _calendarService.UpdateEventAsync(MapToInput(eventDto), cancellationToken);
                if (!updated)
                {
                    return NotFound(new Response { Status = "Error", Message = "Event not found" });
                }

                return Ok(new DataResponse { Message = "Event Updated Successfully", Status = "200" });
            }
            catch (Exception ex)
            {
                return BadRequest(new Response { Status = "Error", Message = _logger.Sanitize(ex) });
            }
        }

        // ===================================================================================
        // GET EVENT BY ID
        // ===================================================================================
        [HttpGet]
        [Route("GetEventById/{id}")]
        public async Task<IActionResult> GetEventById(int id, CancellationToken cancellationToken)
        {
            try
            {
                var dto = await _calendarService.GetEventByIdAsync(id, cancellationToken);

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

                return Ok(new DataResponse { Message = "Success", Status = "200", Data = MapToResponse(dto) });
            }
            catch (Exception ex)
            {
                return BadRequest(new Response { Status = "Error", Message = _logger.Sanitize(ex) });
            }
        }

        // ===================================================================================
        // DELETE EVENT
        // ===================================================================================
        [HttpDelete]
        [Route("DeleteEvent/{id}")]
        public async Task<IActionResult> DeleteEvent(int id, CancellationToken cancellationToken)
        {
            try
            {
                var deleted = await _calendarService.DeleteEventAsync(id, cancellationToken);
                if (!deleted)
                {
                    return NotFound(new Response { Status = "Error", Message = "Event not found" });
                }

                return Ok(new DataResponse { Message = "Event Deleted Successfully", Status = "200" });
            }
            catch (Exception ex)
            {
                return BadRequest(new Response { Status = "Error", Message = _logger.Sanitize(ex) });
            }
        }

        // ===================================================================================
        // GET EVENTS LIST (WITH PAGINATION AND FILTERS)
        // ===================================================================================
        [HttpGet]
        [Route("GetEventList")]
        public async Task<IActionResult> GetEventList(string? search = "", int page = 1, int pageSize = 10, CancellationToken cancellationToken = default)
        {
            try
            {
                var result = await _calendarService.GetEventListAsync(search, page, pageSize, cancellationToken);

                var events = result.Rows.Select(MapToResponse).ToList();

                return Ok(new DataResponse
                {
                    Message = "Success",
                    Status = "200",
                    Data = new { rows = events, totalCount = result.TotalCount }
                });
            }
            catch (Exception ex)
            {
                return BadRequest(new Response { Status = "Error", Message = _logger.Sanitize(ex) });
            }
        }

        // ===================================================================================
        // GET EVENTS FOR CALENDAR (Date Range Filter)
        // ===================================================================================
        [HttpGet]
        [Route("GetEventsForCalendar")]
        public async Task<IActionResult> GetEventsForCalendar([FromQuery] DateTime? start, [FromQuery] DateTime? end, CancellationToken cancellationToken)
        {
            try
            {
                var events = await _calendarService.GetEventsForCalendarAsync(start, end, cancellationToken);

                return Ok(new DataResponse { Message = "Success", Status = "200", Data = events.Select(MapToResponse).ToList() });
            }
            catch (Exception ex)
            {
                return BadRequest(new Response { Status = "Error", Message = _logger.Sanitize(ex) });
            }
        }

        private static EditEventInput MapToInput(EditEvent_DTO eventDto)
        {
            return new EditEventInput
            {
                Id = eventDto.Id,
                Title = eventDto.Title,
                Description = eventDto.Description,
                Location = eventDto.Location,
                RecordID = eventDto.RecordID,
                RecordName = eventDto.RecordName,
                RecordTargetType = eventDto.RecordTargetType,
                ReminderMinutes = eventDto.ReminderMinutes,
                EventColor = eventDto.EventColor,
                StartDate = eventDto.StartDate,
                StartTime = eventDto.StartTime,
                EndDate = eventDto.EndDate,
                EndTime = eventDto.EndTime,
                AllDay = eventDto.AllDay
            };
        }

        private static Event_DTO MapToResponse(EventDTO dto)
        {
            return new Event_DTO
            {
                Id = dto.Id,
                Title = dto.Title,
                Description = dto.Description,
                Location = dto.Location,
                RecordID = dto.RecordID,
                RecordName = dto.RecordName,
                RecordTargetType = dto.RecordTargetType,
                ReminderMinutes = dto.ReminderMinutes,
                EventColor = dto.EventColor,
                StartDate = dto.StartDate,
                StartTime = dto.StartTime,
                EndDate = dto.EndDate,
                EndTime = dto.EndTime,
                AllDay = dto.AllDay,
                CreatedDate = dto.CreatedDate,
                createdby = dto.createdby
            };
        }
    }
}