// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Reflection.Metadata;
using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.AspNetCore.Mvc.Infrastructure;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.AspNetCore.Mvc.ModelBinding.Metadata;
using Microsoft.AspNetCore.Mvc.Razor;
using Microsoft.Extensions.Primitives;

[assembly: MetadataUpdateHandler(typeof(Microsoft.AspNetCore.Mvc.HotReload.HotReloadService))]

namespace Microsoft.AspNetCore.Mvc.HotReload;

internal sealed class HotReloadService : IActionDescriptorChangeProvider, IDisposable
{
    private readonly DefaultModelMetadataProvider? _modelMetadataProvider;
    private readonly DefaultControllerPropertyActivator? _controllerPropertyActivator;
    private readonly RazorHotReload? _razorHotReload;
    private CancellationTokenSource _tokenSource = new();

    public HotReloadService(
        IModelMetadataProvider modelMetadataProvider,
        IControllerPropertyActivator controllerPropertyActivator)
        : this(modelMetadataProvider, controllerPropertyActivator, null)
    {
    }

    public HotReloadService(
        IModelMetadataProvider modelMetadataProvider,
        IControllerPropertyActivator controllerPropertyActivator,
        RazorHotReload? razorHotReload)
    {
        ClearCacheEvent += NotifyClearCache;
        UpdateApplicationEvent += NotifyUpdateApplication;

        if (modelMetadataProvider.GetType() == typeof(DefaultModelMetadataProvider))
        {
            _modelMetadataProvider = (DefaultModelMetadataProvider)modelMetadataProvider;
        }

        if (controllerPropertyActivator is DefaultControllerPropertyActivator defaultControllerPropertyActivator)
        {
            _controllerPropertyActivator = defaultControllerPropertyActivator;
        }

        _razorHotReload = razorHotReload;
    }

    private static event Action<Type[]?>? ClearCacheEvent;
    private static event Action<Type[]?>? UpdateApplicationEvent;

    public static void ClearCache(Type[]? changedTypes)
    {
        ClearCacheEvent?.Invoke(changedTypes);
    }

    public static void UpdateApplication(Type[]? changedTypes)
    {
        UpdateApplicationEvent?.Invoke(changedTypes);
    }

    IChangeToken IActionDescriptorChangeProvider.GetChangeToken() => new CancellationChangeToken(_tokenSource.Token);

    private void NotifyClearCache(Type[]? changedTypes)
    {
        // Clear individual caches
        _modelMetadataProvider?.ClearCache();
        _controllerPropertyActivator?.ClearCache();

        _razorHotReload?.ClearCache(changedTypes);
    }

    private void NotifyUpdateApplication(Type[]? changedTypes)
    {
        // Trigger the ActionDescriptorChangeProvider
        var current = Interlocked.Exchange(ref _tokenSource, new CancellationTokenSource());
        current.Cancel();
    }

    public void Dispose()
    {
        ClearCacheEvent -= NotifyClearCache;
        UpdateApplicationEvent -= NotifyUpdateApplication;
    }
}