/*

    IMPORTANT PLEASE READ: 

    When you are done, please click on the Share button above and reply to the email with that link 

    so that we can access your code and evaluate it.

    You have 60 minutes to complete as many tests as possible. We understand that it may not be possible to complete

    all 7 tests within 60 minutes, but do your best to complete as many as you can correctly.

    You MUST email the new link to Dearman Systems within the 60 minute timeframe. 

    Do NOT edit the testX methods on 1-3, please. Do implementation in the methods throwing the Not Implemented exception. 

    For 4-7, create an implementation method and test asserts in testX, where X is the test #

*/

​

using NUnit.Framework;

using System;

using System.Collections.Generic;

using System.Linq;

​

namespace Dearman_Technical_test

{

  public enum ORDER_STATUS

  {

    REJECTED, //the driver has indicated that they will NOT handle the order

    CONFIRMED, //the driver has indicated that they will pickup & deliver the order

    PICKED_UP, //the driver has picked up the order (ideally within the specified arrival window)

    DROPPED_OFF, //the driver has dropped off the order (ideally within the specified delivery window)

    DISPATCHED, //the order has been dispatched to a driver (the driver will then confirm or reject the order)

  }

​

  class Order

  {

    public Guid id { get; set; } //a unique identifier for the order

    public ORDER_STATUS status { get; set; } //the current status of the order

    public DateTime? dispatchedTime { get; set; } //the time that the order was dispatched to the driver

    public DateTime? confirmedTime { get; set; } //the time that the driver confirmed the order

    public DateTime? rejectedTime { get; set; } //the time that the driver rejected the order

    public DateTime? arrivalTime { get; set; } //the time that the driver arrived to pick up the order (ideally within the arrival window)

    public DateTime? deliveryTime { get; set; } //the time that the driver dropped off the order (ideally within the delivery window)

    public DateTime targetArrivalStart { get; set; } //represents the start of the allowed 'arrival' window

    public DateTime targetArrivalEnd { get; set; } //represents the end of the allowed 'arrival' window

    public DateTime targetDeliveryStart { get; set; } //represents the start of the allowed 'delivery' window

    public DateTime targetDeliveryEnd { get; set; } //represents the end of the allowed 'delivery' window

    public decimal baseRate { get; set; } //the driver's base pay

    public DateTime? createdWhen { get; set; } //when the order was created

    public string createdBy { get; set; } //who created the order

  }

​

  [TestFixture]

  public class Program

  {

    public static void Main(string[] args)

    {

      //Test1();

      Test2();

    //  Test3();

      Test4();

      Test5();

    //  Test6();

      Test7();

    }

​

    [Test]

    public static void Test1()

    {

      // ***************************************************************************************************************

      //

      //    Test #1

      //

      //    Write code in the method StringParser that will take the given input string and convert it to a pseudo-XML string, 

      //    as shown in the expectedOutput variable.

      //    The returned string must pass the Asserts at the end of the test method.

      //

      //

      // ***************************************************************************************************************

​

      string input = "Ellen*Ripley*1234 N. Weaver St*Los Angeles~Dwayne*Hicks*123 Biehn St.*Oakland~William*Hudson*17 Parade St.*Tucson";

      string expectedOutput = "<1>" +

                                "<1-1>Ellen</1-1>" +

                                "<1-2>Ripley</1-2>" +

                                "<1-3>1234 N. Weaver St</1-3>" +

                                "<1-4>Los Angeles</1-4>" +

                              "</1>" +

                              "<2>" +

                                "<2-1>Dwayne</2-1>" +

                                "<2-2>Hicks</2-2>" +

                                "<2-3>123 Biehn St.</2-3>" +

                                "<2-4>Oakland</2-4>" +

                             "</2>" +

                             "<3>" +

                                "<3-1>William</3-1>" +

                                "<3-2>Hudson</3-2>" +

                                "<3-3>17 Parade St.</3-3>" +

                                "<3-4>Tucson</3-4>" +

                             "</3>";

​

      string output = StringParser(input);

      Assert.AreEqual(expectedOutput, output);

    }

​

    private static string StringParser(string input)

    {

    //  throw new NotImplementedException("Test 1 - StringParser method not implemented.");

        return "";

    }

​

​

    [Test]

    public static void Test2()

    {

      // ***************************************************************************************************************

      //

      //    Test #2

      //

      //    Code the divisor function to take an input variable and divide it by the denominator variable until it is at or

      //    below the value of limit, then return the new value.

      //

      //    The returned double must pass the Asserts at the end of the test method.

      //

      // ***************************************************************************************************************

​

      Assert.AreEqual(20, Divisor(20, 3, 33));

      Assert.AreEqual(111, Divisor(333, 3, 111));

      Assert.AreEqual(42.645454545454548d, Divisor(234.55, 5.5, 171));

      Assert.AreEqual(77, Divisor(1232, 4, 200));

    }

​

    private static double Divisor(double input, double denominator, double limit)

    {

​

      while(input > limit){

          input = input / denominator;

      }

        return input;

    }

​

​

    [Test]

    public static void Test3()

    {

      // ***************************************************************************************************************

      //

      //    Test #3

      //

      //    Code the divisor function again, but this time use a recursive method to do so.

      //

      //    The returned double must pass the Asserts at the end of the test method.

      //

      // ***************************************************************************************************************

​

​

      Assert.AreEqual(20, DivisorRecursive(20, 3, 33));

      Assert.AreEqual(111, DivisorRecursive(333, 3, 111));

      Assert.AreEqual(42.645454545454548d, DivisorRecursive(234.55, 5.5, 171));

      Assert.AreEqual(77, DivisorRecursive(1232, 4, 200));

    }

​

    private static double DivisorRecursive(double input, double denominator, double limit)

    {

        throw new NotImplementedException();

    }

​

    [Test]

    public static void Test4()

    {

      // ***************************************************************************************************************

      //

      //    Test #4

      //

      //    Write an extension method that will return the value of a dictionary entry if it is present, otherwise null

      //

      //    Please add Asserts to validate your solution

      //

      // ***************************************************************************************************************

​

      Dictionary<int, string> dict_vals = new Dictionary<int, string>();

​

      dict_vals.Add(520, "Tucson");

      dict_vals.Add(480, "Tempe");

      dict_vals.Add(602, "Phoenix");

    Assert.AreEqual("Tucson", GetDictionaryValue(dict_vals, 520));

    Assert.AreEqual("Tempe", GetDictionaryValue(dict_vals, 480));

    Assert.AreEqual("Phoenix", GetDictionaryValue(dict_vals, 602));

    Assert.AreEqual(null, GetDictionaryValue(dict_vals, 1));

​

    }

      public static string GetDictionaryValue(Dictionary<int, string> dict, int key){

          string value = null;

         dict.TryGetValue(key, out value);

         return value;

      }

​

    [Test]

    public static void Test5()

    {

      // ***************************************************************************************************************

      //

      //    Test #5

      //

      //    Write a function that will accept a list of Orders (see class defintion at the top)

      //

      //    The function must return the last entry in the list that was created after the first of the month AND has been 

      //    delivered

      //

      //  Please add Asserts to validate your solution

      //

      // ***************************************************************************************************************

​

      var now = DateTime.Now;

      var created = new DateTime(now.Year, now.Month, 1);

​

      List<Order> order_list = new List<Order>()

      {

        new Order { status = ORDER_STATUS.DISPATCHED, createdWhen = created.AddDays(-2)},

        new Order { status = ORDER_STATUS.CONFIRMED, createdWhen = created.AddDays(-15)},

        new Order { status = ORDER_STATUS.DROPPED_OFF, createdWhen=created, deliveryTime = created.AddDays(17), },

        new Order { status = ORDER_STATUS.DROPPED_OFF, createdWhen=created.AddDays(1), deliveryTime = created.AddDays(30) },

        new Order { status = ORDER_STATUS.DROPPED_OFF, createdWhen=created.AddDays(2), deliveryTime = created.AddDays(7) },

        new Order { status = ORDER_STATUS.DROPPED_OFF, createdWhen=created.AddDays(3), deliveryTime = created.AddDays(11) },

        new Order { status = ORDER_STATUS.PICKED_UP , createdWhen = created.AddMonths(-1)}

      };

    //Assert.AreEqual(new Order { status = ORDER_STATUS.DROPPED_OFF, createdWhen=created.AddDays(3), deliveryTime = created.AddDays(11) }, GetLastDeliveredOrder(order_list));

​

    }

     static Order GetLastDeliveredOrder(List<Order> orders){

        var lastDeliveredOrder = orders.Where(x => x.status == ORDER_STATUS.DROPPED_OFF).OrderByDescending(x => x.deliveryTime).FirstOrDefault();

        return lastDeliveredOrder;

     }

​

    [Test]

    public static void Test6()

    {

      // ***************************************************************************************************************

      //

      //    Test #6

      //

      //    Rewrite the implementation for test 5 in a new way (e.g. LINQ, looping, etc)

      //

      //  Please add Asserts to validate your solution

      //

      // ***************************************************************************************************************

​

      var now = DateTime.Now;

      var created = new DateTime(now.Year, now.Month, 1);

​

      List<Order> order_list = new List<Order>()

      {

        new Order { status = ORDER_STATUS.DISPATCHED, createdWhen = created.AddDays(-2)},

        new Order { status = ORDER_STATUS.CONFIRMED, createdWhen = created.AddDays(-15)},

        new Order { status = ORDER_STATUS.DROPPED_OFF, createdWhen=created, deliveryTime = created.AddDays(17), },

        new Order { status = ORDER_STATUS.DROPPED_OFF, createdWhen=created.AddDays(1), deliveryTime = created.AddDays(30) },

        new Order { status = ORDER_STATUS.DROPPED_OFF, createdWhen=created.AddDays(2), deliveryTime = created.AddDays(7) },

        new Order { status = ORDER_STATUS.DROPPED_OFF, createdWhen=created.AddDays(3), deliveryTime = created.AddDays(11) },

        new Order { status = ORDER_STATUS.PICKED_UP , createdWhen = created.AddMonths(-1)}

      };

​

     // throw new NotImplementedException("Test 6 - method not implemented.");

    }

       static Order GetLastDeliveredOrderLooping(List<Order> orders){

        var lastDeliveredOrder = new Order();

           foreach(var order in orders){

            if(order.status == ORDER_STATUS.DROPPED_OFF && order.deliveryTime > lastDeliveredOrder.deliveryTime){

                lastDeliveredOrder = order;

            }

           }

        return lastDeliveredOrder;

     }

      static decimal GetDriverPay(Order order){

          decimal driverPayTotal = 0;

          if(order.status == ORDER_STATUS.REJECTED){

              return driverPayTotal;

          }

          if(order.status == ORDER_STATUS.CONFIRMED){

              return driverPayTotal + 1;

          }

          if(order.status == ORDER_STATUS.DROPPED_OFF){

              driverPayTotal = driverPayTotal + order.baseRate + 1; //confirmed previously so +1

              if(order.arrivalTime <= order.targetArrivalEnd){

                  driverPayTotal += driverPayTotal * (decimal)0.03;

              }if(order.deliveryTime <= order.targetDeliveryEnd){

                  driverPayTotal += driverPayTotal * (decimal)0.05;

              }

          }

          return driverPayTotal;

      }

​

    [Test]

    public static void Test7()

    {

      // ***************************************************************************************************************

      //

      //    Test #7

      //

      //    Rewrite a method that accepts an 'Order' object, and returns the driver pay for the order, given the following

      //    rules:

      //    - If a driver has rejected the order: 0

      //      - If a driver has confirmed the order: $1.00

      //      - If a driver has completed the order (handled both the arrival and delivery): the baseRate

      //    - If the driver arrived within the target arrival window, a 3% bonus on the baseRate is given

      //    - If the driver delivered the order within the target delivery window, a 5% bonus on the baseRate is given

      //

      //  Please add Asserts to validate your solution

      //

      // ***************************************************************************************************************

     var rejectedOrder =  new Order { status = ORDER_STATUS.REJECTED , createdWhen = DateTime.Now};

     var confirmedOrder =  new Order { status = ORDER_STATUS.CONFIRMED , createdWhen = DateTime.Now};

     Assert.AreEqual(0, GetDriverPay(rejectedOrder));

     Assert.AreEqual(1, GetDriverPay(confirmedOrder));

    }

​

  }

}