/// <summary>
 /// Constructor
 /// </summary>
 /// <param name="variable"></param>
 /// <param name="previousValue"></param>
 /// <param name="newValue"></param>
 public Change(Variables.IVariable variable, Values.IValue previousValue, Values.IValue newValue)
 {
     Variable = variable;
     PreviousValue = previousValue;
     NewValue = newValue;
     Applied = false;
 }

 public bool ContainsValue(Values value)
 {
     foreach (Card card in cards)
         if (card.Value == value)
             return true;
     return false;
 }

 public Deck DoYouHaveAny(Values value)
 {
     Deck cardsIHave = cards.PullOutValues(value);
     textBoxOnForm.Text += Name + " has " + cardsIHave.Count + " "
            + Card.Plural(value) + Environment.NewLine;
     return cardsIHave;
 }

        public void AskForACard(IEnumerable<Player> players, int myIndex, Deck stock, Values value)
        {
            List<Player> _players = (List<Player>)players;

            textBoxOnForm.Content +=  name + " asks if anyone has a " + value + "." + Environment.NewLine;

            int cardsAdded = 0;
            for (int playerIndex = 0; playerIndex < _players.Count; playerIndex++)
            {
                if (playerIndex != myIndex)
                {
                    Deck cardsGiven = _players[playerIndex].DoYouHaveAny(value);
                    if (cardsGiven.Count > 0)
                    {
                        while (cardsGiven.Count > 0)
                        {
                            cards.Add(cardsGiven.Deal());
                            cardsAdded++;
                        }
                    }
                }
            }
            textBoxOnForm.Content += Environment.NewLine;

            if (cardsAdded == 0 && stock.Count > 0)
            {
                textBoxOnForm.Content += name + " has to draw from the stock." + Environment.NewLine;
                cards.Add(stock.Deal());
            }
        }

 public static string Plural(Values value)
 {
     if (value == Values.Six)
         return "Sixes";
     else
         return value.ToString() + "s";
 }

        public void ToListening(Command.Endpoint.IInstance commandEndpoint, Values.Version version)
        {
            Context.IListen context = _contextFactory.ForListen(commandEndpoint, version);
            Event.Transition message = _eventFactory.ForStateTransition(context);

            _eventMediator.Publish(message);
        }

 public Deck PullOutValues(Values value)
 {
     Deck deckToReturn = new Deck(new Card[] { });
     for (int i = cards.Count - 1; i >= 0; i--)
         if (cards[i].Value == value)
             deckToReturn.Add(Deal(i));
     return deckToReturn;
 }

 public Move(Columns column, Rows row, Values value, int score = 0)
     : this()
 {
     Row = row;
     Column = column;
     Value = value;
     Score = score;
 }

 public void pileColourCards_init(Values value, Colours colour)
 {
     pileColourCards.Clear();
     foreach (Card item in cardsToPlay)
     {
         if (item.colour == colour)
             pileColourCards.Add(item);
     }
 }

 public IntPtr hasCard(Values value)
 {
     foreach (Card item in cardsToPlay)
     {
         if (item.value == value)
             return new IntPtr(1);
     }
     return new IntPtr(0);
 }

 /// <summary>
 /// Generate a random IISLog
 /// </summary>
 /// <returns></returns>
 public static Values GetRandomIISLog()
 {
     var values = new Values(
         DateTime.UtcNow,
         RandomClientIps[random.Next(RandomClientIps.Count)],
         RandomUris[random.Next(RandomUris.Count)],
         RandomMethods[random.Next(RandomMethods.Count)],
         RandomResponses[random.Next(RandomResponses.Count)]);
     return values;
 }

 public Script(string name, string description, string databaseName, string connectionString, bool wrapInTransaction, Values.Version currentVersion, Values.Version newVersion, string command)
 {
     Name = name;
     Description = description;
     DatabaseName = databaseName;
     ConnectionString = connectionString;
     WrapInTransaction = wrapInTransaction;
     CurrentVersion = currentVersion;
     NewVersion = newVersion;
     Command = command;
 }

 public static bool DoesCardMatch(Card cardToCheck, Values value)
 {
     if (cardToCheck.Value == value)
     {
         return true;
     }
     else
     {
         return false;
     }
 }

 public bool HasBook(Values value)
 {
     int NumberOfCards = 0;
     foreach (Card card in cards)
         if (card.Value == value)
             NumberOfCards++;
     if (NumberOfCards == 4)
         return true;
     else
         return false;
 }

 public Device(Status status, int index, string deviceAddress, string deviceType, string deviceState, Values.SignalStrength signalStrength, Values.LinkQuality linkQuality, Values.BatteryState batteryState, TimeSpan timeSinceLastPacketReceived, int receivedPackets, int sentPackets, params string[] unknown)
 {
     Status = status;
     Index = index;
     DeviceAddress = deviceAddress;
     DeviceType = deviceType;
     DeviceState = deviceState;
     SignalStrength = signalStrength;
     LinkQuality = linkQuality;
     BatteryState = batteryState;
     TimeSinceLastPacketReceived = timeSinceLastPacketReceived;
     ReceivedPackets = receivedPackets;
     SentPackets = sentPackets;
     Unknown = unknown ?? Enumerable.Empty<string>();
 }

        public double GetPrice(Values v)
        {
            switch (v)
            {
                case Values.Nine_DollarsNintyNine:
                    return 9.99;
                case Values.Fourteen_Dollars_NintyNine:
                    return 14.99;
                case Values.Ninteen_Dollars_NintyNine:
                    return 19.99;
                default:
                    return 0;

            }
        }

        public Values.Pick DoesPickRightPick(Values.Pick pick)
        {
            List<IStratergy> strats = new List<IStratergy>();
            var exampleStrat = Substitute.For<IStratergy>();
            exampleStrat.SuggestedPick.Returns(pick);
            exampleStrat.MinimumConfidence.Returns(0);
            exampleStrat.DifficultyRequired.Returns(0);
            exampleStrat.Confidence.Returns(1);
            strats.Add(exampleStrat);
            var ai = new ArtificalIntelligence(strats);

            ai.LoadPlayersMoves(null);

            return ai.Pick;
        }

        /// <summary>
        /// Creates this instance.
        /// </summary>
        /// <returns></returns>
        public static ICollection<Entities.Script> Create(Values.Configuration configuration, Values.ExecutionPlan executionPlan, Domain.Strategies.ConfigInjector configInjector)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            if (executionPlan == null)
            {
                throw new ArgumentNullException("executionPlan");
            }

            if (configInjector == null)
            {
                throw new ArgumentNullException("configInjector");
            }

            var scripts = new List<Entities.Script>();

            foreach (var scriptName in executionPlan.NameOfScriptsToRun)
            {
                var scriptManifest = configuration.Manifest.GetManifest(scriptName);
                if (scriptManifest == null)
                {
                    //TODO: add errors to scripts
                    var message = string.Format(CultureInfo.InvariantCulture, "Could not find script \"{0}\" in the manifest file.", scriptName);
                    log.Error(message);
                    throw new DatabaseScripterException(ErrorCode.CouldNotFindScriptInManifest, message);
                }

                var environmentConfiguration = configuration.EnvironmentConfigurations.Find(executionPlan.Environment);
                if (environmentConfiguration == null)
                {
                    //TODO: add errors to scripts
                    var message = string.Format(CultureInfo.InvariantCulture, "Could not find environment configuration \"{0}\"", executionPlan.Environment);
                    log.Error(message);
                    throw new DatabaseScripterException(ErrorCode.CouldNotFindEnvironmentConfiguration, message);
                }

                var flatScriptConfiguration = environmentConfiguration.GetFlatConfigurationForScript(scriptName);
                var connectionString = configuration.ConnectionStrings[flatScriptConfiguration.Properties.Find("connection").Value].ConnectionString;

                scripts.Add(CreateScript(flatScriptConfiguration, scriptManifest, configuration, configInjector, connectionString));
            }

            return scripts;
        }

 public static string Plural(Values value)
 {
     if (value == Values.Seis)
         return Values.Seis.ToString();
     else
         if (value == Values.As)
             return value.ToString() + "es";
     else
         if (value == Values.Dez)
             return Values.Dez.ToString();
     else
         if (value == Values.Dois)
             return Values.Dois.ToString();
     else
         if (value == Values.Tres)
             return Values.Tres.ToString();
     else
         return value.ToString() + "s";
 }

        public void AskForACard(List<Player> players, int myIndex, Deck stock, Values value)
        {
            /*
                Pergunte para os outros jogadores se eles têm uma valor.
                Primeiro, adicione uma linha a TextBox: "João pergunta se alguém tem algum 8".
                Então, percorra a lista de jogadores passada como parâmetro e pergunte a cada um
                deles se ele tem o valor (usando seu método DoYouHaveAny()). Ele deve passar um baralho
                - adicione ao seu. Controle quantas cartas foram adicionadas. Se não houver nenhuma, você
                mesmo terá lidar com uma do stock (que também foi passado como parâmetro) e você terá que
                adicionar uma linha a TextBox: "João tem que pegar uma carta do stock"
            */

            txtBoxOnForm.Text += string.Format("{0} pergunta se alguém tem algum {1}." + Environment.NewLine, Name, value);

            //foreach (Player player in players)
            //{
            //    player.DoYouHaveAny(value);
            //}

            /**/
            int totalCardsGiven = 0;

            for (int i = 0; i < players.Count; i++)
            {
                if (i != myIndex)
                {
                    Player player = players[i];
                    Deck CardsGiven = player.DoYouHaveAny(value);
                    totalCardsGiven += CardsGiven.Count;
                    while (CardsGiven.Count > 0)
                    {
                        deckCards.Add(CardsGiven.Deal());
                    }
                }
            }
            /**/
            if (totalCardsGiven == 0)
            {
                txtBoxOnForm.Text += Name + " deve tirar do stock." + Environment.NewLine;
            }
            deckCards.Add(stock.Deal());
        }