package slangc.model.statements;

import slangc.api.BytecodeInstructionWriter;
import slangc.api.Reporter;
import slangc.model.ClauseModel;
import slangc.model.InnerTypeScope;
import slangc.model.MemberModel;
import slangc.model.StatementModel;
import slangc.model.StatementOwner;
import slangc.model.TypeModel;
import slangc.model.clauses.CatchClause;
import slangc.model.clauses.FinallyClause;
import slangc.parser.Branch;
import slangc.parser.Node;

public class TryStatement extends StatementModel implements StatementOwner {
	private StatementModel innerStatement;
	private CatchClause[] catchClauses;
	private FinallyClause finallyClause;

	public TryStatement(StatementOwner owner, Branch source) {
		super(owner, source);
		innerStatement = StatementModel.construct(this, source.getSubnode(2));
		ClauseModel[] catches = ClauseModel.constructMultiple(this, (Branch)source.getSubnode(3));
		catchClauses = new CatchClause[catches.length];
		for (int i = 0; i < catches.length; i++) {
			catchClauses[i] = (CatchClause)catches[i];
		}
		finallyClause = (FinallyClause)ClauseModel.construct(this, source.getSubnode(4));
	}

	//@Override
	public void dump(Reporter reporter, String indent, String incr) {
		reporter.note("DUMP", indent + "> Try:");
		innerStatement.dump(reporter, indent + incr, incr);
		for (int i = 0; i < catchClauses.length; i++) {
			catchClauses[i].dump(reporter, indent + incr, incr);
		}
		if (finallyClause != null) {
			finallyClause.dump(reporter, indent + incr, incr);
		}
	}
	
	//@Override
	public int resolveExpressions() {
		int nresolved = 0;
		nresolved += innerStatement.resolveExpressions();
		for (int i = 0; i < catchClauses.length; i++) {
			nresolved += catchClauses[i].resolveExpressions();
		}
		if (finallyClause != null) {
			nresolved += finallyClause.resolveExpressions();
		}
		return nresolved;
	}

	//@Override
	public TypeModel resolveType(Node subnode) {
		return getOwner().resolveType(subnode);
	}

	//@Override
	public MemberModel getMethodOrField() {
		return getOwner().getMethodOrField();
	}

	//@Override
	public InnerTypeScope getTypeScope() {
		return getOwner().getTypeScope();
	}

	public MethodModel[] lookupSimpleMethod(String name) {
		// TODO: Better interface support
		return super.lookupSimpleMethod(name);
	}

	public slangc.model.Named lookupSimpleName(String name) {
		// TODO: Better interface support
		return super.lookupSimpleName(name);
	}
	
	@Override
	public void innerGenerate(BytecodeInstructionWriter w) {
		BytecodeInstructionWriter.Label begin = w.newLabel("try_begin");
		BytecodeInstructionWriter.Label end = w.newLabel("try_end");
		BytecodeInstructionWriter.Label catchEnd = w.newLabel("try_catch_end");
		BytecodeInstructionWriter.CatchLabel[] catches = new BytecodeInstructionWriter.CatchLabel[catchClauses.length];
		BytecodeInstructionWriter.FinallyLabel fin = finallyClause == null ? null : w.newFinallyLabel("try_finally", begin, catchEnd);
		
		for (int i = 0; i < catches.length; i++) {
			catches[i] = w.newCatchLabel("try_catch", begin, end, catchClauses[i].getCatchType().getTypeSignature());
		}
		
		w.labelHere(begin);
		getInnerStatement().generate(w);
		w.genJump(BytecodeInstructionWriter.JumpOp.GOTO, catchEnd);
		w.labelHere(end);
		for (int i = 0; i < catches.length; i++) {
			w.labelHere(catches[i]);
			// Manually notify the writer that a typeName (the exception) has been pushed
			w.vpush(catchClauses[i].getCatchType().getTypeSignature());
			// Now we just need to store it to our variable so it can be accessed normally
			// It needs to be declared first, but in practice a backend may just ignore this declaration
			w.genDeclareLocal(catchClauses[i].getCatchVariable().getStorageType().getTypeSignature(), catchClauses[i].getCatchVariable().getIndex());
			w.genStoreLocalOrParam(catchClauses[i].getCatchVariable().getStorageType().getTypeSignature(), catchClauses[i].getCatchVariable().getIndex());
			catchClauses[i].getInnerStatement().generate(w);
			w.genJump(BytecodeInstructionWriter.JumpOp.GOTO, catchEnd);
		}
		w.labelHere(catchEnd);
		
		if (finallyClause != null) {
			w.labelHere(fin);
			finallyClause.getInnerStatement().generate(w);
			w.genCheckRethrow();
		}
	}
	
	public StatementModel getInnerStatement() {
		return innerStatement;
	}
}