using System;

using System.Collections.Generic;

using System.Linq;

using System.Diagnostics;

​

public class Motor {

    public int id;

    public int frame;

    public int mount;

    public int hertz;

}

​

public class Target {

    public int frame;

    public int mount;

    public int hertz;

}

public class Program

{

    public static int NumberOfMotors = 1300;

    public static int NumberOfUnits = 100;

    public static Random rand = new Random();

    public static List<int> availableFrames = new List<int>{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

    public static List<int> availableMounts = new List<int>{ 1, 2, 3, 4, 5 };

    public static List<int> availableHertz = new List<int>{ 50, 60 };

    public static List<Motor> motorCache = new List<Motor>();

    public static Dictionary<int, Dictionary<int, Motor>> frameLookup;

    public static Dictionary<int, Dictionary<int, Motor>> mountLookup;

    public static Dictionary<int, Dictionary<int, Motor>> hertzLookup;

    public static Stopwatch totalwatch = new Stopwatch();

    public static List<long> hashTimes = new List<long>();

​

    public static void Main()

    {

        Console.WriteLine("Starting Test with " + NumberOfMotors + " Motors");

        SetUpCache();

        Console.WriteLine("> Added " + motorCache.Count + " Motors to motorCache.");

        createFrameLookup();

        Console.WriteLine("> Created Frame Dictionary with " + frameLookup.Count + " Lists.");

​

        createMountLookup();

        Console.WriteLine("> Created Mount Dictionary with " + mountLookup.Count + " Lists.");

        createHertzLookup();

        Console.WriteLine("> Created Hertz Dictionary with " + hertzLookup.Count + " Lists.");

        Console.WriteLine("-------");

        getMotorsForUnits();

​

        Console.WriteLine("-------");

    }

    public static void SetUpCache() {

        for (var i = 0; i < NumberOfMotors; i++) {

            motorCache.Add(new Motor {

                id = i,

                frame = availableFrames[rand.Next(availableFrames.Count)],

                mount = availableMounts[rand.Next(availableMounts.Count)],

                hertz = availableHertz[rand.Next(availableHertz.Count)],

            });

        }

    }

    public static void createFrameLookup() {

        frameLookup = new Dictionary<int, Dictionary<int, Motor>>();

        motorCache.ForEach((Motor motor) => {

            if (!frameLookup.ContainsKey(motor.frame)) {

                frameLookup[motor.frame] = new Dictionary<int, Motor>();

            }

            frameLookup[motor.frame].Add(motor.id, motor);

        });

    }

    public static void createMountLookup() {

        mountLookup = new Dictionary<int, Dictionary<int, Motor>>();

        motorCache.ForEach((Motor motor) => {

            if (!mountLookup.ContainsKey(motor.mount)) {

                mountLookup[motor.mount] = new Dictionary<int, Motor>();

            }

            mountLookup[motor.mount].Add(motor.id, motor);

        });

    }

    public static void createHertzLookup() {

        hertzLookup = new Dictionary<int, Dictionary<int, Motor>>();

        motorCache.ForEach((Motor motor) => {

            if (!hertzLookup.ContainsKey(motor.hertz)) {

                hertzLookup[motor.hertz] = new Dictionary<int, Motor>();

            }

            hertzLookup[motor.hertz].Add(motor.id, motor);

        });

    }

    public static void getMotorsForUnits() {

        var units = new List<Target>();

        for (var i = 0; i < NumberOfUnits; i++) {

            var unit = new Target(){

                frame = availableFrames[rand.Next(availableFrames.Count)],

                mount = availableMounts[rand.Next(availableMounts.Count)],

                hertz = availableHertz[rand.Next(availableHertz.Count)],

            };

            units.Add(unit);

        }

        var stopwatch = new Stopwatch();

        stopwatch.Start();

        foreach (var unit in units) {

            getMotorsThatFit(unit).Count();

        }

        Console.WriteLine("New Method: " + stopwatch.Elapsed.TotalMilliseconds);

        Console.WriteLine("-------");

        stopwatch.Restart();

        foreach (var unit in units) {

            getMotorsThatFitViaLoop(unit).Count();

        }

​

        Console.WriteLine("Loop Method: " + stopwatch.Elapsed.TotalMilliseconds);

    }

    public static List<Motor> getMotorsThatFit(Target unit) {       

        Dictionary<int, Motor> frameFit = frameLookup[unit.frame];

        Dictionary<int, Motor> mountFit = mountLookup[unit.mount];

        Dictionary<int, Motor> hertzFit = hertzLookup[unit.hertz];

        var motorsThatFit = new List<Motor>();

        foreach (KeyValuePair<int, Motor> entry in frameFit) {

            if (mountFit.ContainsKey(entry.Key) && hertzFit.ContainsKey(entry.Key)) {

                // This runs only motors that "fit" through the checkMotorPerformance method, because it is unknown

                // in what order these checks will run, but we do know that it is unnecessary to calculate performance 

                // against a motor that does not fit.

                motorsThatFit.Add(checkMotorPerformance(entry.Value));

            }

        }

        return motorsThatFit;

    }

    public static List<Motor> getMotorsThatFitViaLoop(Target unit) {

        var motorsThatFit = new List<Motor>();

        foreach (var motor in motorCache) {

            // This runs every motor through the checkMotorPerformance method, because it is unknown

            // in what order these checks will run and/or how many unneccessary calculations are made

            // against this motor.

            motorsThatFit.Add(checkMotorPerformance(motor));

        }

        return motorsThatFit;

    }

    public static Motor checkMotorPerformance(Motor motor) {

        var stopwatch = new Stopwatch();

        stopwatch.Start();

        // This simulates the time it may take to calculate performance on a motor based on frame size.

        // This ensures that motors passed to this performance check via either methodology are treated

        // equally, the intention being to simulate how many unneccessary checks can be avoided and, thus,

        // how much time can be saved.

        // This is reasonable because it has been proven that it is not just the performance calculations

        // run against motors that have a cost, but also other mutations that contribute to overall speed,

        // and simply rearranging the order in which the performance calculations run does not appreciably

        // improve the performance of the algorithm overall.

        while (stopwatch.Elapsed.TotalMilliseconds < (0.001 * motor.frame)) { }

        return motor;

    }

}