shoc-backend/SeaHaven.Services/Implementation/PMScheduleService.cs

using Data.SeaHavenIndustries;
using SeaHaven.DataServices.Interfaces;
using SeaHaven.Services.DTOs;
using SeaHaven.Services.Interfaces;

namespace SeaHaven.Services.Implementation
{
    /// <summary>
    /// PM Schedule service implementation
    /// Contains business logic, validation, and orchestration for PM Schedule operations
    /// </summary>
    public class PMScheduleService : IPMScheduleService
    {
        private readonly IPMScheduleDataService _pmScheduleDataService;

        public PMScheduleService(IPMScheduleDataService pmScheduleDataService)
        {
            _pmScheduleDataService = pmScheduleDataService;
        }

        public async Task<PMScheduleDTO?> GetPMScheduleByIdAsync(int id)
        {
            var pmSchedule = await _pmScheduleDataService.GetByIdAsync(id);
            return pmSchedule == null ? null : MapToDTO(pmSchedule);
        }

        public async Task<PMScheduleDTO?> GetPMScheduleByIdWithDetailsAsync(int id)
        {
            var pmSchedule = await _pmScheduleDataService.GetByIdWithDetailsAsync(id);
            return pmSchedule == null ? null : MapToDTO(pmSchedule);
        }

        public async Task<IEnumerable<PMScheduleDTO>> GetAllPMSchedulesAsync()
        {
            var pmSchedules = await _pmScheduleDataService.GetAllWithDetailsAsync();
            return pmSchedules.Select(MapToDTO);
        }

        public async Task<IEnumerable<PMScheduleDTO>> GetPMSchedulesByLocationIdAsync(int locationId)
        {
            var pmSchedules = await _pmScheduleDataService.GetAllWithDetailsAsync();
            return pmSchedules.Where(p => p.LocationId == locationId).Select(MapToDTO);
        }

        public async Task<PagedResult<PMScheduleDTO>> GetPMSchedulesPagedAsync(int page, int pageSize, string? search = null)
        {
            var (items, totalCount) = await _pmScheduleDataService.GetPagedAsync(page, pageSize, search);
            return new PagedResult<PMScheduleDTO>
            {
                Items = items.Select(MapToDTO).ToList(),
                TotalCount = totalCount,
                Page = page,
                PageSize = pageSize
            };
        }

        public async Task<PMScheduleDTO> CreatePMScheduleAsync(CreatePMScheduleDTO dto, string userId)
        {
            var pmSchedule = new PMSchedules
            {
                Name = dto.Name,
                Frequency = dto.Frequency,
                StartDate = dto.StartDate,
                IsActive = dto.IsActive,
                AssetId = dto.AssetId,
                LocationId = dto.LocationId,
                CreatedDate = DateTime.UtcNow,
                createdby = userId
            };

            var created = await _pmScheduleDataService.AddAsync(pmSchedule);
            return MapToDTO(created);
        }

        public async Task<PMScheduleDTO> UpdatePMScheduleAsync(int id, UpdatePMScheduleDTO dto, string userId)
        {
            var pmSchedule = await _pmScheduleDataService.GetByIdAsync(id);
            if (pmSchedule == null)
                throw new InvalidOperationException($"PM Schedule with ID {id} not found");

            if (dto.Name != null) pmSchedule.Name = dto.Name;
            if (dto.Frequency != null) pmSchedule.Frequency = dto.Frequency;
            if (dto.StartDate.HasValue) pmSchedule.StartDate = dto.StartDate.Value;
            if (dto.IsActive.HasValue) pmSchedule.IsActive = dto.IsActive.Value;
            if (dto.AssetId.HasValue) pmSchedule.AssetId = dto.AssetId;
            if (dto.LocationId.HasValue) pmSchedule.LocationId = dto.LocationId;

            pmSchedule.LastModificationTime = DateTime.UtcNow;
            if (int.TryParse(userId, out int userIdInt))
                pmSchedule.LastModifierUserId = userIdInt;

            await _pmScheduleDataService.UpdateAsync(pmSchedule);
            return MapToDTO(pmSchedule);
        }

        public async Task DeletePMScheduleAsync(int id, string userId)
        {
            var pmSchedule = await _pmScheduleDataService.GetByIdAsync(id);
            if (pmSchedule == null)
                throw new InvalidOperationException($"PM Schedule with ID {id} not found");

            pmSchedule.IsDeleted = true;
            pmSchedule.DeleterUserId = userId;
            pmSchedule.DeletionTime = DateTime.UtcNow;

            await _pmScheduleDataService.UpdateAsync(pmSchedule);
        }

        public async Task<bool> PMScheduleExistsAsync(int id)
        {
            return await _pmScheduleDataService.ExistsAsync(id);
        }

        public async Task<int> GetTotalPMScheduleCountAsync()
        {
            return await _pmScheduleDataService.CountAsync();
        }

        private PMScheduleDTO MapToDTO(PMSchedules pmSchedule)
        {
            return new PMScheduleDTO
            {
                Id = pmSchedule.Id,
                Name = pmSchedule.Name,
                Frequency = pmSchedule.Frequency,
                StartDate = pmSchedule.StartDate,
                IsActive = pmSchedule.IsActive,
                AssetId = pmSchedule.AssetId,
                AssetName = pmSchedule.Asset?.Name,
                LocationId = pmSchedule.LocationId,
                LocationName = pmSchedule.Location?.Name,
                CreatedDate = pmSchedule.CreatedDate
            };
        }
    }
}