using eprintServer.Data;
using eprintServer.Entities;
using eprintServer.DTOs;
using Microsoft.EntityFrameworkCore;

namespace eprintServer.Services;

public class CarouselService
{
    private readonly DataContext _context;

    public CarouselService(DataContext context)
    {
        _context = context;
    }
 public async Task<List<CarouselItemDto>> GetAllAsync()
    {
        var items = await _context.CarouselItems
            .Include(c => c.Title)
            .Include(c => c.Description)
            .Include(c => c.ButtonText)
            .Include(c => c.Image)
            .ToListAsync();

        return items.Select(c => new CarouselItemDto
        {
            Id = c.Id,
            Title = c.Title.Select(t => new DynamicValueDto { Value = t.Value, LanguageTag = t.LanguageTag }).ToList(),
            Description = c.Description.Select(d => new DynamicValueDto { Value = d.Value, LanguageTag = d.LanguageTag }).ToList(),
            ButtonText = c.ButtonText.Select(b => new DynamicValueDto { Value = b.Value, LanguageTag = b.LanguageTag }).ToList(),
            RedirectUrl = c.RedirectUrl,
            ImageUrl = c.Image?.Url
        }).ToList();
    }


    public async Task<List<CarouselItemDto>> GetAllFIltredAsync(bool? status = null)
    {
        var query = _context.CarouselItems
            .Include(c => c.Title)
            .Include(c => c.Description)
            .Include(c => c.ButtonText)
            .Include(c => c.Image)
            .AsQueryable();

        if (status.HasValue)
        {
            query = query.Where(c => c.Status == status.Value);
        }

        var items = await query
            .OrderBy(c => c.Order)
            .ToListAsync();

        return items.Select(c => new CarouselItemDto
        {
            Id = c.Id,
            Title = c.Title.Select(t => new DynamicValueDto { Value = t.Value, LanguageTag = t.LanguageTag }).ToList(),
            Description = c.Description.Select(d => new DynamicValueDto { Value = d.Value, LanguageTag = d.LanguageTag }).ToList(),
            ButtonText = c.ButtonText.Select(b => new DynamicValueDto { Value = b.Value, LanguageTag = b.LanguageTag }).ToList(),
            RedirectUrl = c.RedirectUrl,
            ImageUrl = c.Image?.Url,
            Order = c.Order,
            Status = c.Status
        }).ToList();
    }


    public async Task<CarouselItem?> GetByIdAsync(long id)
    {
        return await _context.CarouselItems
            .Include(c => c.Title)
            .Include(c => c.Description)
            .Include(c => c.ButtonText)
            .FirstOrDefaultAsync(x => x.Id == id);
    }

    public async Task<CarouselItem> AddAsync(List<DynamicValueDto> titles, List<DynamicValueDto> descriptions,
     List<DynamicValueDto> buttonTexts, string redirectUrl, int order , bool status)
    {
        var item = new CarouselItem
        {
            RedirectUrl = redirectUrl,
            Title = titles.Select(t => new DynamicValue { Value = t.Value, LanguageTag = t.LanguageTag }).ToList(),
            Description = descriptions.Select(d => new DynamicValue { Value = d.Value, LanguageTag = d.LanguageTag }).ToList(),
            ButtonText = buttonTexts.Select(b => new DynamicValue { Value = b.Value, LanguageTag = b.LanguageTag }).ToList(),
            Order = order,
            Status = status
        };

        _context.CarouselItems.Add(item);
        await _context.SaveChangesAsync();
        return item;
    }

    public async Task<CarouselItem?> UpdateAsync(long id, List<DynamicValueDto>? titles, List<DynamicValueDto>? descriptions,
     List<DynamicValueDto>? buttonTexts, string? redirectUrl, int? order = null, bool? status = null)
    {
        var existing = await _context.CarouselItems
            .Include(c => c.Title)
            .Include(c => c.Description)
            .Include(c => c.ButtonText)
            .FirstOrDefaultAsync(x => x.Id == id);

        if (existing == null) return null;

        // Update RedirectUrl only if not null
        if (redirectUrl != null)
        {
            existing.RedirectUrl = redirectUrl;
        }

        // Handle Titles: Clear and set if passed in request
        if (titles != null)
        {
            _context.DynamicValues.RemoveRange(existing.Title);
            existing.Title = titles.Select(t => new DynamicValue { Value = t.Value, LanguageTag = t.LanguageTag }).ToList();
        }

        // Handle Descriptions: Clear and set if passed in request
        if (descriptions != null)
        {
            _context.DynamicValues.RemoveRange(existing.Description);
            existing.Description = descriptions.Select(d => new DynamicValue { Value = d.Value, LanguageTag = d.LanguageTag }).ToList();
        }

        // Handle ButtonTexts: Clear and set if passed in request
        if (buttonTexts != null)
        {
            _context.DynamicValues.RemoveRange(existing.ButtonText);
            existing.ButtonText = buttonTexts.Select(b => new DynamicValue { Value = b.Value, LanguageTag = b.LanguageTag }).ToList();
        }

         if (order.HasValue && order.Value != existing.Order)
        {
            if (await _context.CarouselItems.AnyAsync(c => c.Order == order.Value))
                throw new InvalidOperationException($"Carousel with order {order.Value} already exists.");
            existing.Order = order.Value;
        }

        if (status.HasValue) existing.Status = status.Value;

        await _context.SaveChangesAsync();
        return existing;
    }

    public async Task<bool> DeleteAsync(long id)
    {
        var item = await _context.CarouselItems.FindAsync(id);
        if (item == null) return false;

        _context.CarouselItems.Remove(item);
        await _context.SaveChangesAsync();
        return true;
    }

     public async Task<CarouselItem?> UpdateCarouselImageAsync(long carouselId, FileModel fileModel)
    {
        var carousel = await GetByIdAsync(carouselId);

        if (carousel == null)
        {
            return null;
        }

        // Use the SetImage helper method
        carousel.SetImage(fileModel);

        _context.CarouselItems.Update(carousel);
        await _context.SaveChangesAsync();
        
        return carousel;
    }

    public async Task<bool> DoesOrderExistAsync(int order)
{
    return await _context.CarouselItems.AnyAsync(c => c.Order == order);
}

// Get next available order if none is provided
public async Task<int> GetNextOrderAsync()
{
    var lastOrder = await _context.CarouselItems.MaxAsync(c => (int?)c.Order) ?? 0;
    return lastOrder + 1;
}


}