/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/


package com.nokia.s60tools.traceanalyser.model;

import java.util.ArrayList;

import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;


import com.nokia.s60tools.traceanalyser.containers.RuleInformation;
import com.nokia.s60tools.traceanalyser.export.ITraceAnalyserRuleType;
import com.nokia.s60tools.traceanalyser.export.RuleEvent;
import com.nokia.s60tools.traceanalyser.export.TraceAnalyserRule;
import com.nokia.s60tools.traceanalyser.interfaces.ITraceAnalyserFileObserver;
import com.nokia.s60tools.traceanalyser.plugin.TraceAnalyserPlugin;
import com.nokia.s60tools.traceanalyser.ui.views.MainView;

/**
 * class engine.
 * Engine of Trace Analyser extension.
 */

public class Engine implements ITraceAnalyserFileObserver {
	
	/* Fail Log Manager */
	private FailLogManager failLogManager;
	
	/* Rule Manager */
	private RuleManager ruleManager;	
	
	/* Trace Listener */
	private TraceListener traceListener;
	
	/* list of rule types */
	ArrayList<ITraceAnalyserRuleType> ruleTypes;
	
	/* Main view */
	MainView mainView;
	
	/**
	 * Engine.
	 * constructor.
	 */
	public Engine(){
		
		// Get rule types
		ruleTypes = new ArrayList<ITraceAnalyserRuleType>();
		getRuleTypeArray();
		
		// create fail log manager
		failLogManager = new FailLogManager(this);
		
		// create rule manager
		ruleManager = new RuleManager(this, ruleTypes);
		
		// create trace listener
		traceListener = new TraceListener(this);
		
		// refresh fail log and rule information.
		failLogManager.refresh();
		ruleManager.refresh();
	}

	/**
	 * setMainView.
	 * @param mainView main view.
	 */
	public void setMainView(MainView mainView){
		this.mainView = mainView;
	}


	/**
	 * getRuleArray.
	 * Searches for rule type plug-ins and creates rule array from them.
	 */
	private void getRuleTypeArray(){

		final String EXTENSION_TRACE_ANALYSER_RULE = "traceanalyserrule"; //$NON-NLS-1$

		try {
			IExtensionRegistry er = Platform.getExtensionRegistry();
			IExtensionPoint ep = 
				er.getExtensionPoint(TraceAnalyserPlugin.PLUGIN_ID, EXTENSION_TRACE_ANALYSER_RULE);
			IExtension[] extensions = ep.getExtensions();

			// if plug-ins were found.
			if (extensions != null && extensions.length > 0) {
				
				// read all found rules
				for (int i = 0; i < extensions.length; i++) {
					IConfigurationElement[] ce = extensions[i].getConfigurationElements();
					if (ce != null && ce.length > 0) {
						try {
							ITraceAnalyserRuleType provider = (ITraceAnalyserRuleType)ce[0].createExecutableExtension("class");
							if (provider != null) {
								ruleTypes.add(provider);
							}
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * getFailLog
	 * @return fail log
	 */
	public RuleEvent[] getFailLog(){
		return failLogManager.getTraceAnalyserFailLog();
	}
	
	/**
	 * refreshFailLog.
	 * Refreshes Fail log
	 */
	public void refreshFailLog(){
		failLogManager.refresh();
	}
	
	/**
	 * clearFailLog.
	 * Clears fail log.
	 */
	public void clearFailLog(){
		failLogManager.clearLog();
	}
	
	/**
	 * addFailLogItem.
	 * @param item, new fail log item.
	 */
	public void addFailLogItem(RuleEvent item){
		failLogManager.addItem(item);
		if(mainView != null){
			mainView.blinkIcon();
		}
	}

	/**
	 * stop.
	 * Stops Trace Analyser Engine.
	 */
	public void stop(){
		failLogManager.saveLogToFile();
		ruleManager.saveData();
		traceListener.stopListening();
	}

	/*
	 * (non-Javadoc)
	 * @see com.nokia.s60tools.traceanalyser.interfaces.ITraceAnalyserFileObserver#failLogUpdated()
	 */
	public void failLogUpdated() {
		if(mainView != null){
			mainView.failLogUpdated();
		}
	}

	/*
	 * (non-Javadoc)
	 * @see com.nokia.s60tools.traceanalyser.interfaces.ITraceAnalyserFileObserver#rulesUpdated()
	 */
	public void rulesUpdated() {
		TraceAnalyserRule[] rules = ruleManager.getActivatedRules();
		traceListener.setRules(rules);
		if(mainView != null){
			mainView.rulesUpdated();
		}
	}
	
	/*
	 * (non-Javadoc)
	 * @see com.nokia.s60tools.traceanalyser.interfaces.ITraceAnalyserFileObserver#ruleUpdated(java.lang.String)
	 */
	public void ruleUpdated(String ruleName) {
		if(mainView != null){
			mainView.ruleUpdated(ruleName);
		}
	}
	
	/**
	 * refreshRuleList.
	 * Refreshes rule list. 
	 */
	public void refreshRuleList(){
		ruleManager.refresh();
	}

	/**
	 * getRuleInformation.
	 * @return Trace analyser rules.
	 */
	public RuleInformation[] getRuleInformation(){
		return ruleManager.getRuleInformation();
	}

	/**
	 * getRule.
	 * returns one rule.
	 * @param ruleName name of the rule that is requested.
	 * @return rule
	 */
	public TraceAnalyserRule getRule(String ruleName){
		return ruleManager.getRule(ruleName);
	}
	
	/**
	 * getRuleTypes.
	 * @return Trace Analyser Rule Types
	 */
	public ArrayList<ITraceAnalyserRuleType> getRuleTypes() {
		return ruleTypes;
	}
	
	/**
	 * addRule.
	 * @param newRule new Trace Analyser rule
	 * @return true if rule was added succesfully.
	 */
	public boolean addRule(TraceAnalyserRule newRule){
		boolean retval = ruleManager.addRule(newRule);
		traceListener.setRules(ruleManager.getActivatedRules());
		return retval;
	}
	
	
	/**
	 * getTraceListener.
	 * @return trace listener
	 */
	public TraceListener getTraceListener() {
		return traceListener;
	}

	/**
	 * changeRuleaActivation.
	 * @param ruleName name of the rule
	 */
	public void changeRuleaActivation(String ruleName, boolean value){
		ruleManager.changeRuleActivation(ruleName, value);
		TraceAnalyserRule[] rules = ruleManager.getActivatedRules();
		traceListener.setRules(rules);
	}
	/**
	 * removeRule
	 * @param ruleName rule that should be removed.
	 * @return true if rule was removed successfully.
	 */
	public boolean removeRule(String ruleName){
		return ruleManager.removeRule(ruleName);
	}
	
	/**
	 * addRuleEvent.
	 * @param ruleName name of rule where event is added.
	 * @param event rule that event is added into.
	 */
	public void addRuleEvent(String ruleName, RuleEvent event){
		ruleManager.addHistoryEvent(ruleName, event);
	}

	/**
	 * resets all rules history data.
	 */
	public void resetHistory(){
		ruleManager.clearHistory();
	}
	
	/**
	 * resets one rules history.
	 * @param ruleName
	 */
	public void resetOneRulesHistory(String ruleName){
		ruleManager.clearOneRulesHistory(ruleName);
	}
	
	/**
	 * ruleExists.
	 * @param ruleName name of the rule
	 * @return true if rule with that name already exists
	 */

	public boolean ruleExists(String ruleName){
		return ruleManager.ruleExists(ruleName);
	}
	
	
}