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

using System.Collections.Immutable;
using System.ComponentModel;

namespace Microsoft.DotNet.Watch;

internal sealed class EventBasedDirectoryWatcher : DirectoryWatcher
{
    public Action<string>? Logger { get; set; }

    private volatile bool _disposed;
    private FileSystemWatcher? _fileSystemWatcher;
    private readonly Lock _createLock = new();

    internal EventBasedDirectoryWatcher(string watchedDirectory, ImmutableHashSet<string> watchedFileNames, bool includeSubdirectories)
        : base(watchedDirectory, watchedFileNames, includeSubdirectories)
    {
        CreateFileSystemWatcher();
    }

    public override void Dispose()
    {
        _disposed = true;
        DisposeInnerWatcher();
    }

    private void WatcherErrorHandler(object sender, ErrorEventArgs e)
    {
        if (_disposed)
        {
            return;
        }

        Logger?.Invoke("[FW] Error");

        var exception = e.GetException();

        Logger?.Invoke(exception.ToString());

        // Win32Exception may be triggered when setting EnableRaisingEvents on a file system type
        // that is not supported, such as a network share. Don't attempt to recreate the watcher
        // in this case as it will cause a StackOverflowException
        if (exception is not Win32Exception)
        {
            // Recreate the watcher if it is a recoverable error.
            CreateFileSystemWatcher();
        }

        NotifyError(exception);
    }

    private void WatcherRenameHandler(object sender, RenamedEventArgs e)
    {
        if (_disposed)
        {
            return;
        }

        Logger?.Invoke($"[FW] Renamed '{e.OldFullPath}' to '{e.FullPath}'.");

        if (Directory.Exists(e.FullPath))
        {
            foreach (var newLocation in Directory.EnumerateFiles(e.FullPath, "*", SearchOption.AllDirectories))
            {
                // Calculated previous path of this moved item.
                var oldLocation = Path.Combine(e.OldFullPath, newLocation.Substring(e.FullPath.Length + 1));
                NotifyChange(oldLocation, ChangeKind.Delete);
                NotifyChange(newLocation, ChangeKind.Add);
            }
        }
        else
        {
            NotifyChange(e.OldFullPath, ChangeKind.Delete);
            NotifyChange(e.FullPath, ChangeKind.Add);
        }
    }

    private void WatcherDeletedHandler(object sender, FileSystemEventArgs e)
    {
        if (_disposed)
        {
            return;
        }

        var isDir = Directory.Exists(e.FullPath);

        Logger?.Invoke($"[FW] Deleted '{e.FullPath}'.");

        // ignore directory changes:
        if (isDir)
        {
            return;
        }

        NotifyChange(e.FullPath, ChangeKind.Delete);
    }

    private void WatcherChangeHandler(object sender, FileSystemEventArgs e)
    {
        if (_disposed)
        {
            return;
        }

        var isDir = Directory.Exists(e.FullPath);

        Logger?.Invoke($"[FW] Updated '{e.FullPath}'.");

        // ignore directory changes:
        if (isDir)
        {
            return;
        }

        NotifyChange(e.FullPath, ChangeKind.Update);
    }

    private void WatcherAddedHandler(object sender, FileSystemEventArgs e)
    {
        if (_disposed)
        {
            return;
        }

        var isDir = Directory.Exists(e.FullPath);

        Logger?.Invoke($"[FW] Added '{e.FullPath}'.");

        if (isDir)
        {
            return;
        }

        NotifyChange(e.FullPath, ChangeKind.Add);
    }

    private void CreateFileSystemWatcher()
    {
        lock (_createLock)
        {
            bool enableEvents = false;

            if (_fileSystemWatcher != null)
            {
                enableEvents = _fileSystemWatcher.EnableRaisingEvents;

                DisposeInnerWatcher();
            }

            _fileSystemWatcher = new FileSystemWatcher(WatchedDirectory)
            {
                IncludeSubdirectories = IncludeSubdirectories
            };

            _fileSystemWatcher.Created += WatcherAddedHandler;
            _fileSystemWatcher.Deleted += WatcherDeletedHandler;
            _fileSystemWatcher.Changed += WatcherChangeHandler;
            _fileSystemWatcher.Renamed += WatcherRenameHandler;
            _fileSystemWatcher.Error += WatcherErrorHandler;

            _fileSystemWatcher.EnableRaisingEvents = enableEvents;
        }
    }

    private void DisposeInnerWatcher()
    {
        if (_fileSystemWatcher != null)
        {
            _fileSystemWatcher.EnableRaisingEvents = false;

            _fileSystemWatcher.Created -= WatcherAddedHandler;
            _fileSystemWatcher.Deleted -= WatcherDeletedHandler;
            _fileSystemWatcher.Changed -= WatcherChangeHandler;
            _fileSystemWatcher.Renamed -= WatcherRenameHandler;
            _fileSystemWatcher.Error -= WatcherErrorHandler;

            _fileSystemWatcher.Dispose();
        }
    }

    public override bool EnableRaisingEvents
    {
        get => _fileSystemWatcher!.EnableRaisingEvents;
        set => _fileSystemWatcher!.EnableRaisingEvents = value;
    }
}