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

namespace SeaHaven.DataServices.Implementation
{
    public class CompletionDocTemplateDataService : ICompletionDocTemplateDataService
    {
        private readonly ApplicationDbContext _context;

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

        public async Task<IReadOnlyList<CompletionDocTemplateRow>> GetActiveAsync(string? serviceKey, WorkOrderType? workOrderType)
        {
            var query = _context.CompletionDocTemplates
                .AsNoTracking()
                .Where(t => t.IsActive && t.IsDeleted != true);

            if (!string.IsNullOrWhiteSpace(serviceKey))
                query = query.Where(t => t.ServiceKey == serviceKey);

            if (workOrderType.HasValue)
                query = query.Where(t => t.WorkOrderType == null || t.WorkOrderType == workOrderType);

            return await query
                .OrderBy(t => t.Name)
                .Select(MapRow)
                .ToListAsync();
        }

        public async Task<CompletionDocTemplateRow?> GetByIdAsync(int id)
        {
            return await _context.CompletionDocTemplates
                .AsNoTracking()
                .Where(t => t.Id == id && t.IsDeleted != true)
                .Select(MapRow)
                .FirstOrDefaultAsync();
        }

        public async Task<CompletionDocTemplateRow?> ResolveForWorkOrderAsync(string? trade, WorkOrderType? workOrderType)
        {
            if (!string.IsNullOrWhiteSpace(trade))
            {
                var byTrade = await _context.CompletionDocTemplates
                    .AsNoTracking()
                    .Where(t => t.IsActive && t.IsDeleted != true && t.ServiceKey == trade)
                    .OrderBy(t => t.WorkOrderType == workOrderType ? 0 : 1)
                    .ThenBy(t => t.Name)
                    .ThenBy(t => t.Id)
                    .Select(MapRow)
                    .FirstOrDefaultAsync();

                if (byTrade != null)
                    return byTrade;
            }

            if (!workOrderType.HasValue)
                return null;

            return await _context.CompletionDocTemplates
                .AsNoTracking()
                .Where(t => t.IsActive && t.IsDeleted != true && t.WorkOrderType == workOrderType)
                .OrderBy(t => t.Name)
                .ThenBy(t => t.Id)
                .Select(MapRow)
                .FirstOrDefaultAsync();
        }

        public async Task<CompletionDocTemplate> CreateAsync(CompletionDocTemplate template)
        {
            template.CreatedDate = DateTime.UtcNow;
            await _context.CompletionDocTemplates.AddAsync(template);
            await _context.SaveChangesAsync();
            return template;
        }

        public async Task UpdateAsync(CompletionDocTemplate template)
        {
            template.LastModificationTime = DateTime.UtcNow;
            _context.CompletionDocTemplates.Update(template);
            await _context.SaveChangesAsync();
        }

        public async Task<bool> DeleteAsync(int id)
        {
            var entity = await _context.CompletionDocTemplates.FindAsync(id);
            if (entity == null)
                return false;

            entity.IsDeleted = true;
            entity.DeletionTime = DateTime.UtcNow;
            await _context.SaveChangesAsync();
            return true;
        }

        private static readonly System.Linq.Expressions.Expression<Func<CompletionDocTemplate, CompletionDocTemplateRow>> MapRow =
            t => new CompletionDocTemplateRow(t.Id, t.Name, t.ServiceKey, t.WorkOrderType, t.TemplateUrl, t.IsActive);
    }
}