Cargo Refill Code v13

/*
Whip's Cargo Refill Script - version 13 - 11/12/16

Based off Utilibot code by Dainw: http://steamcommunity.com/sharedfiles/filedetails/?id=437345638
____________________________________________________________________________________________

/// NAMING ///
    <Block Name> [Restock]; <item1> - <amountOfItem>; <item2> - <amountOfItem>

    Example:
        Cargo Container [Restock];Steel Plate - 500;uranium - 24
            * this will restock the container with 500 steel plates and 24 ingots of uranium
____________________________________________________________________________________________

/// LIST OF RECOGNISED COMPONENT NAMES ///
    Items listed like: "Banana(s)" means that both "Banana" and "Bananas"
    would be valid names

    Ores/Ingots
        * Uranium or Fuel or UraniumIngot(s) or Uranium Ingot(s)
        * Stone
        * Ice

    Components
        * Steel or SteelPlate(s) or Steel Plate(s)
        * InteriorPlate(s) or Interior Plate(s)
        * Construction  or Construction Component(s)
        * Motor(s)
        * MetalGrid(s) or Metal Grid(s)
        * LargeTube(s) or Large Steel Tube(s) or LST
        * SmallTube(s) or Small Steel Tube(s) or SST
        * Display(s)
        * Computer(s) or CPU(s)
        * Medical or Medical Component(s)
        * SolarCell(s) or Solar Cell(s)
        * PowerCell(s) or Power Cell(s)
        * Detector(s) or Detector Component(s)
        * Girder(s)
        * Thrust or Thruster(s) or Thruster Component(s)
        * Reactor or Reactor Component(s)
        * BulletproofGlass or Bullerproof Glass or Glass
        * RadioCommunication or Radio(s) or Radio Component(s)
            or Radio Communication Component(s)
        * Gravity Generator Component(s) or Gravity or Grav
            or Gravity Generator or Gravity Component(s)
        * OxygenBottle(s) or Oxygen Bottle(s) or Oxygen or O2
            or O2 Bottle(s)
        * Superconductor(s) or Super Conductor(s)
        * Hydrogen or HydrogenBottle(s) or Hyrdogen Bottle(s)

    Ammo
        * Missile200mm  or Missile(s) or Rocket(s)
        * NATO_25x184mm or 25mm or 25mm NATO
        * NATO_5p56x45mm or 5.56mm or 5.56mm NATO

Todo:
* make idiot proof
* add comments
* possibly add reactor support?

- Whiplash141
*/

    string transferName = "[Transfer]";
    string restockName = "[Restock]";
    string blockName;
    string itemDesired;
    int amountDesired;
    IMyTerminalBlock target;
    IMyInventory targetInventory;
    Dictionary<string, int> ItemsToTransfer = new Dictionary<string, int>();

void Main()
{
    List<IMyTerminalBlock> cargoCapable = new List<IMyTerminalBlock>();
    List<IMyTerminalBlock> transfer = new List<IMyTerminalBlock>();
    List<IMyTerminalBlock> blocks = new List<IMyTerminalBlock>();

    GridTerminalSystem.GetBlocksOfType<IMyTerminalBlock>(blocks);
    for(int i = 0 ; i < blocks.Count ; i++)
    {
        if(blocks[i] is IMyCargoContainer || blocks[i] is IMyShipWelder || blocks[i] is IMyShipConnector || blocks[i] is IMyUserControllableGun)
            cargoCapable.Add(blocks[i]);
    }

    Echo("Cargo Capable Blocks on Grid: " + cargoCapable.Count.ToString());
    for(int i = 0 ; i < cargoCapable.Count ; i++)
    {
        if(cargoCapable[i].CustomName.Contains(restockName))
        {
            Echo(cargoCapable[i].CustomName);
            target = cargoCapable[i];
            targetInventory = target.GetInventory(0);

            GetCargoQuota();
            UpdateCargoQuota();
            FillCargoQuota();
        }
    }
}

void GetCargoQuota()
{
    blockName = target.CustomName.Replace(" ", ""); //get name of cargo block
    string[] blockName_split = blockName.Split(';'); //split at semicolons

    for (int j = 1 ; j < blockName_split.Length ; j++)
    {
        string[] item_split = blockName_split[j].Split('-'); //seperate item from amount
        itemDesired = item_split[0].ToLower(); //convert to lowercase
        amountDesired = Convert.ToInt32(item_split[1]); //convert to a number
        bool isValidItem = true;

        switch(itemDesired) //compare block names to valid components
        {
        //ore and ingots
            case "uraniumingot":
            case "uraniumingots":
            case "uranium":
            case "fuel":
                itemDesired = "Uranium";
                break;

            case "stone":
            case "rock":
                itemDesired = "Stone";
                break;

            case "ice":
            case "frozenwater"
                itemDesired = "Ice";
                break;

        //Components
            case "steel":
            case "steelplate":
            case "steelplates":
                itemDesired = "SteelPlate";
                break;

            case "interiorplate":
            case "interiorplates":
                itemDesired = "InteriorPlate";
                break;

            case "construction":
            case "constructioncomponent":
            case "constructioncomponents":
            case "cc":
                itemDesired = "Construction";
                break;

            case "motor":
            case "motors":
                itemDesired = "Motor";
                break;

            case "metalgrid":
            case "metalgrids":
                itemDesired = "MetalGrid";
                break;

            case "largetube":
            case "largetubes":
            case "largesteeltube":
            case "largesteeltubes":
            case "lst":
                itemDesired = "LargeTube";
                break;

            case "smalltube":
            case "smalltubes":
            case "smallsteeltube":
            case "smallsteeltubes":
            case "sst":
                itemDesired = "SmallTube";
                break;

            case "display":
            case "displays":
                itemDesired = "Display";
                break;

            case "computer":
            case "computers":
            case "cpu":
            case "cpus":
                itemDesired = "Computer";
                break;

            case "medical":
            case "medicalcomponent":
            case "medicalcomponents":
                itemDesired = "Medical";
                break;

            case "solarcell":
            case "solarcells":
            case "solarcell":
            case "solarcells":
            case "solar":
                itemDesired = "SolarCell";
                break;

            case "powercell":
            case "powercells":
            case "powercell":
            case "powercells":
            case "power":
                itemDesired = "PowerCell";
                break;

            case "detector":
            case "detectors":
            case "detectorcomponent":
            case "detectorcomponents":
                itemDesired = "Detector";
                break;

            case "girder":
            case "girders":
                itemDesired = "Girder";
                break;

            case "thrust":
            case "thruster":
            case "thrusters":
            case "thrustercomponent":
            case "thrustercomponents":
                itemDesired = "Thrust";
                break;

            case "reactor":
            case "reactorcomponent":
            case "reactorcomponents":
                itemDesired = "Reactor";
                break;

            case "bulletproofglass":
            case "glass":
                itemDesired = "BulletproofGlass";
                break;

            case "radiocommunication":
            case "radio":
            case "radiocomponent":
            case "radiocomponents":
            case "radiocommunicationcomponent":
            case "radiocommunicationcomponents":
                itemDesired = "RadioCommunication";
                break;

            case "grav":
            case "gravity":
            case "gravitygenerator":
            case "gravitygeneratorcomponent":
            case "gravitygeneratorcomponents":
            case "gravitycomponent":
            case "gravitycomponents":
                itemDesired = "GravityGenerator";
                break;

            case "oxygenbottle":
            case "oxygenbottles":
            case "oxygen":
            case "o2bottle":
            case "o2bottles":
            case "o2":
                itemDesired = "OxygenBottle";
                break;

            case "superconductor":
            case "superconductors":
                itemDesired = "Superconductor";
                break;

            case "hydrogenbottle":
            case "hydrogenbottles":
            case "hydrogen":
                itemDesired = "HydrogenBottle";
                break;

        //ammo
            case "missile200mm":
            case "missile":
            case "missiles":
            case "rocket":
            case "rockets":
                itemDesired = "Missile200mm";
                break;

            case "nato_25x184mm":
            case "25mm":
            case "25mm NATO":
                itemDesired = "NATO_25x184mm";
                break;

            case "nato_5p56x45mm":
            case "5.56mm":
            case "5.56mm NATO":
                itemDesired = "NATO_5p56x45mm";
                break;

            default: //this means it is none of the above
                isValidItem = false;
                break;
        }

        if(isValidItem)
        {
            ItemsToTransfer.Add(itemDesired, amountDesired);
        }else{
            Echo("'" + itemDesired + "'" + " is not a valid component name");
        }

    }
}

void UpdateCargoQuota()
{
    var itemsAlreadyPresent = targetInventory.GetItems();

    for (int k = 0 ; k < itemsAlreadyPresent.Count ; k++)
    {
        var itemName = itemsAlreadyPresent[k].Content.SubtypeName;
        var itemAmount = (int)itemsAlreadyPresent[k].Amount;
        if (ItemsToTransfer.ContainsKey(itemName)) //if there is stuff already in there
        {
            if (ItemsToTransfer[itemName] > itemAmount) //if we dont have what we need
            {
                ItemsToTransfer[itemName] = ItemsToTransfer[itemName] - itemAmount; //take difference
                Echo(itemName + ":" + ItemsToTransfer[itemName]);
            }else{ //if we have what we need
                ItemsToTransfer.Remove(itemName);
            }
        }
    }
}

void FillCargoQuota()
{
    List<IMyTerminalBlock> transfer = new List<IMyTerminalBlock>();
    GridTerminalSystem.SearchBlocksOfName(transferName, transfer);
    for (int n = 0 ; n < transfer.Count ; n++)
    {
        if (!(transfer[n] is IMyCargoContainer) && !(transfer[n] is IMyShipConnector))
        {
            transfer.Remove(transfer[n]); //remove if not cargo capable
            continue;
        }
        var items = transfer[n].GetInventory(0).GetItems(); //see what we have in the container
        for (int j = 0 ; j < items.Count ; j++)
        {
            var itemName = items[j].Content.SubtypeName;
            Echo("Checking Item:" + itemName);
            if (ItemsToTransfer.ContainsKey(itemName) && ItemsToTransfer[itemName] > 0)
            {
                int itemAmount = Math.Min((int)ItemsToTransfer[itemName],(int)items[j].Amount);
                //if want > have then we take all we can from what we have currently and try the next container
                Echo("I need " + itemAmount);
                bool isTransferrable = transfer[n].GetInventory(0).TransferItemTo(targetInventory,j,null,true,itemAmount);
                Echo("Items can transfer: " + isTransferrable.ToString());
                if (isTransferrable == true) ItemsToTransfer[itemName]-=itemAmount;
            }
        }
    }
    ItemsToTransfer.Clear();
    Echo("Done");
}