package slangc.model.statements;

import slang.data.List;
import slangc.api.BytecodeInstructionWriter;
import slangc.api.Reporter;
import slangc.model.InnerTypeScope;
import slangc.model.MemberModel;
import slangc.model.Named;
import slangc.model.StatementModel;
import slangc.model.StatementOwner;
import slangc.model.TypeModel;
import slangc.parser.Branch;
import slangc.parser.Node;
import slangc.parser.NodeType;

public class BlockStatement extends StatementModel implements StatementOwner {
	private List<StatementModel> statements = new List<StatementModel>();
	private InnerTypeScope.SourceScope typeScope;

	public BlockStatement(StatementOwner owner, Branch source) {
		super(owner, source);
		typeScope = owner.getTypeScope().getInnerScopeForSource(source);
		//System.err.println("Block scope for " + this + " is " + typeScope);
		if (typeScope != null && typeScope.source != source) {
			throw new Error("Mismatched scope!");
		}
		Branch inner = (Branch) source.getSubnode(1);
		for (int i = 0; i < inner.countSubnodes(); i++) {
			if (inner.getSubnode(i).getNodeType() != NodeType.SEMICOLON) {
				statements.append(StatementModel.construct(this, inner.getSubnode(i)));
			}
		}
	}
	
	//@Override
	public InnerTypeScope getTypeScope() {
		return typeScope == null ? getOwner().getTypeScope() : typeScope;
	}

	@Override
	public void dump(Reporter reporter, String indent, String incr) {
		reporter.note("DUMP", indent + "> Block statement:");
		for (int i = 0; i < statements.count(); i++) {
			StatementModel s = statements.get(i);
			s.dump(reporter, indent + incr, incr);
		}
	}

	//@Override
	public TypeModel resolveType(Node subnode) {
		return getTypeScope().resolveTypeReference(subnode);
	}
	//@Override
	public MemberModel getMethodOrField() {
		return getOwner().getMethodOrField();
	}
	
	@Override
	public Named lookupSimpleName(String name) {
		for (int i = 0; i < statements.count(); i++) {
			StatementModel s = statements.get(i);
			if (s instanceof VariableStatement) {
				VariableStatement vs = (VariableStatement) s;
				if (vs.hasVariable(name)) {
					return vs.getVariable(name);
				}
			}
		}
		
		if (typeScope != null) {
			if (typeScope.hasInnerType(name)) {
				return typeScope.getInnerType(name);
			}
		}
		
		return super.lookupSimpleName(name);
	}
	
	@Override
	public int resolveExpressions() {
		int nresolved = 0;
		for (int i = 0; i < statements.count(); i++) {
			StatementModel s = statements.get(i);
			nresolved = s.resolveExpressions();
		}
		return nresolved;
	}
	
	@Override
	public void innerGenerate(BytecodeInstructionWriter w) {
		for (int i = 0; i < statements.count(); i++) {
			StatementModel s = statements.get(i);
			s.generate(w);
		}
	}
	
	public int countInnerStatements() {
		return statements.count();
	}
	
	public StatementModel getInnerStatement(int i) {
		return statements.get(i);
	}

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