using Modules.Library.Domain.EntitiesV0.MediaContent.Items.Anime.ShadowEntities;

namespace Modules.Library.Domain.EntitiesV0.MediaContent.Items.Anime;

public abstract class AnimeItem : Entity
{
    private readonly AnimeItemShadow _shadow;

    public override string Id => _shadow.id;

    public CommonProperties.CommonProperties CommonProperties => GetCommonProperties();
    public ushort Order => _shadow.order;
    public ushort Variant => _shadow.variant;
    public bool Completed => _shadow.completed;
    public override bool Deleted => _shadow.deleted;
    public TimeSpan ExpirationTime => _shadow.expirationTime;

    internal AnimeItem(AnimeItemShadow shadow) { _shadow = shadow; }

    /*
    private CommonProperties.CommonProperties GetCommonProperties()
    {
        new (shadow.commonProperties, afterAnnouncementDateSet, afterEstimatedReleaseDateSet, afterReleaseDateSet)
    }
    */

    protected virtual CommonProperties.CommonProperties GetCommonProperties() =>
        new(_shadow.commonProperties, null, null, null);

    public abstract void SetOrder(ushort order);
    internal static ushort GetNewOrder(IEnumerable<AnimeItemShadow> items) =>
        (ushort)(items.Select(q => (int)q.order).DefaultIfEmpty(-1).Max() + 1);

    public abstract void SetVariant(ushort variant);
    internal static ushort GetNewVariant(IEnumerable<AnimeItemShadow> items, ushort order) =>
        (ushort)(items.Where(q => q.order == order)
        .Select(q => (int)q.variant).DefaultIfEmpty(-1).Max() + 1);

    internal static void Sort(IEnumerable<AnimeItemShadow> items)
    {
        var orderedItemGroups = items.GroupBy(q => q.order).Select(q => new { Order = q.Key, Items = items.Where(x => x.order == q.Key) })
            .OrderBy(q => q.Order).ToArray();
        for (int i = 0; i < orderedItemGroups.Length; i++)
        {
            foreach (var item in orderedItemGroups[i].Items)
            {
                item.order = (ushort)i;
            }
        }
    }

    public abstract void SetCompleted();
    public abstract void SetNotCompleted();
    public abstract void SetExpirationTime(TimeSpan value);

    internal static void SetItemOrder(IEnumerable<AnimeItemShadow> items, ushort lastOrder, ushort newOrder)
    {
        if (newOrder < 0 || newOrder > items.Select(q => q.order).DefaultIfEmpty<ushort>(0).Max())
            throw new ArgumentOutOfRangeException(nameof(newOrder));
        //if (lastOrder == newOrder) return;
        var newOrderItem = items.First(q => q.order == newOrder);
        items.First(q => q.order == lastOrder).order = newOrder;
        foreach (var item in items.Where(q => q.order > Math.Min(lastOrder, newOrder) && q.order < Math.Max(lastOrder, newOrder)))
        {
            if (lastOrder > newOrder) item.order++;
            else if (lastOrder < newOrder) item.order--;
        }
        if (lastOrder > newOrder) newOrderItem.order++;
        else if (lastOrder < newOrder) newOrderItem.order--;
    }

    internal static void SetItemVariant(IEnumerable<AnimeItemShadow> items, ushort lastVariant, ushort newVariant)
    {
        if (newVariant < 0 || newVariant >= items.Count())
            throw new ArgumentOutOfRangeException(nameof(newVariant));
        //if (lastVariant == newVariant) return;
        var newVariantItem = items.First(q => q.variant == newVariant);
        items.First(q => q.variant == lastVariant).variant = newVariant;
        foreach (var item in items.Where(q => q.variant > Math.Min(lastVariant, newVariant) && q.variant < Math.Max(lastVariant, newVariant)))
        {
            if (lastVariant > newVariant) item.variant++;
            else if (lastVariant < newVariant) item.variant--;
        }
        if (lastVariant > newVariant) newVariantItem.variant++;
        else if (lastVariant < newVariant) newVariantItem.variant--;
    }

    internal override void SetDeleted() => _shadow.deleted = true;
}