using System;

using System.Collections.Generic;

using System.Linq;

using System.Threading;

​

public static class SlotMachineBuilder

{

    public static SlotHandle.SlotMachine BuildDefaultSlotMachine()

    {

        var defaultValues = new List<string> { "Cherry", "Rasberry", "Grape" };

        var wheels = new List<SlotHandle.SlotWheel> { new SlotHandle.SlotWheel { Values = defaultValues, CurrentValue = null }, new SlotHandle.SlotWheel { Values = defaultValues, CurrentValue = null }, new SlotHandle.SlotWheel { Values = defaultValues, CurrentValue = null } };

        var random = new RandomProvider();

        var slotHandle = new SlotHandle(random);

        var slotMachine = new SlotHandle.SlotMachine(wheels: wheels, slotHandle: slotHandle);

        return slotMachine;

    }

}

​

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Welcome to an object oriented Slot Machine!");

        var slotMachine = SlotMachineBuilder.BuildDefaultSlotMachine();

        var isContinue = true;

        while (isContinue)

        {

            Console.Write("Spin? (y|n):");

            var spinAnwswer = Console.ReadLine();

            if (spinAnwswer.ToLower().StartsWith("y"))

            {

                var result = slotMachine.SlotHandle.Pull(slotMachine.Wheels);

                foreach (var w in slotMachine.Wheels)

                {

                    SuspenceDots(5);

                    Console.WriteLine(w.CurrentValue);

                }

​

                Console.WriteLine(result.IsWinner ? "You won!!!!!!!!!" : "Sorry, you lost.");

            }

            else

            {

                Console.WriteLine();

                Console.Write("Continue?: (y|n):");

                if (!Console.ReadLine().ToLower().StartsWith("y"))

                {

                    isContinue = false;

                }

            }

        }

    }

​

    static void SuspenceDots(int quantity, int speedMillisends = 50)

    {

        for (int i = 1; i <= quantity; i++)

        {

            Console.Write(".");

            Thread.Sleep(speedMillisends);

        }

    }

}

​

public class HandlePullResult

{

    public bool IsWinner { get; set; }

}

​

public interface IRandomProvider

{

    int Random(int inclusiveMin, int inclusiveMax);

}

​

public class RandomProvider : IRandomProvider

{

    private readonly Random random;

    public RandomProvider()

    {

        this.random = new Random();

    }

​

    public int Random(int inclusiveMin, int inclusiveMax)

    {

        //https://stackoverflow.com/questions/5063269/c-sharp-random-next-never-returns-the-upper-bound

        var result = this.random.Next(minValue: inclusiveMin, maxValue: inclusiveMax + 1); // max is exclusive, min is inclusive.

        return result;

    }

}

​

public class SlotHandle

{

    private readonly IRandomProvider randomProvider;

​

    public SlotHandle(IRandomProvider randomProvider)

    {

        if (randomProvider == null)

            throw new ArgumentNullException(nameof(randomProvider));

        this.randomProvider = randomProvider;

    }

​

    public HandlePullResult Pull(List<SlotWheel> wheels)

    {

        //future, I would imagine there would be more complex win formulas that account for payout ratios and win history

        // for now we will use a simple random generator

        var result = new HandlePullResult { IsWinner = false };

        foreach (var wheel in wheels)

        {

            wheel.CurrentValue = this.SelectRandom(wheel.Values);

        }

​

        //The current win rule is that all wheels have the same value.

        //Real world must include endless combo value wins like wild cards ect.

        result.IsWinner = wheels.Select(w => w.CurrentValue).Distinct().Count() == 1;

        return result;

    }

​

    public string SelectRandom(List<string> values)

    {

        if (values == null)

            throw new ArgumentNullException(nameof(values));

        var maxIndex = values.Count - 1;

        var randomIndex = this.randomProvider.Random(inclusiveMin: 0, inclusiveMax: maxIndex);

        var result = values[randomIndex];

        return result;

    }

​

    public class SlotMachine

    {

        public SlotMachine(List<SlotWheel> wheels, SlotHandle slotHandle)

        {

            //Note validation of slot build can be moved to another responsibility, but for now let's do the basics.

            if (wheels == null)

                throw new ArgumentNullException(nameof(wheels));

            if (slotHandle == null)

                throw new ArgumentNullException(nameof(slotHandle));

            if (wheels.Count < 3)

            {

                throw new Exception($"There must me a minmum of 3 values per Slot Wheel. {wheels.Count} were given.");

            }

​

            this.SlotHandle = slotHandle;

            this.Wheels = wheels;

        }

​

        public List<SlotWheel> Wheels { get; private set; }

​

        public SlotHandle SlotHandle { get; private set; }

    }

​

​

​

    public class SlotWheel

    {

        public string CurrentValue { get; set; }

​

        public List<string> Values { get; set; }

    }

}