using System.Linq.Expressions;

namespace Greencore.platform.validators;

public static class Options
{
    public static OptionsBuilder<T, C> For<T, C>() => new();
}

public sealed class OptionsBuilder<T, C>
{
    public FieldOptionsBuilder<T, C> Field<V>(Expression<Func<T, V>> property) => new(ValidationPath.Get(property));
}

public sealed class FieldOptionsBuilder<T, C>
{
    private readonly string _path;
    internal FieldOptionsBuilder(string path) => _path = path;

    public FieldOptions<T, C, O> Load<O>(Func<T, C, CancellationToken, ValueTask<IReadOnlyList<O>>> load) => new(_path, load, []);
}

/// <summary>Fuente de opciones independiente de las reglas, con dependencias de campos explícitas.</summary>
public sealed class FieldOptions<T, C, O>
{
    private readonly IReadOnlyList<(string Path, Func<T, object?> Select)> _dependencies;
    internal Func<T, C, CancellationToken, ValueTask<IReadOnlyList<O>>> Loader { get; }
    public string Path { get; }
    public IReadOnlyList<string> Dependencies => Array.AsReadOnly(_dependencies.Select(item => item.Path).ToArray());

    internal FieldOptions(string path, Func<T, C, CancellationToken, ValueTask<IReadOnlyList<O>>> load, IEnumerable<(string Path, Func<T, object?> Select)> dependencies)
    {
        ArgumentNullException.ThrowIfNull(load);
        Path = path;
        Loader = load;
        _dependencies = Array.AsReadOnly(dependencies.ToArray());
    }

    public FieldOptions<T, C, O> DependsOn<V>(Expression<Func<T, V>> property)
    {
        var path = ValidationPath.Get(property);
        if (_dependencies.Any(item => item.Path == path)) throw new ArgumentException("The dependency is already registered.", nameof(property));
        var select = property.Compile();
        return new(Path, Loader, [.. _dependencies, (path, candidate => select(candidate))]);
    }

    public OptionsSession<T, C, O> CreateSession(Action<Action>? dispatch = null) => new(this, dispatch);
    internal object?[] ReadDependencies(T candidate) => _dependencies.Select(item => item.Select(candidate)).ToArray();
}

/// <summary>Recarga al cambiar dependencias o contexto y descarta respuestas de selecciones anteriores.</summary>
public sealed class OptionsSession<T, C, O> : IDisposable
{
    private readonly FieldOptions<T, C, O> _definition;
    private readonly AsyncDataSession<IReadOnlyList<O>> _session;
    private readonly object _gate = new();
    private object?[]? _previous;
    private C? _context;
    private Task<DataOperationResult<IReadOnlyList<O>>>? _pending;
    private bool _disposed;
    private volatile bool _retry;

    public DataSnapshot<IReadOnlyList<O>> Snapshot => _session.Snapshot;
    public string Path => _definition.Path;
    public IReadOnlyList<string> Dependencies => _definition.Dependencies;
    public event Action<DataSnapshot<IReadOnlyList<O>>>? Changed;

    internal OptionsSession(FieldOptions<T, C, O> definition, Action<Action>? dispatch)
    {
        _definition = definition;
        _session = new(dispatch);
        _session.Changed += snapshot =>
        {
            if (snapshot.State is DataState.Failed or DataState.Canceled) _retry = true;
            Changed?.Invoke(snapshot);
        };
    }

    public async ValueTask RefreshAsync(T candidate, C context, CancellationToken cancellationToken = default)
        => _ = await LoadAsync(candidate, context, false, cancellationToken).ConfigureAwait(false);

    public ValueTask<DataOperationResult<IReadOnlyList<O>>> EnsureLoadedAsync(T candidate, C context, CancellationToken cancellationToken = default)
        => LoadAsync(candidate, context, false, cancellationToken, true);

    public ValueTask<DataOperationResult<IReadOnlyList<O>>> ReloadAsync(T candidate, C context, CancellationToken cancellationToken = default)
        => LoadAsync(candidate, context, true, cancellationToken);

    private ValueTask<DataOperationResult<IReadOnlyList<O>>> LoadAsync(T candidate, C context, bool force, CancellationToken cancellationToken, bool cacheWithoutDependencies = false)
    {
        cancellationToken.ThrowIfCancellationRequested();
        var dependencies = _definition.ReadDependencies(candidate);
        AsyncDataSession<IReadOnlyList<O>>.Request request;
        TaskCompletionSource<DataOperationResult<IReadOnlyList<O>>> completion;
        lock (_gate)
        {
            ObjectDisposedException.ThrowIf(_disposed, this);
            if (!force && !_retry && (cacheWithoutDependencies || dependencies.Length > 0) && _previous is not null && dependencies.SequenceEqual(_previous) && EqualityComparer<C>.Default.Equals(context, _context))
                return new(_pending!.WaitAsync(cancellationToken));
            _previous = dependencies;
            _context = context;
            _retry = false;
            request = _session.Begin(cancellationToken);
            completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
            _pending = completion.Task;
        }
        _ = ExecuteAsync(request, candidate, context, dependencies, completion);
        return new(completion.Task);
    }

    private async Task ExecuteAsync(AsyncDataSession<IReadOnlyList<O>>.Request request, T candidate, C context, object?[] dependencies, TaskCompletionSource<DataOperationResult<IReadOnlyList<O>>> completion)
    {
        try
        {
            var operation = await _session.RunRequestAsync(request, async token =>
            {
                try
                {
                    var result = await _definition.Loader(candidate, context, token).ConfigureAwait(false);
                    token.ThrowIfCancellationRequested();
                    ArgumentNullException.ThrowIfNull(result);
                    return Array.AsReadOnly(result.ToArray());
                }
                catch
                {
                    lock (_gate) { if (ReferenceEquals(_previous, dependencies)) _retry = true; }
                    throw;
                }
            }).ConfigureAwait(false);
            completion.TrySetResult(operation);
        }
        catch (Exception exception) { completion.TrySetException(exception); }
    }

    public void Dispose()
    {
        lock (_gate) { if (_disposed) return; _disposed = true; }
        _session.Dispose();
        Changed = null;
    }
}