using System;
using System.IO;
using Rhino.Mocks;

namespace PlayingWithDisposableActions.Test
{
	public class LetsPlay
	{
		public void DemoWithUsingBlock()
		{
			using (MemoryStream stream = new MemoryStream()) {
				// do something with the stream
			}
		}

		public void DemoOfUsingBlockExpanded()
		{
			MemoryStream stream = null;
			try {
				stream = new MemoryStream();
				// do something with the stream
			}
			finally {
				if (stream != null) stream.Dispose();
			}
		}

		public void DemoAction()
		{
			Do<string>(Console.Out.WriteLine);
			Do<Type>(MyMethodThatMatchesTheActionDelegateSignature);
		}

		public void Do<T>(Action<T> action)
		{
		}

		private void MyMethodThatMatchesTheActionDelegateSignature(Type type)
		{
		}

		private void DemoDisposableAction()
		{
			string myMessage = "Hello World";
			using (new DisposableAction<string>(Console.Out.WriteLine, myMessage)) {
				// do something
			}

			using (new DisposableConsoleLogger("Finished running...")) {
				// do something
			}
		}

		private void WhatIsRhinoDoingUnderTheHood()
		{
			MockRepository mockery = new MockRepository();

			using (mockery.Record()) {
				// ReplayAll()
			}
			using (mockery.Playback()) {
				// VerifyAll()
			}
		}
	}

	public class DisposableAction<T> : IDisposableAction
	{
		public DisposableAction(Action<T> _action, T _itemToActOn)
		{
			this._action = _action;
			this._itemToActOn = _itemToActOn;
		}

		public void Dispose()
		{
			_action(_itemToActOn);
		}

		private Action<T> _action;
		private T _itemToActOn;
	}

	public class DisposableConsoleLogger : DisposableAction<string>
	{
		public DisposableConsoleLogger(string completionMessage) : base(Console.Out.WriteLine, completionMessage)
		{
		}

		public DisposableConsoleLogger() : base(Console.Out.WriteLine, "completed action")
		{
		}
	}

	public interface IDisposableAction : IDisposable
	{
	}
}