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

namespace SeaHaven.Services.Implementation
{
    public class TaskListTemplateService : ITaskListTemplateService
    {
        private readonly ITaskListTemplateDataService _dataService;

        public TaskListTemplateService(ITaskListTemplateDataService dataService)
        {
            _dataService = dataService;
        }

        public async Task<IEnumerable<TaskListTemplateDTO>> GetAllAsync(CancellationToken cancellationToken)
        {
            var templates = await _dataService.GetActiveTemplatesWithItemsAsync(cancellationToken);
            return templates.Select(MapToDTO);
        }

        public async Task<TaskListTemplateDTO?> GetByIdAsync(int id, CancellationToken cancellationToken)
        {
            var template = await _dataService.GetTemplateWithItemsReadOnlyAsync(id, cancellationToken);
            return template == null ? null : MapToDTO(template);
        }

        public async Task<int> CreateAsync(TaskListTemplateInput input, CancellationToken cancellationToken)
        {
            var template = new TaskListTemplate
            {
                Name = input.Name,
                Description = input.Description,
                IsActive = input.IsActive,
                Items = input.Items.Select((item, idx) => new TaskListTemplateItem
                {
                    ItemText = item.ItemText,
                    SortOrder = item.SortOrder > 0 ? item.SortOrder : idx
                }).ToList()
            };

            var created = await _dataService.AddTemplateAsync(template, cancellationToken);
            return created.Id;
        }

        public async Task<bool> UpdateAsync(int id, TaskListTemplateInput input, CancellationToken cancellationToken)
        {
            var template = await _dataService.GetTemplateWithItemsForUpdateAsync(id, cancellationToken);
            if (template == null)
                return false;

            template.Name = input.Name;
            template.Description = input.Description;
            template.IsActive = input.IsActive;

            var newItems = input.Items.Select((item, idx) => new TaskListTemplateItem
            {
                TaskListTemplateId = id,
                ItemText = item.ItemText,
                SortOrder = item.SortOrder > 0 ? item.SortOrder : idx
            }).ToList();

            await _dataService.ReplaceTemplateItemsAsync(template, newItems, cancellationToken);
            return true;
        }

        public async Task<bool> DeleteAsync(int id, CancellationToken cancellationToken)
        {
            return await _dataService.DeactivateTemplateAsync(id, cancellationToken);
        }

        private static TaskListTemplateDTO MapToDTO(TaskListTemplate template)
        {
            return new TaskListTemplateDTO
            {
                Id = template.Id,
                Name = template.Name,
                Description = template.Description,
                IsActive = template.IsActive,
                Items = (template.Items ?? new List<TaskListTemplateItem>())
                    .OrderBy(i => i.SortOrder)
                    .Select(i => new TaskListTemplateItemDTO
                    {
                        Id = i.Id,
                        ItemText = i.ItemText,
                        SortOrder = i.SortOrder
                    }).ToList()
            };
        }
    }
}