/*
Script for automatic rotor stop when a solar panel or oxygen farm has high output.
Version: 0.99d

Sigurd Hansen
*/
#region Variables
const int HighPwrValue = 200; // Set this to your minimum power requirement per panel. (Or oxygen L/min)
const string NameOfSolar = "SolarMain"; // Search for Solar Blocks(Or oxygen farm)
const string NameOfRotorX = "RotorX"; // Search for Rotor Blocks with this name.
const float rotorspeed = 2f; // Max speed of rotor. Will be dynamically adjusted when close to target. Do not remove "f"

const bool EnableTimerMgmt = false; // Enable Dynamic Timer Trigger Management for better accuracy and performance.
const string NameOfTimer = "SolarTimer"; // Set this to the timer responsible for triggering this program.
const float TimerIdleDelay = 8f; // Delay of timer when idle. Do not remove "f"
const float TimerActiveDelay = 2f; // Delay of timer when active. Do not remove "f". Do not set below 2.

const bool EnableTwoAxisMode = true; // Support for dual axis configuration
const string NameOfRotorY = "RotorY"; // Search for this name for extra axis. Must not find x-axis rotors.

const bool EnableOxygenMode = false; // Enables oxygen mode.


// Changes below this line not recommended
//------------------------------------------------------------

List<IMyTerminalBlock> solarBlocks = new List<IMyTerminalBlock>();
List<IMyTerminalBlock> rotorBlocksX = new List<IMyTerminalBlock>();
List<IMyTerminalBlock> rotorBlocksY = new List<IMyTerminalBlock>();
IMyTimerBlock timer;

bool firstrun = true;
#endregion
#region Main
void Main()
{
if (firstrun) {
GridTerminalSystem.SearchBlocksOfName(NameOfSolar, solarBlocks); // Search for Solar Blocks
GridTerminalSystem.SearchBlocksOfName(NameOfRotorX, rotorBlocksX); // Search for Rotor Blocks
GridTerminalSystem.SearchBlocksOfName(NameOfRotorY, rotorBlocksY); // Search for RotorY Blocks
timer = GridTerminalSystem.GetBlockWithName(NameOfTimer) as IMyTimerBlock;
if (timer == null && EnableTimerMgmt) { throw new Exception("Cannot find timer. Check timer name and recompile."); }
if (solarBlocks.Count == 0) { throw new Exception("Cannot find solar panel. Check name and recompile."); }
if (rotorBlocksX.Count == 0) { throw new Exception("Cannot find x-axis rotor blocks. Check name and recompile."); }
if (rotorBlocksY.Count == 0 && EnableTwoAxisMode) { throw new Exception("Cannot find y-axis rotor blocks. Check name and recompile."); }
if (rotorBlocksY.Count < rotorBlocksX.Count && EnableTwoAxisMode) {
int diff = rotorBlocksX.Count - rotorBlocksY.Count;
throw new Exception(diff + " Y-axis rotors missing. Fix and recompile.");
}

firstrun = false;
}

bool[] rotorOn = new bool[rotorBlocksX.Count]; // Stop or start rotor
bool[] rotorLow = new bool[rotorBlocksX.Count]; // True when power is way to low
bool[] rotorFineTune = new bool[rotorBlocksX.Count]; // Fine Tune, very slow rotor
bool[] reverse = new bool[rotorBlocksX.Count]; // Reverse rotor
bool[] rotorOnY = new bool[rotorBlocksY.Count]; // Stop or start rotor

bool containsFalse = false; // Dynamic timer management. Increase or decrease timer
float pwr = 0f, lastPwr = 0f; // Current and last power reading

if (EnableOxygenMode) {
for(int i = 0; i < solarBlocks.Count; i++) { // For each oxygen farm...
var solar = solarBlocks[i] as IMyOxygenFarm; // Support for oxygen farm
if(solar != null) { // Yes I am
GetOxygen(solar, ref pwr); // Get oxygen level, return into existing pwr variable
lastPwr = GetAndSetLastOxygen(solar, pwr); // Get and set last runs oxygen level
reverse[i] = (lastPwr < pwr || pwr == 0) ? false : true; // Change rotor direction
rotorOn[i] = (pwr <= HighPwrValue) ? true : false; // Turn on rotor
rotorLow[i] = (pwr < HighPwrValue/2) ? true : false; // Slow or fast rotor
rotorFineTune[i] = (pwr > HighPwrValue*10/11) ? true : false; // Fine tune rotor
}
}
} else {
for(int i = 0; i < solarBlocks.Count; i++) { // For each solar panel...
var solar = solarBlocks[i] as IMySolarPanel; // I am a Solar Panel
if(solar != null) { // Yes I am
GetPower(solar, ref pwr); // Get Power from solar panel, return into existing pwr variable
lastPwr = GetAndSetLastPwr(solar, pwr); // Get and set last runs power
reverse[i] = (lastPwr < pwr || pwr == 0) ? false : true; // Change rotor direction
rotorOn[i] = (pwr <= HighPwrValue) ? true : false; // Turn on rotor
rotorLow[i] = (pwr < HighPwrValue/2) ? true : false; // Slow or fast rotor
rotorFineTune[i] = (pwr > HighPwrValue*10/11) ? true : false; // Fine tune rotor
}
}
}

for(int i = 0; i < rotorBlocksX.Count; i++) { // For each rotorX...
IMyMotorStator rotor = rotorBlocksX[i] as IMyMotorStator; // I am a Rotor
if(rotor != null) { // Yes I am
SetRotorSpeed(rotor, rotorLow[i], rotorFineTune[i]); // Dynamic rotor speed
if (!rotorOn[i]) { // Turn off...
TriggerRotor(rotor, false, false, ref containsFalse); // Stop rotor
} else if (rotorOn[i] && EnableTwoAxisMode && reverse[i]) { // Turn On, dual axis mode, and reverse
rotorOnY[i] = CheckAndUpdateRotorName(rotor);
if (rotorOnY[i]) {
TriggerRotor(rotor, false, false, ref containsFalse); // Y on, therefore X off.
}

if (!rotorOnY[i]) {
TriggerRotor(rotor, true, reverse[i], ref containsFalse); // Y off, therefore X on, and reverse.
}
} else if (rotorOn[i] && EnableTwoAxisMode && !reverse[i]) {
rotorOnY[i] = CheckAndUpdateRotorName(rotor);
if (!rotorOnY[i]) {
TriggerRotor(rotor, true, reverse[i], ref containsFalse); // Start rotor. Reverse if needed
}
} else {
TriggerRotor(rotor, true, reverse[i], ref containsFalse); // Start rotor. Reverse if needed
}
}
}

if (EnableTwoAxisMode) {
for(int i = 0; i < rotorBlocksY.Count; i++) { // For each rotorY...
IMyMotorStator rotor = rotorBlocksY[i] as IMyMotorStator; // I am a Rotor
if(rotor != null) { // Yes I am
if (rotorOnY[i] == true) {
SetRotorSpeed(rotor, rotorLow[i], rotorFineTune[i]); // Dynamic rotor speed
TriggerRotor(rotor, true, reverse[i], ref containsFalse); // Start rotor Y. Reverse if needed
} else {
TriggerRotor(rotor, false, false, ref containsFalse);
}
}
}
}

if (containsFalse && EnableTimerMgmt) { // Dynamic timer stuff
if (timer.TriggerDelay > TimerActiveDelay) {
AdjustTriggerDelay(timer, false); // Decrease Timer Delay
}
} else {
if (timer.TriggerDelay < TimerIdleDelay && EnableTimerMgmt) {
AdjustTriggerDelay(timer, true); // Increase Timer Delay
}
}
}

#endregion

#region Methods

void AdjustTriggerDelay(IMyTimerBlock timer, bool Increase) {
if (Increase) { timer.SetValue("TriggerDelay", TimerIdleDelay); } // Increase Timer Trigger Delay
else { timer.SetValue("TriggerDelay", TimerActiveDelay); } // Decrease Timer Trigger Delay
}

void TriggerRotor(IMyMotorStator rotor, bool state, bool reverse, ref bool containsFalse) {
if (!state) {
rotor.GetActionWithName("OnOff_Off").Apply(rotor); // Stop rotor
} else {
rotor.GetActionWithName("OnOff_On").Apply(rotor); // Start rotor
containsFalse = true; // Adjust timer for better accuracy
if (reverse) { rotor.GetActionWithName("Reverse").Apply(rotor); }
}
}

void GetPower(IMySolarPanel solar, ref float pwr) {
string value = "";
string type = "";
System.Text.RegularExpressions.Regex matchthis = new System.Text.RegularExpressions.Regex(@"^.+\n.+\:\s?([0-9\.]+)\s(.*)\n.+$");
System.Text.RegularExpressions.Match match = matchthis.Match(solar.DetailedInfo);
if (match.Success)
{
value = match.Groups[1].Value;
type = match.Groups[2].Value;
Echo (value + " " + type);
} else throw new Exception("Can't parse DetailedInfo with regex");
bool test = float.TryParse(value, out pwr); // Get power into variable
if (type == "W") { pwr /= 1000; } // Make sure power is in kW
if (!test) { throw new Exception("Can't parse power reading from solar panel: " + value); }
}

void GetOxygen(IMyOxygenFarm solar, ref float pwr) {
string value = "";
System.Text.RegularExpressions.Regex matchthis = new System.Text.RegularExpressions.Regex(@"^.+\n.+\n.+\:\s?([0-9\.]+)\s?L.*$");
System.Text.RegularExpressions.Match match = matchthis.Match(solar.DetailedInfo);
if (match.Success)
{
value = match.Groups[1].Value;
Echo (value + " L/min");
} else
{
Echo("Assuming 0; Can't parse DetailedInfo: " + value);
value = "0";
}
bool test = float.TryParse(value, out pwr); // Get oxygen into variable
if (!test) { throw new Exception("Can't parse reading from oxygen farm\n"); }
}

void SetRotorSpeed(IMyMotorStator rotor, bool fast, bool FineTune) {
float SetTo = 0f;
bool VelocityPositive = (rotor.GetValueFloat("Velocity") > 0f) ? true : false; // True if positive velocity
if (fast) { // Under half of required power from solar panel. Will increase speed
SetTo = (VelocityPositive) ? rotorspeed : -rotorspeed;
} else if (FineTune) { // Fine tune speed
SetTo = (VelocityPositive) ? rotorspeed/3.7f : -rotorspeed/3.7f;
} else { // Not far from required power. Lower speed for increased accuracy
SetTo = (VelocityPositive) ? rotorspeed/1.7f : -rotorspeed/1.7f;
}
rotor.SetValue("Velocity", SetTo);
}

float GetAndSetLastPwr(IMySolarPanel solar, float CurrentPower) {
float OldPwr = 0f;
string[] words = solar.CustomName.Split(':'); // Colon split words
if (words.Length > 1) { // If there is data after colon
if (!float.TryParse(words[1], out OldPwr)) { OldPwr = 0f;} // Try to get data into float variable
}
solar.SetCustomName(words[0] + ":" + CurrentPower); // Set current power in solar panel name
return OldPwr;
}
float GetAndSetLastOxygen(IMyOxygenFarm solar, float CurrentPower) {
float OldPwr = 0f;
string[] words = solar.CustomName.Split(':'); // Colon split words
if (words.Length > 1) { // If there is data after colon
if (!float.TryParse(words[1], out OldPwr)) { OldPwr = 0f;} // Try to get data into float variable
}
solar.SetCustomName(words[0] + ":" + CurrentPower); // Set current power in solar panel name
return OldPwr;
}


bool CheckAndUpdateRotorName(IMyMotorStator rotor) {
int OldCount = 0;
string[] words = rotor.CustomName.Split(':'); // Colon split words
if (words.Length > 1) { // If there is data after colon
if (!int.TryParse(words[1], out OldCount)) { OldCount = 0;} // Try to get data into int variable
}
int NewCount = OldCount + 1;
if (OldCount > 6) {
rotor.SetCustomName(words[0] + ":0");
return true;
}
else if (OldCount >= 3) {
rotor.SetCustomName(words[0] + ":" + NewCount); // Set current count in rotor name
return true;
} else {
rotor.SetCustomName(words[0] + ":" + NewCount); // Set current count in rotor name
return false;
}
}
#endregion