using System;

using System.Collections.Generic;

using System.Linq;

public class Program

{

    public static void Main()

    {

        /*

            Mothership item stock.

        */

        var stock = new Dictionary<Product, int> {

            {IronOre, 2000},

            {CopperOre, 2000},

            {CopperWire, 7}

        };

        /*

            Check how many times build given order, with the given

            stock and time debt.

        */

        RunAdvFab(Battery, stock, 1000);

    }

    static void RunAdvFab(Product order, Dictionary<Product, int> stock, double time)

    {

        var canBuild = true;

        while(canBuild)

        {

            Dump("In stock:", stock);

            Console.WriteLine();

            // Copy stock, key is item type, value is item quantity.

            var tempStock = new Dictionary<Product, int>(stock);

            /* 

                Items that will be consumed, start with the ores. As if

                there are no parts already built and the fab will have to 

                them all from ores.

            */

            var inputs = new Dictionary<Product, int>(order.OreCost);

            /*

                Analyse which parts are already available in the stock. 

                Calculate how much time will be saved with them and swap their

                ore cost with them in "inputs". For example, having copper wires

                will reduce the need for copper ore and copper ingots.

            */

            var savedTime = CalcJob(order, null, tempStock, inputs);

            var timeCost = order.OreBuildTime - savedTime;

            /*

                Calculate how many times the calculated list of inputs can taken

                from the stock. For each input item that is required (amount > 0), 

                divide stock amount with required amount, and find the smallest

                such division.

            */

            var repetitions = inputs.Where(req => req.Value > 0).Min(req => stock[req.Key] / req.Value);

            /*

                Apply time debt consumption limit. Total repetition is smaller of

                time and stock repetitions.

            */

            repetitions = Math.Min(repetitions, (int)(time / timeCost));    

            Console.WriteLine("Making " + order.Name + " x" + repetitions + " for " + (timeCost * repetitions) + "s total");

            // Update time debt.

            time -= timeCost * repetitions;

            Console.WriteLine("Time left: " + time);

            Console.WriteLine();

            // If we have built any ordered items, update stock and go for another loop.

            canBuild = repetitions > 0;

            AddItems(stock, order, repetitions);

            foreach(var item in inputs)

                stock[item.Key] -= item.Value * repetitions;

        }

    }

    static double CalcJob(Product order, int? amount, Dictionary<Product, int> stock, Dictionary<Product, int> inputs)

    {

        /* 

            When the stock is depleated the recursion will ask for

            "making more ores". We end the analysis there.

        */

        if (order.IsOre)

            return 0;

        var savedTime = 0.0;

        /* 

            Nullable amount is a hack for differentiating between

            fab order item and its parts.

        */

        var subAmount = amount.HasValue ? amount.Value : 1;

        foreach(var req in order.Requirements)

        {

            var available = stock.ContainsKey(req.Key) ? stock[req.Key] : 0;

            var needed = req.Value * subAmount;

            var used = Math.Min(available, needed);

            /*

                If there are parts that can be used, add them to the time

                saving, and replace ore cost with part cost.

            */

            if (used > 0)

            {

                Console.WriteLine("Using " + used + " " + req.Key.Name + ", saved " + (req.Key.OreBuildTime * used) + "s");

                foreach(var ore in req.Key.OreCost)

                    if (inputs.ContainsKey(ore.Key))

                        inputs[ore.Key] -= ore.Value * used;

                    else

                        Dump("Missing " + ore.Key.Name, inputs);

                stock[req.Key] -= used;

                savedTime += req.Key.OreBuildTime * used;

                AddItems(inputs, req.Key, used);

            }

            /*

                If there are parts that needs to be build, descend

                recursively to check for the saving down the line.

            */

            if (needed > used)

                savedTime += CalcJob(req.Key, needed - used, stock, inputs);

        }

        if (amount.HasValue)

            Console.WriteLine("Making " + subAmount + " " + order.Name);

        return savedTime;

    }

    // Helper method for adding quantity to dictionary even if it doesn't exist yet.

    static void AddItems(Dictionary<Product, int> stock, Product item, int amount)

    {

        if (!stock.ContainsKey(item))

            stock[item] = 0;

        stock[item] += amount;

    }

    // Helper method for logging stock

    static void Dump(string title, Dictionary<Product, int> stock)

    {

        Console.WriteLine(title);

        foreach(var item in stock)

            Console.WriteLine(item.Value + " " + item.Key.Name);

    }

    class Product {

        public readonly string Name;

        public readonly Dictionary<Product, int> Requirements;

        public readonly double BuildTime;

        public readonly Dictionary<Product, int> OreCost;

        public readonly double OreBuildTime;

        public bool IsOre

        {

            get { return this.Requirements == null; }

        }

        public Product(string name, double buildTime, Dictionary<Product, int> requirements) {

            this.Name = name;

            this.BuildTime = buildTime;

            this.Requirements = requirements;

            // Calculating ore cost and time when making without parts

            this.OreCost = new Dictionary<Product, int>();

            var time = buildTime;

            if (!IsOre)

                foreach(var req in requirements)

                    if (req.Key.IsOre)

                        AddItems(OreCost, req.Key, req.Value);

                    else

                    {

                        foreach(var subOre in req.Key.OreCost)

                            AddItems(OreCost, subOre.Key, req.Value * subOre.Value);

                        time += req.Key.OreBuildTime * req.Value;

                    }

            this.OreBuildTime = time;

        }

    }

    /*

        List of parts

    */

    static Product IronOre = new Product("iron ore", 0, null);

    static Product CopperOre = new Product("copper ore", 0, null);

    static Product IronIngot = new Product("iron ingot", 15, new Dictionary<Product, int> {

        {IronOre, 75}

    });

    static Product CopperIngot = new Product("copper ingot", 15, new Dictionary<Product, int> {

        {CopperOre, 75}

    });

    static Product CopperWire = new Product("copper wire", 15, new Dictionary<Product, int> {

        {CopperIngot, 3},

    });

    static Product Battery = new Product("battery", 30, new Dictionary<Product, int> {

        {CopperWire, 2},

        {IronIngot, 3}

    });

}