using System;
using System.Collections.Generic;
using Chernobyl.Destruction;

namespace Chernobyl.Unity.Work
{
    /// <summary>
    /// Interface for objects which perform some work on a regular basis.
    /// </summary>
    public interface IUpdateable
    {
        // TODO: Replace the Chernobyl.Update.IUpdateable with this or vice versa.

        /// <summary>
        /// Instructs the object to perform the work.
        /// </summary>
        void Update();
    }

    /// <summary>
    /// A module that has components that require updates.
    /// </summary>
    public interface IUpdateableModule
    {
        /// <summary>
        /// The components that require updates. Note that this list may be updated by the module.
        /// </summary>
        IEnumerable<IUpdateable> Updateables { get; }
    }

    /// <summary>
    /// A module that has components that require fixed updates.
    /// </summary>
    public interface IFixedUpdateableModule
    {
        /// <summary>
        /// The components that require updates. Note that this list may be updated by the module.
        /// </summary>
        IEnumerable<IUpdateable> FixedUpdateables { get; }
    }

    /// <summary>
    /// Invokes a method when an <see cref="IUpdateable"/>.
    /// </summary>
    public class FuncUpdateable : IUpdateable
    {
        /// <param name="action">The method to invoke on each update.</param>
        public FuncUpdateable(Action action)
        {
            _action = action;
        }

        /// <inheritdoc />
        public void Update() => _action();

        readonly Action _action;
    }

    /// <summary>
    /// Utility and extension methods for <see cref="IUpdateable"/>.
    /// </summary>
    public static class Updateable
    {
        /// <summary>
        /// Converts a <paramref name="action"/> to a <see cref="IUpdateable"/>.
        /// </summary>
        public static IUpdateable From(Action action) => new FuncUpdateable(action);
    }

    /// <summary>
    /// Wraps disposal and updating in one type.
    /// </summary>
    public class DisposableUpdateable : IDisposable, IUpdateable
    {
        /// <param name="dispose">The method to invoke when disposal occurs.</param>
        /// <param name="update">The method to invoke when update occurs.</param>
        public DisposableUpdateable(Action dispose, Action update)
            : this(Disposable.From(dispose), Updateable.From(update))
        { }

        /// <param name="disposable">The instance to invoke when disposal occurs.</param>
        /// <param name="updateable">The instance to invoke when update occurs.</param>
        public DisposableUpdateable(IDisposable disposable, IUpdateable updateable)
        {
            _disposable = disposable;
            _updateable = updateable;
        }

        /// <inheritdoc />
        public void Dispose() => _disposable.Dispose();

        /// <inheritdoc />
        public void Update() => _updateable.Update();

        readonly IDisposable _disposable;
        readonly IUpdateable _updateable;
    }
}