import java.util.Observable;
import java.util.Stack;


class CalculatorEngine extends Observable {
	

	private int state;
	private Stack ops;
	private Op op;
	

	CalculatorEngine()
		{ this.clear(); }
	

	Stack ops()
		{ return this.ops; }
	
	void ops( Stack aStack )
		{ this.ops = aStack; }


	Op op()
		{ return this.op; }
		
	void op( Op anOp )
		{ this.op = anOp; }


	public void notifyObservers()
		{
		setChanged();
		notifyObservers( ops().peek() );
		}
		

	synchronized void digit( String aString )
		{
		String temp = new String(); //geaendert
		
		if ( state == 3 )
			{
			ops().push( "0" );
			state = 4;
			}
		if ( state == 7 )
			{
			clear();
			};
			
		temp =  (String) ops().pop();

		if ( ( state == 1 ) || ( state == 5 ) )
			{
			temp = temp + "." + aString;
			if ( state == 1 )
				{
				state = 2;
				}
			else if ( state == 5 )
				{
				state = 6;
				};
			}
		else
			{	// Diese Aenderung ist die Behebung der ueberfluessigen fuehrenden '0'
			
			if (temp=="0") temp = aString;	//geaendert
			
			else temp = temp + aString;		//geaendert
			
			};
		
		ops.push( temp );
		notifyObservers();
		}
	
	synchronized void period()
		{
		if ( state == 0 )
			{
			state = 1;
			}
		else if ( state == 3 )
			{
			ops().push( "0" );
			state = 5;
			}
		else if ( state == 4 )
			{
			state = 5;
			}
		else if ( state == 7 )
			{
			clear();
			state = 1;
			};
		}
	
	synchronized void operation( Op anOp )
		{		
		if ( anOp.isBinaryOp() )
			{
			binaryOperation( anOp );
			state = 3;
			}
		else
			{
			unaryOperation( anOp );
			};
		notifyObservers();
		}
	
	void binaryOperation( Op anOp )
		{
		if ( ( state == 4 ) || (state == 5) || (state == 6) )
			{
			Double temp1;
			Double temp2;
			 
			temp2 = ( new Double( (String) (ops().pop()) ) );
			temp1 = ( new Double( (String) (ops().pop()) ) );
			ops().push( op().perform( temp1, temp2 ).toString() );	
			};
		op( anOp );
		}
	
	void unaryOperation( Op anOp ) {
	
		
		/* Hier wird neu mit Hilfe der Methode 'isDouble' unterschieden, ob ein Integer
		oder ein Double eingegeben wurde. Dies ist ausschlaggebend um die fehlerhafte
		Anzeige des der Kommastelle bei der Negation zu verhindern.		
		*/
		
		if (isDouble((String) (ops().peek()))) {
							
			Double temp;
			
			temp = ( new Double( (String) (ops().pop()) ) );
			ops().push( anOp.perform( temp ).toString() );
		}
		
		else {
		
			if (anOp.isSquareRoot()) {
			
				Double temp;
			
				temp = ( new Double( (String) (ops().pop()) ) );
				ops().push( anOp.perform( temp ).toString() );
			}
		
			else {
		
				Integer temp;
				
				temp = ( new Integer( (String) (ops().pop()) ) );
				ops().push( anOp.perform( temp ).toString() );
			}
		}
	}
		
	synchronized void clear()
		{
		ops( new Stack() );
		ops().push( "0" );
		op( null );
		state = 0;
		
		notifyObservers();
		}
	
	synchronized void calculate()
		{
		binaryOperation( null );
		state = 7;
		
		notifyObservers();
		}
	
	// Diese Funktion unterscheidet, ob es sich um ein Integer oder ein Double handelt.
	
	boolean isDouble(String s) {
	
		Double d = new Double(s);
		boolean checkPoint = false;
		
		for (int i=0;i<s.length();i++) {
								
				if (s.charAt(i)=='.') { 
								
					checkPoint=true;
										
					break;
				}
			}
				
		if (checkPoint) {
				
			return true;
		}
		
		else {
		
			return false;
		}
		
	}	
		
}