using Data.SeaHavenIndustries;
using Microsoft.EntityFrameworkCore;
using SeaHaven.DataServices.Interfaces;

namespace SeaHaven.DataServices.Implementation
{
    public class TaskListTemplateDataService : ITaskListTemplateDataService
    {
        private readonly ApplicationDbContext _context;

        public TaskListTemplateDataService(ApplicationDbContext context)
        {
            _context = context;
        }

        public async Task<TaskListTemplate?> GetByIdAsync(int id)
        {
            return await _context.TaskListTemplates.FindAsync(id);
        }

        public async Task<TaskListTemplate?> GetByIdWithItemsAsync(int id)
        {
            return await _context.TaskListTemplates
                .Include(t => t.Items)
                .FirstOrDefaultAsync(t => t.Id == id);
        }

        public async Task<IEnumerable<TaskListTemplate>> GetAllAsync()
        {
            return await _context.TaskListTemplates.ToListAsync();
        }

        public async Task<TaskListTemplate> AddAsync(TaskListTemplate template)
        {
            await _context.TaskListTemplates.AddAsync(template);
            await _context.SaveChangesAsync();
            return template;
        }

        public async Task UpdateAsync(TaskListTemplate template)
        {
            _context.TaskListTemplates.Update(template);
            await _context.SaveChangesAsync();
        }

        public async Task DeleteAsync(int id)
        {
            var entity = await GetByIdAsync(id);
            if (entity != null)
            {
                _context.TaskListTemplates.Remove(entity);
                await _context.SaveChangesAsync();
            }
        }

        public async Task<bool> ExistsAsync(int id)
        {
            return await _context.TaskListTemplates.AnyAsync(t => t.Id == id);
        }

        public async Task<IEnumerable<TaskListTemplate>> GetActiveTemplatesWithItemsAsync(CancellationToken cancellationToken)
        {
            return await _context.TaskListTemplates
                .Include(t => t.Items)
                .Where(t => t.IsActive)
                .OrderBy(t => t.Name)
                .AsNoTracking()
                .ToListAsync(cancellationToken);
        }

        public async Task<TaskListTemplate?> GetTemplateWithItemsReadOnlyAsync(int id, CancellationToken cancellationToken)
        {
            return await _context.TaskListTemplates
                .Include(t => t.Items)
                .Where(t => t.Id == id)
                .AsNoTracking()
                .FirstOrDefaultAsync(cancellationToken);
        }

        public async Task<TaskListTemplate?> GetTemplateWithItemsForUpdateAsync(int id, CancellationToken cancellationToken)
        {
            return await _context.TaskListTemplates
                .Include(t => t.Items)
                .FirstOrDefaultAsync(t => t.Id == id, cancellationToken);
        }

        public async Task<TaskListTemplate> AddTemplateAsync(TaskListTemplate template, CancellationToken cancellationToken)
        {
            await _context.TaskListTemplates.AddAsync(template, cancellationToken);
            await _context.SaveChangesAsync(cancellationToken);
            return template;
        }

        public async Task ReplaceTemplateItemsAsync(TaskListTemplate template, IEnumerable<TaskListTemplateItem> newItems, CancellationToken cancellationToken)
        {
            if (template.Items != null)
                _context.TaskListTemplateItems.RemoveRange(template.Items);

            template.Items = newItems.ToList();
            await _context.SaveChangesAsync(cancellationToken);
        }

        public async Task<bool> DeactivateTemplateAsync(int id, CancellationToken cancellationToken)
        {
            var template = await _context.TaskListTemplates.FindAsync(new object[] { id }, cancellationToken);
            if (template == null)
                return false;

            template.IsActive = false;
            await _context.SaveChangesAsync(cancellationToken);
            return true;
        }
    }
}