public ActionResult Index()
    {
        //==== LIST OF PRODUCTIONS - Filter by current and future productions
        var query = db.Productions.Where(p => p.OpeningDay > DateTime.Now || p.IsCurrent == true || (p.OpeningDay <= DateTime.Now && p.ClosingDay >= DateTime.Now))
            .OrderBy(p => p.OpeningDay);
        //===== ORDER PRODUCTIONS
        var orderedProductions = SortProductions(query.ToList());
        //===== PRODUCTION PICTURES - create list of productionPhotos objects for each production, randomize order of photo objects, nest productionPhotos objects list in a list, store list in ViewBag dictionary 
        var productionPhotosList = new List<List<ProductionPhotos>>();
        foreach (Production production in orderedProductions)
        {
            var photoArray = db.ProductionPhotos.Where(p => p.Production.ProductionId == production.ProductionId).ToList();
            productionPhotosList.Add(ShufflePhotos(photoArray));
            //DEBUG System.Diagnostics.Debug.WriteLine(photoArray.Count);
        }
        ViewBag.ProductionPhotosList = productionPhotosList;

        return View(orderedProductions);
    }
    
//===== SHUFFLE PHOTOS - takes a list of ProductionPhoto objects and shuffles them
private static readonly Random random = new Random();

private List<ProductionPhotos> ShufflePhotos(List<ProductionPhotos> photos)
    {
        int n = photos.Count;
        while (n > 1)
        {
            n--;
            int rnd = random.Next(n + 1);
            ProductionPhotos value = photos[rnd];
            photos[rnd] = photos[n];
            photos[n] = value;
        }
        return photos;
    }    

public ActionResult Create([Bind(Include = "PartID,Production,Person,Character,Type,Details")] Part part)
    {
        //=== VALIDATION - PRODUCTION check if selected from dropdown
        if (Request.Form["Production"] != "")
        {
            int productionID = Convert.ToInt32(Request.Form["Production"]);
            var production = db.Productions.Find(productionID);
            part.Production = production;
            ModelState.Remove("Production"); // manual remove error - throws by default due to Part model [Required] validation can't match to dropdown
        }
        //=== VALIDATION - PERSON check if selected from dropdown
        if (Request.Form["Person"] != "")
        {
            int castID = Convert.ToInt32(Request.Form["Person"]);
            var person = db.CastMembers.Find(castID);
            part.Person = person;
            ModelState.Remove("Person"); // manual remove error - throws by default due to Part model [Required] validation can't match to dropdown
        }
        //=== VALIDATION - FORM
        if (ModelState.IsValid)
        {
            //=== IS VALID - lookup production and cast member objects based on form value "Id" for each
            db.Parts.Add(part);
            db.SaveChanges();
            return RedirectToAction("Index");
        }
        else
        {
            //=== NOT VALID - reload dropdown menus then return part to view 
            ViewData["dbUsers"] = new SelectList(db.Users.ToList(), "Id", "UserName");
            ViewData["CastMembers"] = new SelectList(db.CastMembers.ToList(), "CastMemberId", "Name");
            ViewData["Productions"] = new SelectList(db.Productions.ToList(), "ProductionId", "Title");
            return View(part);
        }            
    }

public ActionResult Create([Bind(Include = "ProductionId,Title,Playwright,Description,Runtime,OpeningDay,ClosingDay,DefaultPhoto,ShowtimeEve,ShowtimeMat,TicketLink,Season,IsCurrent,IsWorldPremiere")] Production production, HttpPostedFileBase uploadFile)
{
    //========== VALIDATION
    //===== PHOTO - Check if photo is not null but not a valid photo format
    if (uploadFile != null && !PhotoController.ValidatePhoto(uploadFile))
    {
        ModelState.AddModelError("DefaultPhoto", "File must be a valid photo format.");
        ViewData["upload_file"] = uploadFile;
    }
    if (ModelState.IsValid)
    {
        //========== DEFAULT PHOTO ==========
        //--- save photo using photo controller, save entry to ProductionPhotos, photoName set to production title, description set to "Default Photo"
        if (uploadFile != null)
        {
            //----- Save New Photo or retrieve existing photo if the same - using photo controller
            Debug.WriteLine("Saving photo...");
            int photoId = PhotoController.CreatePhoto(uploadFile, production.Title);
            //----- Save New ProductionPhoto
            var productionPhoto = new ProductionPhotos() { PhotoId = photoId, Title = production.Title, Description = "Default Photo" };
            db.ProductionPhotos.Add(productionPhoto);
            db.SaveChanges();
            //----- Save New Production, add DefaultPhoto object reference to production
            production.DefaultPhoto = productionPhoto;
            db.Productions.Add(production);
            db.SaveChanges();
            //----- Add Production object reference to productionPhoto
            productionPhoto.Production = production;
            db.Entry(productionPhoto).State = EntityState.Modified;
            db.SaveChanges();
        }
        //========== NO PHOTO ==========
        else
        {
            db.Productions.Add(production);
            db.SaveChanges();
        }
        return RedirectToAction("Index");
    }
    return View(production);
}

//========== VALIDATE PHOTO - Test if input is photo, return True if a photo format
public static bool ValidatePhoto(HttpPostedFileBase postedFile)
{
    Debug.WriteLine("Validating photo...");
    const int ImageMinimumBytes = 512;
    //-------------------------------------------
    //  Check the image mime types
    //-------------------------------------------
    if (!string.Equals(postedFile.ContentType, "image/jpg", StringComparison.OrdinalIgnoreCase) &&
        !string.Equals(postedFile.ContentType, "image/jpeg", StringComparison.OrdinalIgnoreCase) &&
        !string.Equals(postedFile.ContentType, "image/pjpeg", StringComparison.OrdinalIgnoreCase) &&
        !string.Equals(postedFile.ContentType, "image/gif", StringComparison.OrdinalIgnoreCase) &&
        !string.Equals(postedFile.ContentType, "image/x-png", StringComparison.OrdinalIgnoreCase) &&
        !string.Equals(postedFile.ContentType, "image/png", StringComparison.OrdinalIgnoreCase))
    {
        return false;
    }

    //-------------------------------------------
    //  Check the image extension
    //-------------------------------------------
    var postedFileExtension = Path.GetExtension(postedFile.FileName);
    if (!string.Equals(postedFileExtension, ".jpg", StringComparison.OrdinalIgnoreCase)
        && !string.Equals(postedFileExtension, ".png", StringComparison.OrdinalIgnoreCase)
        && !string.Equals(postedFileExtension, ".gif", StringComparison.OrdinalIgnoreCase)
        && !string.Equals(postedFileExtension, ".jpeg", StringComparison.OrdinalIgnoreCase))
    {
        return false;
    }

    //-------------------------------------------
    //  Attempt to read the file and check the first bytes
    //-------------------------------------------
    try
    {
        if (!postedFile.InputStream.CanRead)
        {
            return false;
        }
        //----- Check whether the image size below the lower limit or not
        if (postedFile.ContentLength < ImageMinimumBytes)
        {
            return false;
        }
        //----- Read the file
        byte[] buffer = new byte[ImageMinimumBytes];
        postedFile.InputStream.Read(buffer, 0, ImageMinimumBytes);
        string content = System.Text.Encoding.UTF8.GetString(buffer);
        if (Regex.IsMatch(content, @"<script|<html|<head|<title|<body|<pre|<table|<a\s+href|<img|<plaintext|<cross\-domain\-policy",
            RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Multiline))
        {
            return false;
        }
    }
    catch (Exception)
    {
        return false;
    }
    //-------------------------------------------
    //  Try to instantiate new Bitmap to see if .NET will throw exception
    //-------------------------------------------
    try
    {
        using (var bitmap = new Bitmap(postedFile.InputStream))
        {
        }
    }
    catch (Exception)
    {
        return false;
    }
    finally
    {
        postedFile.InputStream.Position = 0;
    }
    return true;
}

public ActionResult Create([Bind(Include = "ProductionId,Title,Playwright,Description,Runtime,OpeningDay,ClosingDay,DefaultPhoto,ShowtimeEve,ShowtimeMat,TicketLink,Season,IsCurrent,IsWorldPremiere")] Production production, HttpPostedFileBase uploadFile)
{
    //========== VALIDATION ==========
    //===== PHOTO - Check if photo is not null but not a valid photo format
    if (uploadFile != null && !PhotoController.ValidatePhoto(uploadFile))
    {
        ModelState.AddModelError("DefaultPhoto", "File must be a valid photo format.");                
    }
    //===== SHOWTIME - at list one (ShowtimeEve, ShowtimeMat) need to be assigned 
    if (production.ShowtimeEve == null && production.ShowtimeMat == null)
    {
        ModelState.AddModelError("ShowtimeEve", "At least one showtime must be specified.");
        ModelState.AddModelError("ShowtimeMat", "At least one showtime must be specified.");
    }
    //========== SAVE ==========
    if (ModelState.IsValid)
    {
        //===== DEFAULT PHOTO 
        //--- save photo using photo controller, save entry to ProductionPhotos, photoName set to production title, description set to "Default Photo"
        if (uploadFile != null)
        {
            //----- Save New Photo or retrieve existing photo if the same - using photo controller
            Debug.WriteLine("Saving photo...");
            int photoId = PhotoController.CreatePhoto(uploadFile, production.Title);
            //----- Save New ProductionPhoto
            var productionPhoto = new ProductionPhotos() { PhotoId = photoId, Title = production.Title, Description = "Default Photo" };
            db.ProductionPhotos.Add(productionPhoto);
            db.SaveChanges();
            //----- Save New Production, add DefaultPhoto object reference to production
            production.DefaultPhoto = productionPhoto;
            db.Productions.Add(production);
            db.SaveChanges();
            //----- Add Production object reference to productionPhoto
            productionPhoto.Production = production;
            db.Entry(productionPhoto).State = EntityState.Modified;
            db.SaveChanges();
        }
        //===== NO PHOTO 
        else
        {
            db.Productions.Add(production);
            db.SaveChanges();
        }
        return RedirectToAction("Index");
    }
    return View(production);
}

namespace Blackjack
{
    class Program
    {
        static void Main(string[] args)
        {
            //========== CASINO NAME
            const string casinoName = "Grand Hotel and Casino";

            //========== LOG FILE
            string logDir = Directory.GetCurrentDirectory() + @"\logs";
            string logFile = logDir + @"\log.txt";
            if (!Directory.Exists(logDir)) Directory.CreateDirectory(logDir);
            string logTxt = string.Format("========== BLACKJACK LOG ==========\n{0}\n", DateTime.Now);
            File.WriteAllText(logFile, logTxt);

            //========== GAME SETUP
            Console.BackgroundColor = ConsoleColor.DarkGreen;
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.Clear();
            Console.WriteLine("\n===================================================\n=====( Welcome to the {0} )=====\n===================================================\n", casinoName);
            Game game = new BlackjackGame();

            //========== ADD PLAYERS
            const int maxPlayers = 7;
            bool addPlayers = true;
            string playerName;            

            while (addPlayers && game.Players.Count < maxPlayers)
            {
                Console.WriteLine("\nPlayer, what is your name?");
                playerName = Console.ReadLine();
                playerName = playerName[0].ToString().ToUpper() + playerName.Substring(1);
                //===== ADMIN ENTRY
                if (playerName == "Admin")
                {
                    List<ExceptionEntity> exceptions = ReadExceptions();
                    foreach (var e in exceptions)
                    {
                        Console.Write(e.Id + " | ");
                        Console.Write(string.Format("{0} | ", e.ExceptionType));
                        Console.Write(string.Format("{0} | ", e.ExceptionMessage));
                        Console.WriteLine(string.Format("{0} \n", e.TimeStamp));                        
                    }
                    Console.Read();
                    return;
                }
                //===== PLAYER ENTRY
                Player player = new Player(playerName); // asks for player bank if not provided
                if (player.Balance > 0)
                {
                    Console.WriteLine("Hello {0}. Would you like to join a game of Blackjack right now?", playerName);
                    if (Console.ReadLine().ToLower().Contains("y"))
                    {
                        game += player;
                        Console.WriteLine("-->{0} added to game.", playerName);
                    }                    
                }
                if (game.Players.Count < maxPlayers)
                {
                    Console.WriteLine("\nIs someone else joining today?");
                    if (Console.ReadLine().ToLower().Contains("n")) addPlayers = false;
                }
            }
            
            //========== PLAY - continue to play rounds until NO players are actively playing or have a balance > 0
            while (game.Players.Count > 0)
            {
                //----- Play game
                try
                {
                    game.Play();
                }
                catch (FraudException e)
                {
                    UpdateDbException(e);
                    Console.WriteLine("SECURITY! Throw this person out.");
                    Console.ReadLine();
                    return;
                }
                catch (Exception e)
                {
                    UpdateDbException(e);
                    Console.WriteLine("ERROR. Please contact your system administrator.");
                    Console.WriteLine("ERROR: " + e.Message);
                    Console.ReadLine();
                    return;
                }
                //----- Player removal
                List<Player> removals = new List<Player>();
                removals = game.Players.Where(x => !x.ActivelyPlaying || x.Balance == 0).ToList();
                foreach (Player player in removals)
                {
                    game -= player;
                }                
            }
            
            //========== GAME OVER
            Console.WriteLine("\n===Thank you for playing.");
            Console.WriteLine("Feel free to look aroung the casino. Bye for now.");


            //========== TESTS ==========

            //string str1 = "Here is some text.\nMore on a new line.\tHere is some after a tab.";
            //File.WriteAllText(logFile, str1);

            //string txt = File.ReadAllText(logFile);
            //Console.WriteLine(txt);


            //===== CREATE DECK
            //Deck deck = new Deck();

            //===== SHUFFLE DECK
            //deck.Shuffle(times: 4, true);

            //===== lambda functions
            //int count = deck.Cards.Count(x => x.Face == Face.Ace); 
            //Console.WriteLine(count);

            //List<Card> newList = deck.Cards.Where(x => x.Face == Face.Ace).ToList();
            //foreach (Card card in newList) { Console.WriteLine(card.Face); }

            //List<int> numList = new List<int>() { 1,2,3,535,342,23 };
            //int sum = numList.Sum();
            //Console.WriteLine(sum);
            //int sumPlus = numList.Sum(x => x + 1);
            //Console.WriteLine(sumPlus);
            //int max = numList.Max();
            //Console.WriteLine(max);
            //int min = numList.Min();
            //Console.WriteLine(min);
            //int sumBig = numList.Where(x => x > 100).Sum();
            //Console.WriteLine(sumBig);
            //Console.WriteLine(numList.Where(x => x > 100).Sum());

            //===== Overloaded operator
            //Game game = new BlackjackGame() { Name = "BlackJack", Dealer = "Doc Holliday", Players = new List<Player>() };
            //Player p1 = new Player() { Name = "Wyatt Earp" };
            //Player p2 = new Player() { Name = "Jesse James" };
            //game = game + p1 + p2;
            //game.ListPlayers();
            //game = game - p2;
            //game.ListPlayers();

            //deck.ListCards(loop: "foreach");

            //Dealer dealer = new Dealer();
            //dealer.Name = "Alex";
            //Console.WriteLine(dealer.Name); // can get/set public properties when base class is not explicitly public

            //Game game2 = new Game(); // can't create a new object based on an abstract class

            //===== HOLD OPEN - till enter is pressed
            Console.ReadLine();
        }

        private static void UpdateDbException(Exception e)
        {
            string connectionStr = @"Data Source = (localdb)\MSSQLLocalDB; Initial Catalog = BalckjackGame; Integrated Security = True; Connect Timeout = 30; Encrypt = False; TrustServerCertificate = False; ApplicationIntent = ReadWrite; MultiSubnetFailover = False";
            string queryStr = @"INSERT INTO Exceptions (ExceptionType, ExceptionMessage, TimeStamp) VALUES
                                (@ExceptionType, @ExceptionMessage, @TimeStamp)";
            using (SqlConnection connection = new SqlConnection(connectionStr))
            {
                SqlCommand command = new SqlCommand(queryStr, connection);
                command.Parameters.Add("@ExceptionType", SqlDbType.VarChar);
                command.Parameters.Add("@ExceptionMessage", SqlDbType.VarChar);
                command.Parameters.Add("@TimeStamp", SqlDbType.DateTime);
                command.Parameters["@ExceptionType"].Value = e.GetType().ToString();
                command.Parameters["@ExceptionMessage"].Value = e.Message;
                command.Parameters["@TimeStamp"].Value = DateTime.Now;

                connection.Open();
                command.ExecuteNonQuery();
                connection.Close();
            }
        }
        private static List<ExceptionEntity> ReadExceptions()
        {
            string connectionStr = @"Data Source = (localdb)\MSSQLLocalDB; Initial Catalog = BalckjackGame; Integrated Security = True; Connect Timeout = 30; Encrypt = False; TrustServerCertificate = False; ApplicationIntent = ReadWrite; MultiSubnetFailover = False";
            string queryStr = @"SELECT Id, ExceptionType, ExceptionMessage, TimeStamp FROM Exceptions";
            List<ExceptionEntity> exceptions = new List<ExceptionEntity>();
            
            using (SqlConnection connection = new SqlConnection(connectionStr))
            {
                SqlCommand command = new SqlCommand(queryStr, connection);
                
                connection.Open();
                SqlDataReader reader = command.ExecuteReader();
                while (reader.Read())
                {
                    ExceptionEntity e = new ExceptionEntity(Convert.ToInt32(reader["Id"]), reader["ExceptionType"].ToString().Trim(), reader["ExceptionMessage"].ToString().Trim(), Convert.ToDateTime(reader["TimeStamp"]));
                    exceptions.Add(e);
                }
                connection.Close();
            }
            return exceptions;
        }
    }
}

namespace Casino.Blackjack
{
    public class BlackjackGame : Game, IWalkAway
    {
        //===== CONSTRUCTOR
        public BlackjackGame() : base()
        {
            // using constructor from base Class "Game"
            // creates new instances of Players, Bets
            Dealer = new BlackjackDealer("", 0);
        }

        //===== PROPERTIES
        public BlackjackDealer Dealer { get; set; }

        //===== PLAY
        public override void Play() //override satisfies the requirement for this child to have the parent method
        {
            //----- START set Dealer and declare variables at the beginning of game 
            if (Dealer.Name == "") 
            {
                Dealer = new BlackjackDealer(name: "Doc Holliday", bank: int.MaxValue);
                ListPlayers();
            }
            int bet;
            bool isValid, winner;

            //----- RESET each round
            Dealer.Stay = Dealer.Blackjack = winner = false;
            Dealer.Hand = new List<Card>();
            Dealer.Deck = new Deck(deckCount:Players.Count);
            foreach (Player p in Players)
            {
                p.Hand = new List<Card>();
                p.Stay = false;
            }

            //----- BET for each player
            Console.WriteLine("\n=== Place Bets...");
            foreach (Player p in Players)
            {
                isValid = false;
                while (!isValid)
                {
                    try
                    {
                        Console.WriteLine("{0} your bet:", p.Name);
                        bet = Convert.ToInt32(Console.ReadLine());
                        if (p.Bet(bet)) 
                        { 
                            isValid = true;
                            Bets[p] = bet;
                        }                        
                    }
                    catch (FraudException)
                    {
                        p.ActivelyPlaying = false;
                        throw new FraudException(string.Format("Security! {0} has tried to commit fraud",p.Name));
                        // Console.WriteLine("SECURITY! Throw this person out.");
                        // Console.ReadLine();
                        // return;
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("Oops...something went wrong:");
                        Console.WriteLine(e.Message);
                    }
                }   
            }

            //----- DEAL START
            Console.WriteLine("\n=== Dealing...");
            for (int i = 0; i < 2; i++)
            {
                Dealer.Deal(Dealer.Hand, Dealer.Name);
                foreach (Player p in Players) Dealer.Deal(p.Hand, p.Name);                
            }
            
            //----- CHECK BLACKJACK - If dealer has Blackjack all players lose except those that also have Blackjack (Draw)
            Dealer.Blackjack = BlackjackRules.CheckBlackjack(Dealer.Hand);
            if (Dealer.Blackjack)
            {
                //--- Dealer Blackjack, all payouts, return
                Console.WriteLine("\n=== Dealer gets Blackjack!");
                foreach (Player p in Players)
                {
                    if (BlackjackRules.CheckBlackjack(p.Hand))
                    {
                        //--- DRAW player blackjack
                        Dealer.Payout(Dealer, p, Bets, condition:"draw");                                                
                    }
                    else
                    {
                        //--- LOSE no blackjack
                        Dealer.Payout(Dealer, p, Bets, condition: "lose");
                    }                    
                }
                return;
            }
            else
            {
                //--- Dealer no Blackjack, check player Blackjack, payout if winner
                winner = Players.Any(p => BlackjackRules.CheckBlackjack(p.Hand));
                if (winner)
                {
                    foreach (Player p in Players)
                    {
                        if (BlackjackRules.CheckBlackjack(p.Hand))
                        {
                            Dealer.Payout(Dealer, p, Bets, condition: "blackjack");
                        }                        
                    }                    
                }
            }

            //----- CONTINUE PLAY
            Console.WriteLine("\n=== Continue Play...");
            foreach (Player p in Players)
            {
                while (!p.Stay)
                {
                    //--- Hand display
                    Console.WriteLine("\nDealer hand:");
                    foreach (Card c in Dealer.Hand) Console.WriteLine("- {0}", c.ToString());
                    Console.WriteLine("\n{0} your cards are:", p.Name);
                    foreach (Card c in p.Hand) Console.WriteLine("- {0}", c.ToString());
                    
                    //--- Hit or Stay
                    Console.WriteLine("\n Hit or Stay?");
                    if (Console.ReadLine().ToLower().Contains("s")) 
                    {
                        p.Stay = true;
                        break;
                    }
                    else
                    {
                        Dealer.Deal(p.Hand, p.Name);
                    }
                    
                    //--- Check Busted
                    if (BlackjackRules.CheckBusted(p.Hand)) Dealer.Payout(Dealer, p, Bets, condition: "bust");                    
                }
            }

            //----- DEALER PLAY
            if (Bets.Count() == 0) return; // check if all players are out
            Dealer.Stay = BlackjackRules.CheckDealerStay(Dealer.Hand);
            while (!Dealer.Stay && !Dealer.Bust)
            {
                Console.WriteLine("\n=== Dealer is hitting...");
                Dealer.Deal(Dealer.Hand, Dealer.Name);
                Dealer.Bust = BlackjackRules.CheckBusted(Dealer.Hand);
                Dealer.Stay = BlackjackRules.CheckDealerStay(Dealer.Hand);
            }
            
            //----- DEALER BUST
            if (Dealer.Bust)
            {
                Console.WriteLine("\n=== Dealer Busted!");
                //--- PAYOUT function - pay only thoses players that still have bets
                foreach (Player p in Players.Where(x=> Bets.ContainsKey(x)))
                {
                    Dealer.Payout(Dealer, p, Bets, condition: "win");
                }
                
                ////--- ALTERNATIVE - Lambda function method
                //foreach (KeyValuePair<Player, int> entry in Bets)
                //{    
                //    Players.Where(p => p == entry.Key).First().Balance += (entry.Value * 2);
                //}                
            }
            //----- DEALER STAY - check only thoses players that still have bets
            else if (Dealer.Stay)
            {
                Console.WriteLine("\n=== Dealer is staying.");
                foreach (Player p in Players.Where(x => Bets.ContainsKey(x))) 
                {
                    switch (BlackjackRules.CheckWin(Dealer.Hand, p.Hand))
                    {
                        case true: //--- player win
                            Dealer.Payout(Dealer, p, Bets, condition: "win");
                            break;
                        case false: //--- dealer win
                            Dealer.Payout(Dealer, p, Bets, condition: "lose");
                            break;
                        default: //--- draw
                            Dealer.Payout(Dealer, p, Bets, condition: "draw");
                            break;                        
                    }
                }                
            }
            return;
        }

        //===== LIST PLAYERS
        public override void ListPlayers()
        {
            Console.WriteLine("===== Welcome To BLACKJACK =====");
            Console.WriteLine("Your dealer is {0}.", Dealer.Name);
            base.ListPlayers(); // this line is the same as all the code within base class method
        }
        //===== WALK AWAY
        public void WalkAway(Player player)
        {
            throw new NotImplementedException();
        }   
        
    }
}

namespace Casino.Blackjack
{
    public class BlackjackRules
    {
        //===== PROPERTIES
        private static Dictionary<Face, int> _cardValues = new Dictionary<Face, int>()
        {
            [Face.Two] = 2,
            [Face.Three] = 3,
            [Face.Four] = 4,
            [Face.Five] = 5,
            [Face.Six] = 6,
            [Face.Seven] = 7,
            [Face.Eight] = 8,
            [Face.Nine] = 9,
            [Face.Ten] = 10,
            [Face.Jack] = 10,
            [Face.Queen] = 10,
            [Face.King] = 10,
            [Face.Ace] = 1
        };

        //===== GET ALL HAND VALUES
        private static int[] GetAllHandValues(List<Card> Hand)
        {
            int aceCount = Hand.Count(x => x.Face == Face.Ace);
            int[] result = new int[aceCount + 1];
            int value = Hand.Sum(x => _cardValues[x.Face]);
            result[0] = value;
            if (result.Length == 1) // triggered only if no Aces
            { 
                return result; 
            }
            else
            {
                for (int i = 1; i < result.Length; i++)
                {
                    value += (i * 10);
                    result[i] = value;
                }
                return result;
            }       
        }
        
        //===== CHECK BLACKJACK
        public static bool CheckBlackjack(List<Card> Hand)
        {
            if (Hand.Count == 2) { return (GetAllHandValues(Hand).Max() == 21) ? true : false; }
            return false;
            //---- VERBOSE option
            //if (Hand.Count == 2)
            //{
            //    int[] possibleValues = GetAllHandValues(Hand);
            //    int value = possibleValues.Max();
            //    if (value == 21)
            //    {
            //        return true;
            //    }
            //    else
            //    {
            //        return false;
            //    }
            //}
            //return false;
        }

        //===== CHECK BUSTED
        public static bool CheckBusted(List<Card> Hand)
        {
            return (GetAllHandValues(Hand).Min() > 21) ? true : false;
        }

        //===== CHECK DEALER STAY
        public static bool CheckDealerStay(List<Card> Hand)
        {
            return (GetAllHandValues(Hand).Any(x => x > 16 && x < 22)) ? true : false;
        }

        //===== CHECK WIN
        public static bool? CheckWin(List<Card> dealerHand, List<Card> playerHand)
        {
            int dealerScore = GetAllHandValues(dealerHand).Where(x => x < 22).Max();
            int playerScore = GetAllHandValues(playerHand).Where(x => x < 22).Max();
            if (playerScore > dealerScore) return true;
            else if (playerScore < dealerScore) return false;
            else return null;
        }
    }
}

namespace Casino
{
    public class Deck
    {
        //========== CONSTRUCTOR
        public Deck(int deckCount=1)
        {
            Cards = new List<Card>();
            //===== DECKS - iterate for a number of decks
            for (int d=0; d < deckCount; d++)
            {
                //===== ENUM - construct a deck of cards using enum datatype
                for (int f = 0; f < Enum.GetNames(typeof(Face)).Length; f++) // using the GetNames() method to build an array to get the length of
                {
                    for (int s = 0; s < Enum.GetNames(typeof(Suit)).Length; s++) // using the GetNames() method to build an array to get the length of
                    {
                        Card card = new Card();
                        card.Face = (Face)f;
                        card.Suit = (Suit)s;
                        Cards.Add(card);
                    }
                }
            }
            Console.WriteLine("Created a deck of {0} cards.", Cards.Count);
            
            //===== SHUFFLE DECK - automatically shuffle deck 4 times when new deck is created
            Shuffle(times: 4, display: false);

            //===== STRING - UNUSED alternative, construct a deck of cards using strings
            //string[] Suits = { "Clubs", "Diamonds", "Hearts", "Spades" };
            //string[] Faces = { "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King", "Ace" };
            //foreach (string f in Faces)
            //{
            //    foreach (string s in Suits)
            //    {
            //        Card card = new Card();
            //        card.Suit = s;
            //        card.Face = f;
            //        Cards.Add(card);
            //    }
            //} 
        }

        //========== PROPERTIES
        Random random = new Random();
        public List<Card> Cards { get; set; }

        //========== SHUFFLE method - input number of time to shuffle, set the default shuffle times to 1 if not provided
        public void Shuffle(int times=1, bool display=false)
        {
            List<Card> tempList;
            int rIndex;
            int sCount = 0;
            for (int i=0; i < times; i++)
            {
                tempList = new List<Card>();
                while (Cards.Count > 0)
                {
                    rIndex = random.Next(0, Cards.Count);
                    tempList.Add(Cards[rIndex]);
                    Cards.RemoveAt(rIndex);
                }
                Cards = tempList;
                if (display) { Console.WriteLine("A shuffle complete. Top card in deck is now {0} of {1}", Cards[0].Face, Cards[0].Suit); }
                sCount++;                
            }
            if (display) { Console.WriteLine((sCount == 1) ? "Shuffled 1 time" : String.Format("Shuffled {0} times.", sCount)); }
        }

        //========== LIST CARDS
        public void ListCards(string loop="for")
        {
            if (loop == "for")
            {
                //===== PRINT LIST OF CARDS
                Console.WriteLine("===== SHOW CARDS - using for loop");
                for (int i = 0; i < Cards.Count; i++)
                {
                    Console.WriteLine(Cards[i].Face + " of " + Cards[i].Suit);
                }
            }
            else
            {
                //===== PRINT LIST OF CARDS
                Console.WriteLine("===== SHOW CARDS - using foreach loop");
                foreach (Card c in Cards)
                {
                    Console.WriteLine(c.Face + " of " + c.Suit);
                }
            }          
        }
    }
}