using System.ComponentModel.Design;
using Demo.Models;

namespace Demo.Features;

public class FeatureWrapper<TMetadata>
    where TMetadata : IMetadata
{
    private readonly TMetadata _metadata;

    protected FeatureList<TMetadata> Features { get; }
    
    public FeatureWrapper(TMetadata metadata, FeatureList<TMetadata>? features = null)
    {
        _metadata = metadata;
        Features = features ?? new FeatureList<TMetadata>();
    }

    public FeatureWrapper<TMetadata> DropFeature(string name)
    {
        if (String.IsNullOrWhiteSpace(name))
        {
            throw new CheckoutException("功能名称不能为空或空白字符");
        }
        Features.Remove(name);

        return this;
    }

    /// <summary>
    /// 添加功能
    /// </summary>
    /// <param name="feature"></param>
    /// <typeparam name="TFeature"></typeparam>
    /// <returns></returns>
    public FeatureWrapper<TMetadata> WithFeature<TFeature>(TFeature feature)
        where TFeature : Feature<TMetadata>
    {
        if (feature is null)
        {
            return this;
        }

        if (String.IsNullOrWhiteSpace(feature.Name))
        {
            throw new CheckoutException("功能名称不能为空或空白字符");
        }
        Features.TryAdd(feature.Name, feature);

        return this;
    }

    /// <summary>
    /// 添加功能
    /// </summary>
    /// <param name="name"></param>
    /// <param name="feature"></param>
    /// <param name="order"></param>
    /// <returns></returns>
    public FeatureWrapper<TMetadata> WithFeature(string name, FeatureFunction<TMetadata> feature, int order = 1)
    {
        if (String.IsNullOrWhiteSpace(name))
        {
            throw new CheckoutException("功能名称不能为空或空白字符");
        }
        if (feature is not null)
        {
            Features.TryAdd(name, new DefaultFeature<TMetadata>(name, feature, order: order));
        }

        return this;
    }
    
    /// <summary>
    /// 添加功能
    /// </summary>
    /// <param name="name"></param>
    /// <param name="feature"></param>
    /// <param name="order"></param>
    /// <returns></returns>
    public FeatureWrapper<TMetadata> WithFeature(string name, FeatureFunctionAsync<TMetadata> feature, int order = 1)
    {
        if (String.IsNullOrWhiteSpace(name))
        {
            throw new CheckoutException("功能名称不能为空或空白字符");
        }
        if (feature is not null)
        {
            Features.TryAdd(name, new DefaultFeature<TMetadata>(name, executeFunctionAsync: feature, order: order));
        }

        return this;
    }

    public void Execute()
    {
        foreach (var feature in Features.Values.OrderBy(f => f.Order))
        {
            try
            {
               feature.Execute(_metadata);
               if (feature.Finished)
               {
                   break;
               }
            }
            catch (Exception ex)
            {
                feature.OnException(new FeatureExceptionContext<TMetadata>(feature, new FeatureException<TMetadata>(_metadata, feature, ex)));
            } 
        }
    }

    public void Execute(string name)
    {
        if (Features.TryGetValue(name, out var feature))
        {
            feature.Execute(_metadata);
        }
        else
        {
            throw new KeyNotFoundException(name);
        }
    }
    
    public async ValueTask ExecuteAsync()
    {
        foreach (var feature in Features.Values.OrderBy(f => f.Order))
        {
            try
            {
                await feature.ExecuteAsync(_metadata);
                if (feature.Finished)
                {
                    break;
                }
            }
            catch (Exception ex)
            {
                await feature.OnExceptionAsync(new FeatureExceptionContext<TMetadata>(feature, new FeatureException<TMetadata>(_metadata, feature, ex)));
            } 
        }
    }
}