#region Instructions

/*

 * You are tasked with writing an algorithm that determines the value of a used car, 

 * given several factors.

 * 

 *    AGE:    Given the number of months of how old the car is, reduce its value one-half 

 *            (0.5) percent.

 *            After 10 years, it's value cannot be reduced further by age. This is not 

 *            cumulative.

 *            

 *    MILES:    For every 1,000 miles on the car, reduce its value by one-fifth of a

 *              percent (0.2). Do not consider remaining miles. After 150,000 miles, it's 

 *              value cannot be reduced further by miles.

 *            

 *    PREVIOUS OWNER:    If the car has had more than 2 previous owners, reduce its value 

 *                       by twenty-five (25) percent. If the car has had no previous  

 *                       owners, add ten (10) percent of the FINAL car value at the end.

 *                    

 *    COLLISION:        For every reported collision the car has been in, remove two (2) 

 *                      percent of it's value up to five (5) collisions.

 *                    

 * 

 *    Each factor should be off of the result of the previous value in the order of

 *        1. AGE

 *        2. MILES

 *        3. PREVIOUS OWNER

 *        4. COLLISION

 *        

 *    E.g., Start with the current value of the car, then adjust for age, take that  

 *    result then adjust for miles, then collision, and finally previous owner. 

 *    Note that if previous owner, had a positive effect, then it should be applied 

 *    AFTER step 4. If a negative effect, then BEFORE step 4.

 */

#endregion

​

using System;

using NUnit.Framework;

​

namespace CarPricer

{

    public class Car

    {

        public decimal PurchaseValue { get; set; }

        public int AgeInMonths { get; set; }

        public int NumberOfMiles { get; set; }

        public int NumberOfPreviousOwners { get; set; }

        public int NumberOfCollisions { get; set; }

    }

​

​

​

    public class PriceDeterminator

    {

        public decimal DetermineCarPrice(Car car)

        {

             var carFinalPrice =0m;

              var  agediscount=DetermineAgeDiscount(car.AgeInMonths);

              var priceWithAgeDiscount=35000m-(car.PurchaseValue*agediscount);

              var milesDiscount=priceWithAgeDiscount*DetermineMilesDiscount(car.NumberOfMiles);

              var priceWithMilesdiscount= priceWithAgeDiscount-milesDiscount;

             if (car.NumberOfPreviousOwners>0)

             {

              var  ownerDiscount=priceWithMilesdiscount*DetermineOwnerDiscount(car.NumberOfPreviousOwners);

              var priceWithOwnerDiscount=priceWithMilesdiscount-ownerDiscount;

              var collisionDiscount=priceWithOwnerDiscount*(DetermineCollisionsDiscount(car.NumberOfCollisions));

              var PriceWithCollisionDiscount=priceWithOwnerDiscount-collisionDiscount;

              carFinalPrice= PriceWithCollisionDiscount;

             }else{

                 var collisionDiscount=priceWithMilesdiscount*DetermineCollisionsDiscount(car.NumberOfCollisions);

                 var PriceWithCollisionDiscount=priceWithMilesdiscount-collisionDiscount;

                 var  ownerDiscount=PriceWithCollisionDiscount*DetermineOwnerDiscount(car.NumberOfPreviousOwners);

                carFinalPrice= PriceWithCollisionDiscount+ownerDiscount;

             }

            return carFinalPrice;

        }

            private decimal DetermineMilesDiscount(Int32 miles)

        {

            if (miles>150000)

            {

            return (150000/1000)*0.002m;

            }else

            {

                return (miles/1000)*0.002m;;

            }

​

        }

        private decimal DetermineOwnerDiscount(Int32 owners)

        {

            if (owners==0)

            {

            return 0.1m;

            }

            else if (owners>2)

            {

                return  0.25m;

            }

            else{

            return 0m;

            }

​

        }

        private decimal DetermineAgeDiscount (Int32 ageInMonths){

            var yearsInMonths=ageInMonths/12;

            if (yearsInMonths>10)

            {

            return 120*0.005m;

            }else

            {

            return ageInMonths*0.005m;

            }

        }

            private decimal DetermineCollisionsDiscount (Int32 collisions)

            {

            return collisions>5?5*0.02m:collisions*0.02m;

        }

    }

​

    public class UnitTests

    {

        public void CalculateCarValue()

        {

            AssertCarValue(25313.40m, 35000m, 3 * 12, 50000,  1, 1);

           AssertCarValue(19688.20m, 35000m, 3 * 12, 150000, 1, 1);

           AssertCarValue(19688.20m, 35000m, 3 * 12, 250000, 1, 1);

           AssertCarValue(20090.00m, 35000m, 3 * 12, 250000, 1, 0);

           AssertCarValue(21657.02m, 35000m, 3 * 12, 250000, 0, 1);

        }

​

        private static void AssertCarValue(decimal expectValue, decimal purchaseValue, 

        int ageInMonths, int numberOfMiles, int numberOfPreviousOwners, int 

        numberOfCollisions)

        {

            Car car = new Car

                        {

                            AgeInMonths = ageInMonths,

                            NumberOfCollisions = numberOfCollisions,

                            NumberOfMiles = numberOfMiles,

                            NumberOfPreviousOwners = numberOfPreviousOwners,

                            PurchaseValue = purchaseValue

                        };

            PriceDeterminator priceDeterminator = new PriceDeterminator();

            var carPrice = priceDeterminator.DetermineCarPrice(car);

            Assert.AreEqual(expectValue, carPrice);

        }

    }

}

​