KoogleV4/GameModel/PinPicture.cs

using GameModel.Exceptions;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Net.NetworkInformation;
using System.Text;
using System.Threading.Tasks;

namespace GameModel
{
    public record PinPicture : IEnumerable<PinState>, IEnumerable
    {
        private readonly List<PinState> pins = new List<PinState>();
        public PinPicture() : this(PinState.Up, PinState.Up, PinState.Up, PinState.Up, PinState.Up, PinState.Up, PinState.Up, PinState.Up, PinState.Up)
        {
             
        }

        public PinPicture(PinState pinState1, PinState pinState2, PinState pinState3, PinState pinState4, PinState pinState5, PinState pinState6, PinState pinState7, PinState pinState8, PinState pinState9)
        {
            pins.Add(pinState1);
            pins.Add(pinState2);
            pins.Add(pinState3);
            pins.Add(pinState4);
            pins.Add(pinState5);
            pins.Add(pinState6);
            pins.Add(pinState7);
            pins.Add(pinState8);
            pins.Add(pinState9);
            //ValidatePinPicture(pins);
        }

        //private PinPicture(IEnumerable<PinState> pins)
        //{
        //    this.pins = pins.Select(_ => _).ToList();            
        //    ValidatePinPicture(this.pins);
        //}

        private void ValidatePinPicture(IEnumerable<PinState> pins)
        {
            //if (pins.Count() != 9)
            //{
            //    throw new InvalidPinPictureException();
            //}

            //if (pins.All(_ => _ == PinState.Down))
            //{
            //    throw new InvalidPinPictureException();
            //}

            //if (pins.Count(_ => _ == PinState.Up) == 0)
            //{
            //    throw new InvalidPinPictureException();
            //}

            //if (ThrowCounter >= ThrowsPerRound)
            //{
            //    throw new InvalidPinPictureException();
            //}
        }

        public PinState this[int index]
        {
            get
            {
                if (index < 1 || index > 9)
                {
                    throw new InvalidPinIndexException();
                }

                return pins[index - 1];
            }
            set 
            {
                if (index < 1 || index > 9)
                {
                    throw new InvalidPinIndexException();
                }
                pins[index - 1] = value;
            }
        }

        public PinState PinState1 { get { return this[1]; } set { this[1] = value; } }
        public PinState PinState2 { get { return this[2]; } set { this[2] = value; } }
        public PinState PinState3 { get { return this[3]; } set { this[3] = value; } }
        public PinState PinState4 { get { return this[4]; } set { this[4] = value; } }
        public PinState PinState5 { get { return this[5]; } set { this[5] = value; } }
        public PinState PinState6 { get { return this[6]; } set { this[6] = value; } }
        public PinState PinState7 { get { return this[7]; } set { this[7] = value; } }
        public PinState PinState8 { get { return this[8]; } set { this[8] = value; } }
        public PinState PinState9 { get { return this[9]; } set { this[9] = value; } }

        public int UpCount
        {
            get { return pins.Count(_ => _ == PinState.Up); }
        }

        public int DownCount
        {
            get { return pins.Count(_ => _ == PinState.Down); }
        }

        public bool AllUp
        {
            get
            {
                // count down-pins to respect na-pins
                return DownCount == 0;
            }
        }

        public static PinPicture operator +(PinPicture pic, PinThrow pinThrow)
        {
            if (pinThrow.IsSink)
                return pic with { };

            return pic with
            {
                PinState1 = pinThrow.PicPicture.PinState1 == PinState.Down ? PinState.Down : pic.PinState1,
                PinState2 = pinThrow.PicPicture.PinState2 == PinState.Down ? PinState.Down : pic.PinState2,
                PinState3 = pinThrow.PicPicture.PinState3 == PinState.Down ? PinState.Down : pic.PinState3,
                PinState4 = pinThrow.PicPicture.PinState4 == PinState.Down ? PinState.Down : pic.PinState4,
                PinState5 = pinThrow.PicPicture.PinState5 == PinState.Down ? PinState.Down : pic.PinState5,
                PinState6 = pinThrow.PicPicture.PinState6 == PinState.Down ? PinState.Down : pic.PinState6,
                PinState7 = pinThrow.PicPicture.PinState7 == PinState.Down ? PinState.Down : pic.PinState7,
                PinState8 = pinThrow.PicPicture.PinState8 == PinState.Down ? PinState.Down : pic.PinState8,
                PinState9 = pinThrow.PicPicture.PinState9 == PinState.Down ? PinState.Down : pic.PinState9
            };
        }

        public IEnumerator<PinState> GetEnumerator()
        {
            foreach (var pin in pins)
            {
                yield return pin;
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }
    }
}