// Autor: Martin Heinrich
// MatNr: 0125222
// BspNr: 4032
// Titel: Gesamtkapazität eines Kondesatornetzwerkes
// Beschreibung: Es soll die Gesamtkapazität eines Kondensatornetzwerkes berechnet werden
// Eingabe: Ein String {0..9, +, /, (, )}
// Ausgabe: Gesamtkapazität auf int gerundet
// Das Beispiel ist objektorientiert und als Package zu lösen.
// Dokumentation in ../Kapaz.txt

package Kapaz;

public class CapNet
{
  private int prvCount;
  private float prvValue;

//*************************************************************************************************
// constructors:
  public CapNet()
  {
    prvCount = 0;
    prvValue = 0;
  }
  public CapNet(String s)
  {
    setString(s);
  }
//*************************************************************************************************


//*************************************************************************************************
// setString() übernimmt ein neues Netzwerk als String entsprechend der Spezifikation
  public void setString(String s)
  {
    prvCount = 0;
    prvValue = 0;

    if (s.length() == 0) {return;};

    CapNet tNet; // Objektreferenz für tiefere Ebenen

    int Index = findChar(s, '+');

    if (Index == -1)
    {
      // aktuelle Ebene ist nicht Serienschaltung
      Index = findChar(s, '/');

      if (Index == -1)
      {
        // aktuelle Ebene ist nicht Parallelschaltung
        // Wenn die äußeren Zeichen ein Klammer-Paar sind -> nächste Ebene (rekursiv)
        if ((s.charAt(0) == '(') && (s.charAt(s.length()-1) == ')'))
        {
          tNet = new CapNet(s.substring(1, s.length()-1));
          prvCount = tNet.getCount();
          prvValue = tNet.getValue();
          return;
        }; // if (charAt())

        // Sonst müsste es bereits eine Integer-Zahl sein
        try
        {
          prvValue = Integer.valueOf(s).intValue();
        } catch (Exception e)
        { prvValue = 0;
          return;
        }; // try

        // ...und zwar eine positive
        if (prvValue <= 0)
        { prvValue = 0;
          return;
        }; // if (prvCount)
        prvCount = 1;
        return;
      }; // if (Index(/))

      // aktuelle Ebene ist Parallelschaltung
      tNet = new CapNet(s.substring(0, Index)); // linke Seite (rekursiv)
      if ((tNet.getCount() == 0) || (Index == s.length())) {return;};
      prvCount = tNet.getCount();
      prvValue = tNet.getValue();
      tNet = new CapNet(s.substring(Index+1, s.length())); // rechte Seite (rekursiv)
      if (tNet.getCount() == 0)
      { prvCount = 0;
        prvValue = 0;
        return;
      }; // if (getCount())
      prvCount += tNet.getCount();
      prvValue += tNet.getValue();
      return;
    }; // if (Index(+))

    // in einer Ebene dürfen nicht + und / sein
    if (findChar(s, '/') != -1) {return;};

    // aktuelle Ebene ist Serienschaltung
    tNet = new CapNet(s.substring(0, Index)); // linke Seite (rekursiv)
    if ((tNet.getCount() == 0) || (Index == s.length())) {return;};
    prvCount = tNet.getCount();
    prvValue = tNet.getValue();
    tNet.setString(s.substring(Index+1, s.length())); // rechte Seite (rekursiv)
    if (tNet.getCount() == 0)
    { prvCount = 0;
      prvValue = 0;
      return;
    }; // if (getCount())
    prvCount += tNet.getCount();
    prvValue = 1/(1/prvValue+1/tNet.getValue());

  } // setString
//*************************************************************************************************


//*************************************************************************************************
// getCount() gibt an, wieviele Kondensatoren das Netzwerk enthält (bei 0: ungültig)
  public int getCount()
  {
    return prvCount;
  } // getCount()
//*************************************************************************************************


//*************************************************************************************************
// getValue() gibt den Wert des Netzwerkes an
  public float getValue()
  {
    return prvValue;
  } // getValue()
//*************************************************************************************************


//*************************************************************************************************
// findChar() gibt den ersten Index an, bei dem sich im String s das Zeichen c außerhalb runder Klammern befindet
// Gibt -1 zurück, wenn kein solches Zeichen gefunden wurde
  private static int findChar(String s, char c)
  {
    int Index = -1;
    
    while (-1 != (Index = s.indexOf(c, Index+1)))
    {
      if (checkBrackets(s.substring(0, Index))) {return Index;};
    }; // while
    return Index;
  } // getValue()
//*************************************************************************************************


//*************************************************************************************************
// checkBrackets() überprüft, ob alle öffnenden Klammern im String s auch wieder geschlossen werden
  private static boolean checkBrackets(String s)
  {
    int cIndex = -1;
    int tIndex = 0;

    while (-1 != (cIndex = s.indexOf("(", cIndex+1)))
    {
      if (-1 == (tIndex = s.indexOf(")", ((cIndex > tIndex)?cIndex:tIndex+1)))) {return false;};
    }; // if (cIndex!=-1)
    return true;
  } // checkBrackets()
//*************************************************************************************************

} // class CapNet