using System;
using MbUnit.Framework;

namespace Spiking35.Test.unit {
	//[Flags]
	//public enum Digits {
	//    Zero = 0x00,
	//    One = 0x01,
	//    Two = 0x02,
	//    Three = 0x03,
	//    Four = 0x04,
	//    Five = 0x05,
	//    Six = 0x06,
	//    Seven = 0x07,
	//    Eight = 0x08,
	//    Nine = 0x09
	//}

	public class Digits {
		public static readonly IDigit Eight = new Digit( 8 );
		public static readonly IDigit Five = new Digit( 5 );
		public static readonly IDigit Four = new Digit( 4 );
		public static readonly IDigit Nine = new Digit( 9 );
		public static readonly IDigit One = new Digit( 1 );
		public static readonly IDigit Seven = new Digit( 7 );
		public static readonly IDigit Six = new Digit( 6 );
		public static readonly IDigit Three = new Digit( 3 );
		public static readonly IDigit Two = new Digit( 2 );
		public static readonly IDigit Zero = new Digit( 0 );

		private class Digit : IDigit {
			public Digit( int digitToRepresent ) {
				_digitToRepresent = digitToRepresent;
			}

			public int Value() {
				return _digitToRepresent;
			}

			public override string ToString() {
				return _digitToRepresent.ToString( );
			}

			private readonly int _digitToRepresent;
		}
	}

	public interface IDigit {
		int Value();
	}

	public interface INumber {
		INumber Append( IDigit digit );
	}

	public class Number : INumber, IEquatable< Number > {
		public Number() : this( 0 ) {}

		public Number( int numberToRepresent ) {
			_numberToRepresent = numberToRepresent;
		}

		public INumber Append( IDigit digit ) {
			return new Number( ( _numberToRepresent*10 ) + digit.Value( ) );
		}

		public bool Equals( Number number ) {
			if ( number == null ) {
				return false;
			}
			return _numberToRepresent == number._numberToRepresent;
		}

		public override string ToString() {
			return _numberToRepresent.ToString( );
		}

		public override bool Equals( object obj ) {
			if ( ReferenceEquals( this, obj ) ) {
				return true;
			}
			return Equals( obj as Number );
		}

		public override int GetHashCode() {
			return _numberToRepresent;
		}

		private readonly int _numberToRepresent;
	}

	public class NumberBuilder : INumberBuilder {
		public NumberBuilder() {
			_numberBeingBuilt = new Number( 0 );
		}

		public void Append( IDigit digit ) {
			_numberBeingBuilt = _numberBeingBuilt.Append( digit );
		}

		public INumber Build() {
			return _numberBeingBuilt;
		}

		private INumber _numberBeingBuilt;
	}

	public interface INumberBuilder {
		void Append( IDigit digit );

		INumber Build();
	}

	[TestFixture]
	public class NumberBuilderTest {
		private INumberBuilder CreateSUT() {
			return new NumberBuilder( );
		}

		[Test]
		public void should_be_able_to_add_a_single_digit() {
			INumberBuilder builder = CreateSUT( );
			builder.Append( Digits.One );
			Assert.AreEqual( new Number( 1 ), builder.Build( ) );
		}

		[Test]
		public void should_be_able_to_form_a_number_with_more_than_one_digit() {
			INumberBuilder builder = CreateSUT( );
			builder.Append( Digits.One );
			builder.Append( Digits.Nine );
			Assert.AreEqual( new Number( 19 ), builder.Build( ) );
		}

		//[Test]
		//public void Should_be_equal_to_2_digits() {
		//    Digits digits = Digits.Six | Digits.One;
		//    Assert.IsTrue( Digits.Six == ( digits & Digits.Six ) );
		//    Assert.IsTrue( Digits.One == ( digits & Digits.One ) );
		//}
	}
}