package persistence.antlr.debug;

import java.util.Vector;
import java.util.Hashtable;
import java.util.Enumeration;
import persistence.antlr.collections.impl.BitSet;
import persistence.antlr.RecognitionException;


/** A class to assist in firing parser events
 *  NOTE: I intentionally _did_not_ synchronize the event firing and
 *        add/remove listener methods.  This is because the add/remove should
 *        _only_ be called by the parser at its start/end, and the _same_thread_
 *        should be performing the parsing.  This should help performance a tad...
 */
public class ParserEventSupport {
	private Object source;
	private Hashtable doneListeners;
	private Vector matchListeners;
	private Vector messageListeners;
	private Vector tokenListeners;
	private Vector traceListeners;
	private Vector semPredListeners;
	private Vector synPredListeners;
	private Vector newLineListeners;
	private ParserMatchEvent        matchEvent;
	private MessageEvent            messageEvent;
	private ParserTokenEvent        tokenEvent;
	private SemanticPredicateEvent  semPredEvent;
	private SyntacticPredicateEvent synPredEvent;
	private TraceEvent              traceEvent;
	private NewLineEvent            newLineEvent;
	private ParserController        controller;
	protected static final int CONSUME=0;
	protected static final int ENTER_RULE=1;
	protected static final int EXIT_RULE=2;
	protected static final int LA=3;
	protected static final int MATCH=4;
	protected static final int MATCH_NOT=5;
	protected static final int MISMATCH=6;
	protected static final int MISMATCH_NOT=7;
	protected static final int REPORT_ERROR=8;
	protected static final int REPORT_WARNING=9;
	protected static final int SEMPRED=10;
	protected static final int SYNPRED_FAILED=11;
	protected static final int SYNPRED_STARTED=12;
	protected static final int SYNPRED_SUCCEEDED=13;
	protected static final int NEW_LINE=14;
	protected static final int DONE_PARSING=15;
	private int ruleDepth = 0;


	public ParserEventSupport(Object source) {
		matchEvent   = new ParserMatchEvent(source);
		messageEvent = new MessageEvent(source);
		tokenEvent   = new ParserTokenEvent(source);
		traceEvent   = new TraceEvent(source);
		semPredEvent = new SemanticPredicateEvent(source);
		synPredEvent = new SyntacticPredicateEvent(source);
		newLineEvent = new NewLineEvent(source);
		this.source = source;
	}
	public void addDoneListener(ListenerBase l) {
		if (doneListeners == null) doneListeners = new Hashtable();
		Integer i = (Integer)doneListeners.get(l);
		int val;
		if (i != null)
			val = i.intValue() + 1;
		else
			val = 1;
		doneListeners.put(l, new Integer(val));
	}
	public void addMessageListener(MessageListener l) {
		if (messageListeners == null) messageListeners = new Vector();
		messageListeners.addElement(l);
		addDoneListener(l);
	}
	public void addNewLineListener(NewLineListener l) {
		if (newLineListeners == null) newLineListeners = new Vector();
		newLineListeners.addElement(l);
		addDoneListener(l);
	}
	public void addParserListener(ParserListener l) {
		if (l instanceof ParserController) {
			((ParserController)l).setParserEventSupport(this);
			controller = (ParserController)l;
		}	
		addParserMatchListener(l);
		addParserTokenListener(l);

		addMessageListener(l);
		addTraceListener(l);
		addSemanticPredicateListener(l);
		addSyntacticPredicateListener(l);
	}
	public void addParserMatchListener(ParserMatchListener l) {
		if (matchListeners == null) matchListeners = new Vector();
		matchListeners.addElement(l);
		addDoneListener(l);
	}
	public void addParserTokenListener(ParserTokenListener l) {
		if (tokenListeners == null) tokenListeners = new Vector();
		tokenListeners.addElement(l);
		addDoneListener(l);
	}
	public void addSemanticPredicateListener(SemanticPredicateListener l) {
		if (semPredListeners == null) semPredListeners = new Vector();
		semPredListeners.addElement(l);
		addDoneListener(l);
	}
	public void addSyntacticPredicateListener(SyntacticPredicateListener l) {
		if (synPredListeners == null) synPredListeners = new Vector();
		synPredListeners.addElement(l);
		addDoneListener(l);
	}
	public void addTraceListener(TraceListener l) {
		if (traceListeners == null) traceListeners = new Vector();
		traceListeners.addElement(l);
		addDoneListener(l);
	}
	public void fireConsume(int value) {
		tokenEvent.setValues(ParserTokenEvent.CONSUME, 1, value);
		fireEvents(CONSUME, tokenListeners);		
	}
	public void fireDoneParsing() {
		traceEvent.setValues(TraceEvent.DONE_PARSING, 0,0,0);

		Hashtable targets=null;
//		Hashtable targets=doneListeners;
		ListenerBase l=null;
		
		synchronized (this) {
			if (doneListeners == null) return;
			targets = (Hashtable)doneListeners.clone();
		}
		
		if (targets != null) {
			Enumeration e = targets.keys();
			while(e.hasMoreElements()) {
				l = (ListenerBase)e.nextElement();
				fireEvent(DONE_PARSING, l);
			}
		}	
		if (controller != null)
			controller.checkBreak();
	}
	public void fireEnterRule(int ruleNum, int guessing, int data) {
		ruleDepth++;
		traceEvent.setValues(TraceEvent.ENTER, ruleNum, guessing, data);
		fireEvents(ENTER_RULE, traceListeners);
	}
	public void fireEvent(int type, ListenerBase l) {
		switch(type) {
			case CONSUME:    ((ParserTokenListener)l).parserConsume(tokenEvent); break;
			case LA:         ((ParserTokenListener)l).parserLA(tokenEvent);      break;

			case ENTER_RULE: ((TraceListener)l).enterRule(traceEvent);           break;
			case EXIT_RULE:  ((TraceListener)l).exitRule(traceEvent);            break;

			case MATCH:        ((ParserMatchListener)l).parserMatch(matchEvent);       break;
			case MATCH_NOT:    ((ParserMatchListener)l).parserMatchNot(matchEvent);    break;
			case MISMATCH:     ((ParserMatchListener)l).parserMismatch(matchEvent);    break;
			case MISMATCH_NOT: ((ParserMatchListener)l).parserMismatchNot(matchEvent); break;

			case SEMPRED:      ((SemanticPredicateListener)l).semanticPredicateEvaluated(semPredEvent); break;

			case SYNPRED_STARTED:   ((SyntacticPredicateListener)l).syntacticPredicateStarted(synPredEvent);   break;
			case SYNPRED_FAILED:    ((SyntacticPredicateListener)l).syntacticPredicateFailed(synPredEvent);    break;
			case SYNPRED_SUCCEEDED: ((SyntacticPredicateListener)l).syntacticPredicateSucceeded(synPredEvent); break;

			case REPORT_ERROR:   ((MessageListener)l).reportError(messageEvent);   break;
			case REPORT_WARNING: ((MessageListener)l).reportWarning(messageEvent); break;

			case DONE_PARSING: l.doneParsing(traceEvent); break;
			case NEW_LINE:     ((NewLineListener)l).hitNewLine(newLineEvent); break;
			
			default:
				throw new IllegalArgumentException("bad type "+type+" for fireEvent()");
		}	
	}
	public void fireEvents(int type, Vector listeners) {
		ListenerBase l=null;
		
		if (listeners != null)
			for (int i = 0; i < listeners.size(); i++) {
				l = (ListenerBase)listeners.elementAt(i);
				fireEvent(type, l);
			}
		if (controller != null)
			controller.checkBreak();
	}
	public void fireExitRule(int ruleNum, int guessing, int data) {
		traceEvent.setValues(TraceEvent.EXIT, ruleNum, guessing, data);
		fireEvents(EXIT_RULE, traceListeners);
		ruleDepth--;
		if (ruleDepth == 0)
			fireDoneParsing();
	}
	public void fireLA(int k, int la) {
		tokenEvent.setValues(ParserTokenEvent.LA, k, la);
		fireEvents(LA, tokenListeners);
	}
	public void fireMatch(char c, int guessing) {
		matchEvent.setValues(ParserMatchEvent.CHAR, c, new Character(c), null, guessing, false, true);
		fireEvents(MATCH, matchListeners);
	}
	public void fireMatch(char value, BitSet b, int guessing) {
		matchEvent.setValues(ParserMatchEvent.CHAR_BITSET, value, b, null, guessing, false, true);
		fireEvents(MATCH, matchListeners);
	}
	public void fireMatch(char value, String target, int guessing) {
		matchEvent.setValues(ParserMatchEvent.CHAR_RANGE, value, target, null, guessing, false, true);
		fireEvents(MATCH, matchListeners);
	}
	public void fireMatch(int value, BitSet b, String text, int guessing) {
		matchEvent.setValues(ParserMatchEvent.BITSET, value, b, text, guessing, false, true);
		fireEvents(MATCH, matchListeners);
	}
	public void fireMatch(int n, String text, int guessing) {
		matchEvent.setValues(ParserMatchEvent.TOKEN, n, new Integer(n), text, guessing, false, true);
		fireEvents(MATCH, matchListeners);
	}
	public void fireMatch(String s, int guessing) {
		matchEvent.setValues(ParserMatchEvent.STRING, 0, s, null, guessing, false, true);
		fireEvents(MATCH, matchListeners);
	}
	public void fireMatchNot(char value, char n, int guessing) {
		matchEvent.setValues(ParserMatchEvent.CHAR, value, new Character(n), null, guessing, true, true);
		fireEvents(MATCH_NOT, matchListeners);
	}
	public void fireMatchNot(int value, int n, String text, int guessing) {
		matchEvent.setValues(ParserMatchEvent.TOKEN, value, new Integer(n), text, guessing, true, true);
		fireEvents(MATCH_NOT, matchListeners);
	}
	public void fireMismatch(char value, char n, int guessing) {
		matchEvent.setValues(ParserMatchEvent.CHAR, value, new Character(n), null, guessing, false, false);
		fireEvents(MISMATCH, matchListeners);
	}
	public void fireMismatch(char value, BitSet b, int guessing) {
		matchEvent.setValues(ParserMatchEvent.CHAR_BITSET, value, b, null, guessing, false, true);
		fireEvents(MISMATCH, matchListeners);
	}
	public void fireMismatch(char value, String target, int guessing) {
		matchEvent.setValues(ParserMatchEvent.CHAR_RANGE, value, target, null, guessing, false, true);
		fireEvents(MISMATCH, matchListeners);
	}
	public void fireMismatch(int value, int n, String text, int guessing) {
		matchEvent.setValues(ParserMatchEvent.TOKEN, value, new Integer(n), text, guessing, false, false);
		fireEvents(MISMATCH, matchListeners);
	}
	public void fireMismatch(int value, BitSet b, String text, int guessing) {
		matchEvent.setValues(ParserMatchEvent.BITSET, value, b, text, guessing, false, true);
		fireEvents(MISMATCH, matchListeners);
	}
	public void fireMismatch(String value, String text, int guessing) {
		matchEvent.setValues(ParserMatchEvent.STRING, 0, text, value, guessing, false, true);
		fireEvents(MISMATCH, matchListeners);
	}
	public void fireMismatchNot(char value, char c, int guessing) {
		matchEvent.setValues(ParserMatchEvent.CHAR, value, new Character(c), null, guessing, true, true);
		fireEvents(MISMATCH_NOT, matchListeners);
	}
	public void fireMismatchNot(int value, int n, String text, int guessing) {
		matchEvent.setValues(ParserMatchEvent.TOKEN, value, new Integer(n), text, guessing, true, true);
		fireEvents(MISMATCH_NOT, matchListeners);
	}
	public void fireNewLine(int line) {
		newLineEvent.setValues(line);
		fireEvents(NEW_LINE, newLineListeners);
	}
	public void fireReportError(Exception e) {
		messageEvent.setValues(MessageEvent.ERROR, e.toString());
		fireEvents(REPORT_ERROR, messageListeners);
	}
	public void fireReportError(String s) {
		messageEvent.setValues(MessageEvent.ERROR, s);
		fireEvents(REPORT_ERROR, messageListeners);
	}
	public void fireReportWarning(String s) {
		messageEvent.setValues(MessageEvent.WARNING, s);
		fireEvents(REPORT_WARNING, messageListeners);
	}
	public boolean fireSemanticPredicateEvaluated(int type, int condition, boolean result, int guessing) {
		semPredEvent.setValues(type, condition, result, guessing);
		fireEvents(SEMPRED, semPredListeners);
		return result;
	}
	public void fireSyntacticPredicateFailed(int guessing) {
		synPredEvent.setValues(0, guessing);
		fireEvents(SYNPRED_FAILED, synPredListeners);
	}
	public void fireSyntacticPredicateStarted(int guessing) {
		synPredEvent.setValues(0, guessing);
		fireEvents(SYNPRED_STARTED, synPredListeners);
	}
	public void fireSyntacticPredicateSucceeded(int guessing) {
		synPredEvent.setValues(0, guessing);
		fireEvents(SYNPRED_SUCCEEDED, synPredListeners);
	}
	protected void refresh(Vector listeners) {
		Vector v;
		synchronized (listeners) {
			v = (Vector)listeners.clone();
		}
		if (v != null)
			for (int i = 0; i < v.size(); i++)
				((ListenerBase)v.elementAt(i)).refresh();
	}
	public void refreshListeners() {
		refresh(matchListeners);
		refresh(messageListeners);
		refresh(tokenListeners);
		refresh(traceListeners);
		refresh(semPredListeners);
		refresh(synPredListeners);
	}
	public void removeDoneListener(ListenerBase l) {
		if (doneListeners == null) return;
		Integer i = (Integer)doneListeners.get(l);
		int val=0;
		if (i != null)
			val = i.intValue() - 1;

		if (val == 0) 
			doneListeners.remove(l);
		else
			doneListeners.put(l, new Integer(val));
	}
	public void removeMessageListener(MessageListener l) {
		if (messageListeners != null)
			messageListeners.removeElement(l);
		removeDoneListener(l);
	}
	public void removeNewLineListener(NewLineListener l) {
		if (newLineListeners != null)
			newLineListeners.removeElement(l);
		removeDoneListener(l);
	}
	public void removeParserListener(ParserListener l) {
		removeParserMatchListener(l);
		removeMessageListener(l);
		removeParserTokenListener(l);
		removeTraceListener(l);
		removeSemanticPredicateListener(l);
		removeSyntacticPredicateListener(l);
	}
	public void removeParserMatchListener(ParserMatchListener l) {
		if (matchListeners != null)
			matchListeners.removeElement(l);
		removeDoneListener(l);
	}
	public void removeParserTokenListener(ParserTokenListener l) {
		if (tokenListeners != null)
			tokenListeners.removeElement(l);
		removeDoneListener(l);
	}
	public void removeSemanticPredicateListener(SemanticPredicateListener l) {
		if (semPredListeners != null)
			semPredListeners.removeElement(l);
		removeDoneListener(l);
	}
	public void removeSyntacticPredicateListener(SyntacticPredicateListener l) {
		if (synPredListeners != null)
			synPredListeners.removeElement(l);
		removeDoneListener(l);
	}
	public void removeTraceListener(TraceListener l) {
		if (traceListeners != null)
			traceListeners.removeElement(l);
		removeDoneListener(l);
	}
}
