/*
   	Copyright (c) 2009 Olivier Chafik, All Rights Reserved
   	
   	This file is part of JNAerator (http://jnaerator.googlecode.com/).
   	
   	JNAerator is free software: you can redistribute it and/or modify
   	it under the terms of the GNU Lesser General Public License as published by
   	the Free Software Foundation, either version 3 of the License, or
   	(at your option) any later version.
  	
  	JNAerator is distributed in the hope that it will be useful,
  	but WITHOUT ANY WARRANTY; without even the implied warranty of
  	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  	GNU Lesser General Public License for more details.
  	
  	You should have received a copy of the GNU Lesser General Public License
  	along with JNAerator.  If not, see <http://www.gnu.org/licenses/>.
  */
  package com.ochafik.lang.jnaerator.parser;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  
  public abstract class Statement extends Element {
  	
  	public static class Throw extends Statement {
  		Expression expression;
  		public Expression getExpression() {
  			return expression;
  		}
  		public void setExpression(Expression expression) {
  			this.expression = changeValue(this, this.expression, expression);
  		}
  		public Throw() {}
  		public Throw(Expression expression) {
  			setExpression(expression);
  		}
  		@Override
  		public void accept(Visitor visitor) {
  			visitor.visitThrow(this);
  		}
  
  		@Override
  		public Element getNextChild(Element child) {
  			return null;
  		}
  
  		@Override
  		public Element getPreviousChild(Element child) {
  			return null;
  		}
  
  		@Override
  		public boolean replaceChild(Element child, Element by) {
  			if (child == getExpression()) {
  				setExpression((Expression)by);
  				return true;
  			}
  			return false;
  		}
  
  		@Override
  		public String toString(CharSequence indent) {
  			return "throw " + getExpression().toString(indent) + ";";
  		}
  
  	}
  	public static class DeclarationStatement extends Statement {
  		Declaration declaration;
  		public void setDeclaration(Declaration declaration) {
  			this.declaration = changeValue(this, this.declaration, declaration);
  		}
  		public Declaration getDeclaration() {
  			return declaration;
  		}
  		public DeclarationStatement() {}
  		public DeclarationStatement(Declaration declaration) {
  			setDeclaration(declaration);
  		}
  		@Override
  		public void accept(Visitor visitor) {
  			visitor.visitDeclarationStatement(this);
  		}
  		@Override
  		public Element getNextChild(Element child) {
  			return null;
  		}
  		@Override
  		public Element getPreviousChild(Element child) {
  			return null;
  		}
  		@Override
  		public boolean replaceChild(Element child, Element by) {
  			if (child == getDeclaration()) {
  				setDeclaration((Declaration)by);
  				return true;
  			}
  			return false;
 		}
 		@Override
 		public String toString(CharSequence indent) {
 			return getDeclaration() == null ? "" : getDeclaration().toString(indent);
 		}
 	}
 	public static class Return extends Statement {
 		Expression value;
 		
 		public Return() {}
 		public Return(Expression value) {
 			setValue(value);
 		}
 
 		public void setValue(Expression value) {
 			this.value = changeValue(this, this.value, value);
 		}
 		public Expression getValue() {
 			return value;
 		}
 		@Override
 		public void accept(Visitor visitor) {
 			visitor.visitReturn(this);
 		}
 
 		@Override
 		public Element getNextChild(Element child) {
 			return null;
 		}
 
 		@Override
 		public Element getPreviousChild(Element child) {
 			return null;
 		}
 
 		@Override
 		public boolean replaceChild(Element child, Element by) {
 			if (child == getValue()) {
 				setValue((Expression)by);
 				return true;
 			}
 			return false;
 		}
 
 		@Override
 		public String toString(CharSequence indent) {
 			return "return " + (getValue() == null ? "<null>" : getValue().toString(indent)) + ";";
 		}
 
 	}
 	public static class If extends Statement {
 		public If() {}
 		public If(Expression condition, Statement thenBranch, Statement elseBranch) {
 			setCondition(condition);
 			setThenBranch(thenBranch);
 			setElseBranch(elseBranch);
 		}
 		Expression condition;
 		Statement thenBranch, elseBranch;
 		
 		public void setElseBranch(Statement elseBranch) {
 			this.elseBranch = changeValue(this, this.elseBranch, elseBranch);
 		}
 		public void setCondition(Expression condition) {
 			this.condition = changeValue(this, this.condition, condition);
 		}
 		public void setThenBranch(Statement thenBranch) {
 			this.thenBranch = changeValue(this, this.thenBranch, thenBranch);
 		}
 		public Statement getElseBranch() {
 			return elseBranch;
 		}
 		public Statement getThenBranch() {
 			return thenBranch;
 		}
 		public Expression getCondition() {
 			return condition;
 		}
 		@Override
 		public void accept(Visitor visitor) {
 			visitor.visitIf(this);
 		}
 		@Override
 		public Element getNextChild(Element child) {
 			return null;
 		}
 		@Override
 		public Element getPreviousChild(Element child) {
 			return null;
 		}
 		@Override
 		public boolean replaceChild(Element child, Element by) {
 			if (child == getCondition()) {
 				setCondition((Expression)by);
 				return true;
 			}
 			if (child == getThenBranch()) {
 				setThenBranch((Statement)by);
 				return true;
 			}
 			if (child == getElseBranch()) {
 				setElseBranch((Statement)by);
 				return true;
 			}
 			return false;
 		}
 		@Override
 		public String toString(CharSequence indent) {
 			StringBuffer b = new StringBuffer("if (");
 			if (getCondition() == null)
 				b.append("<null>");
 			else
 				b.append(getCondition().toString(indent));
 			String indent2 = indent + "\t";
 			b.append(") ");
 			if (getThenBranch() == null)
 				b.append("<null>");
 			else {
 				if (getThenBranch() instanceof Block) {
 					b.append(getThenBranch().toString(indent));
 					if (getElseBranch() != null)
 						b.append(" ");
 				} else {
 					b.append("\n");
 					b.append(indent2);
 					b.append(getThenBranch().toString(indent2));
 					if (getElseBranch() != null)
 						b.append("\n" + indent);
 				}
 			}
 			
 			if (getElseBranch() != null) {
 				b.append("else ");
 				if (getElseBranch() instanceof Block) {
 					b.append(getElseBranch().toString(indent));
 				} else {
 					b.append("\n");
 					b.append(indent2);
 					b.append(getElseBranch().toString(indent2));
 				}
 			}
 			return b.toString();
 		}
 	}
 	public static class ExpressionStatement extends Statement {
 
 		public ExpressionStatement() {}
 		public ExpressionStatement(Expression expression) {
 			setExpression(expression);
 		}
 
 		Expression expression;
 		
 		public Expression getExpression() {
 			return expression;
 		}
 		public void setExpression(Expression expression) {
 			this.expression = changeValue(this, this.expression, expression);
 		}
 		
 		@Override
 		public void accept(Visitor visitor) {
 			visitor.visitExpressionStatement(this);
 		}
 
 		@Override
 		public Element getNextChild(Element child) {
 			return null;
 		}
 
 		@Override
 		public Element getPreviousChild(Element child) {
 			return null;
 		}
 
 		@Override
 		public boolean replaceChild(Element child, Element by) {
 			if (getExpression() == child) {
 				setExpression((Expression)by);
 				return true;
 			}
 			return false;
 		}
 
 		@Override
 		public String toString(CharSequence indent) {
 			return expression == null ? null : expression.toString(indent) + ";";
 		}
 		
 	}
 	
 	public static class Block extends Statement {
 		final List<Statement> statements = new ArrayList<Statement>();
 		@Override
 		public void accept(Visitor visitor) {
 			visitor.visitBlock(this);
 		}
 
 		boolean compact;
 		
 		@Override
 		public Block clone() {
 			return (Block)super.clone();
 		}
 		
 		public Block setCompact(boolean compact) {
 			this.compact = compact;
 			return this;
 		}
 		public boolean isCompact() {
 			return compact;
 		}
 		public Block() {}
 		public Block(Statement... statements) {
 			addStatements(statements);
 		}
 		public Block(List<Statement> statements) {
 			setStatements(statements);
 		}
 		public void addStatement(Statement statement) {
 			if (statement != null) {
 				statement.setParentElement(this);
 				statements.add(statement);
 			}
 		}
 		public void setStatements(List<Statement> statements) {
 			changeValue(this, this.statements, statements);
 		}
 		public void addStatements(Statement... statements) {
 			setStatements(Arrays.asList(statements));
 		}
 		public List<Statement> getStatements() {
 			return unmodifiableList(statements);
 		}
 		@Override
 		public Element getNextChild(Element child) {
 			return getNextSibling(statements, child);
 		}
 
 		@Override
 		public Element getPreviousChild(Element child) {
 			return getPreviousSibling(statements, child);
 		}
 
 		@Override
 		public boolean replaceChild(Element child, Element by) {
 			return replaceChild(statements, Statement.class, this, child, by);
 		}
 
 		@Override
 		public String toString(CharSequence indent) {
 			String nindent = indent + "\t";
 //			if (statements.size() == 1 && !(getParentElement() instanceof Function))
 //				return "\t" + statements.get(0).toString(nindent);
 			
 			StringBuilder b = new StringBuilder();
 			b.append('{');
 			if (!statements.isEmpty()) {
 				if (isCompact()) {
 					b.append(' ');
 					b.append(implode(statements, ", ", indent));
 					b.append(' ');
 				} else {
 					String lnindent = "\n" + nindent;
 					b.append(lnindent);
 					b.append(implode(statements, lnindent, nindent));
 					b.append('\n');
 					b.append(indent);
 				}
 			}
 			b.append('}');
 			return b.toString();
 		}
 
 	}
 }