/*******************************************************************************
 * Copyright (c) 2013 <Project SWG>
 * 
 * This File is part of NGECore2.
 * 
 * This program 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.
 * 
 * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
 * 
 * Using NGEngine to work with NGECore2 is making a combined work based on
 * NGEngine. Therefore all terms and conditions of the GNU Lesser General Public
 * License cover the combination.
 ******************************************************************************/
package services;

import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.Vector;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

import protocol.swg.PlayClientEffectLocMessage;
import resources.harvest.SurveyTool;
import resources.objects.creature.CreatureObject;
import resources.objects.player.PlayerObject;
import resources.objects.resource.GalacticResource;
import resources.objects.resource.ResourceContainerObject;
import resources.objects.resource.ResourceRoot;
import resources.objects.tangible.TangibleObject;
import services.sui.SUIWindow;
import services.sui.SUIWindow.SUICallback;
import services.sui.SUIWindow.Trigger;
import main.NGECore;
import engine.resources.container.Traverser;
import engine.resources.objects.SWGObject;
import engine.resources.service.INetworkDispatch;
import engine.resources.service.INetworkRemoteEvent;

/**
 * @author Charon
 */
public class SurveyService implements INetworkDispatch {
	
	private NGECore core;
	private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
	public Vector<SurveyTool> activeSurveyTools = new Vector<SurveyTool>();
	
	public SurveyService(NGECore core) {
		this.core = core;
		scheduleSurveyService();
	}
	
	@SuppressWarnings("unused")
	public void scheduleSurveyService() {
		final ScheduledFuture<?> task = scheduler.scheduleAtFixedRate(new Runnable() {
			@Override
			public void run() {
				try {
					processActiveTools();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}, 10, 1000, TimeUnit.MILLISECONDS);
		
	}
	
	private void processActiveTools() {
		synchronized (activeSurveyTools) {
			// All tools sampling
			Iterator <SurveyTool> surveyIterator = activeSurveyTools.iterator();
			while (surveyIterator.hasNext()) {
				SurveyTool surveyTool = surveyIterator.next();
				if (surveyTool == null)
					continue;
				CreatureObject user = (CreatureObject) NGECore.getInstance().objectService.getObject(surveyTool.getUserID());
				if (surveyTool.getCurrentlySurveying()) {
					// Check if survey process has finished
					if (System.currentTimeMillis() > surveyTool.getLastSurveyTime() + 3000) {
						surveyIterator.remove();
						surveyTool.setCurrentlySurveying(false);
						surveyTool.sendConstructSurveyMapMessage();
					}
				}
				if (surveyTool.getCurrentlySampling()) {
					// Check if sampling process has finished
					if ((System.currentTimeMillis() > surveyTool.getLastSampleTime() + 3000) && !surveyTool.getCurrentlyCoolingDown()) {
						surveyTool.setCurrentlyCoolingDown(true);
						// Update inventory
						handleSamplingStages(surveyTool);
						
					}
					// Check if sampling recovery is over
					long sampleRecoveryTime = surveyTool.getRecoveryTime();
					if (System.currentTimeMillis() > surveyTool.getLastSampleTime() + sampleRecoveryTime && !surveyTool.isExceptionalState()) {
						// kick off another sampling attempt
						surveyTool.setCurrentlyCoolingDown(false);
						continueSampling(surveyTool);
					}
					if (user.getPosture() != 1) {
						surveyTool.setExceptionalState(false);
						surveyTool.setCurrentlySampling(false);
						surveyIterator.remove();
						if (user.getPosture() == 0)
							user.sendSystemMessage("You stand up", (byte) 0);
						
						user.sendSystemMessage("@survey:sample_cancel", (byte) 0);
					}
				}
			}
			activeSurveyTools.removeAll(Collections.singleton(null));
		}
	}
	
	@SuppressWarnings("unused")
	private void handleSamplingStages(SurveyTool surveyTool) {
		if (surveyTool.isExceptionalState())
			return;
		CreatureObject crafter = (CreatureObject) NGECore.getInstance().objectService.getObject(surveyTool.getUserID());
		PlayerObject player = (PlayerObject) crafter.getSlottedObject("ghost");
		GalacticResource sampleResource = (GalacticResource) NGECore.getInstance().objectService.getObject(surveyTool.getSurveyResourceID());
		int stackCount = 0;
		boolean gamblingwon = false;
		//ResourceContainerObject container = player.getRecentContainer();
		ResourceContainerObject container = null;
		// Attempt to find container with the currently sampled resource in
		// player inventory tree
		ResourceContainerObject foundContainer = findResourceContainerInInventory(crafter, sampleResource);
		if (foundContainer != null)
			container = foundContainer;
		
		if (!surveyTool.isRecoveryMode())
			stackCount = core.resourceService.getResourceSampleQuantity(crafter, sampleResource);
		else { // handle particularly rich case
			stackCount = core.resourceService.getResourceSampleQuantity(crafter, sampleResource);
			int recoveryChance = new Random().nextInt(100);
			if (recoveryChance < 99) {
				gamblingwon = true;
				stackCount *= 3;
			}
			surveyTool.setRecoveryMode(false);
		}
		
		if (container != null) {
			if (container.getReferenceID() == sampleResource.getId()) {
				int stackCountToUpdate = container.getStackCount();
				if (stackCountToUpdate < ResourceContainerObject.maximalStackCapacity - stackCount) { // sample fits into container
					SWGObject crafterInventory = crafter.getSlottedObject("inventory");
					container.setStackCount(stackCountToUpdate + stackCount, crafter);
					//crafter.sendSystemMessage("@base_player:prose_grant_xp @exp_n:resource_harvesting_inorganic", (byte) 0);
					core.playerService.giveExperience(crafter, (int) (2.5F * stackCount));
					//exp_n:resource_harvesting_inorganic
					
					//container.sendDelta3(crafter.getClient());
					//container.buildAttributeListMessage(crafter.getClient());
				} else { // new container
					if ((stackCount > 0) && (!surveyTool.isRecoveryMode())) {
						String resourceContainerIFF = ResourceRoot.CONTAINER_TYPE_IFF_SIGNIFIER[sampleResource.getResourceRoot().getContainerType()];
						ResourceContainerObject containerObject = (ResourceContainerObject) core.objectService.createObject(resourceContainerIFF, crafter.getPlanet());
						containerObject.initializeStats(sampleResource);
						containerObject.setProprietor(crafter);
						SWGObject crafterInventory = crafter.getSlottedObject("inventory");
						containerObject.setStackCount(stackCount, crafter);
						crafterInventory.add(containerObject);
						player.setRecentContainer(containerObject);
					}
				}
			} else { // Mismatch -> new container
				String resourceContainerIFF = ResourceRoot.CONTAINER_TYPE_IFF_SIGNIFIER[sampleResource.getResourceRoot().getContainerType()];
				if ((stackCount > 0) && (!surveyTool.isRecoveryMode())) {
					ResourceContainerObject containerObject = (ResourceContainerObject) core.objectService.createObject(resourceContainerIFF, crafter.getPlanet());
					containerObject.initializeStats(sampleResource);
					containerObject.setProprietor(crafter);
					container.setStackCount(stackCount, crafter);
					SWGObject crafterInventory = crafter.getSlottedObject("inventory");
					crafterInventory.add(containerObject);
					player.setRecentContainer(containerObject);
				}
			}
		} else { // create new container, first sample
		
			if ((stackCount > 0) && (!surveyTool.isRecoveryMode())) {
				
				String resourceContainerIFF = ResourceRoot.CONTAINER_TYPE_IFF_SIGNIFIER[sampleResource.getResourceRoot().getContainerType()];
				ResourceContainerObject containerObject = (ResourceContainerObject) core.objectService.createObject(resourceContainerIFF, crafter.getPlanet());
				containerObject.initializeStats(sampleResource);
				containerObject.setProprietor(crafter);
				//stackCount = core.resourceService.getResourceSampleQuantity(crafter, sampleResource); 
				containerObject.setStackCount(stackCount, crafter);
				SWGObject crafterInventory = crafter.getSlottedObject("inventory");
				crafterInventory.add(containerObject);
				player.setRecentContainer(containerObject);
			}
		}
		
		if (gamblingwon) {
			crafter.sendSystemMessage("@survey:critical_success", (byte) 0);
			core.playerService.giveExperience(crafter, (int) (2.5F * stackCount));
			surveyTool.setExceptionalState(false);
			return;
		}
		
		if ((stackCount > 0) && (!surveyTool.isRecoveryMode())) {
			// @survey:sample_located
			crafter.sendSystemMessage("You successfully locate a " + stackCount + " unit sample of " + sampleResource.getName() + ".", (byte) 0);
			core.playerService.giveExperience(crafter, (int) (2.5F * stackCount));
		}
		if ((stackCount > 0) && (surveyTool.isRecoveryMode())) {
			crafter.sendSystemMessage("@survey:node_recovery", (byte) 0);
			core.playerService.giveExperience(crafter, (int) (2.5F * stackCount));
		}
		if ((stackCount == 0) && (!surveyTool.isRecoveryMode())) {
			crafter.sendSystemMessage("@survey:sample_failed", (byte) 0);
			core.playerService.giveExperience(crafter, (int) (2.5F * stackCount));
			//surveyTool.setRecoveryMode(true);
			//surveyTool.setRecoveryTime(System.currentTimeMillis());						
		}
	}
	
	public ResourceContainerObject findResourceContainerInInventory(CreatureObject owner, GalacticResource resource) {
		ResourceContainerObject foundContainer = null;
		final Vector<ResourceContainerObject> found = new Vector<ResourceContainerObject>();
		TangibleObject playerInventory = (TangibleObject) owner.getSlottedObject("inventory");
		playerInventory.viewChildren(owner, false, false, new Traverser() {
			@Override
			public void process(SWGObject obj) {
				if (obj instanceof ResourceContainerObject) {
					ResourceContainerObject container = (ResourceContainerObject) obj;
					if (container.getReferenceID() == resource.getId() && container.getStackCount() < ResourceContainerObject.maximalStackCapacity - 10)
						found.add(container);
				}
			}
		});
		
		if (found.size() > 0)
			foundContainer = found.get(0);
		return foundContainer;
	}
	
	public void requestSurvey(CreatureObject crafter, SWGObject target, String commandArgs) {
		// Check if crafter has survey skill
		
//		if (!crafter.hasAbility("surveying")) { // ToDo !
//			crafter.sendSystemMessage("You have insufficient skill to survey", (byte) 0);
//			return;
//		}
		if (target == null) {
			System.err.println("SurveyService: Target Object Not Valid for surveying.");
			return; // target object not valid
		}
			
		if (crafter.getContainer() != null) {
			System.err.println("SurveyService: Container is not null!");
			return;
		}
		
		SurveyTool surveyTool = (SurveyTool) target;
		if (surveyTool.getToolType() == -1) {
			System.err.println("SurveyService: Survey tool type was not recognized.");
			return; // Survey tool type was not recognized
		}
			
		surveyTool.setUserID(crafter.getObjectID());
		surveyTool.setRecoveryTime(10000L);
		PlayerObject player = (PlayerObject) crafter.getSlottedObject("ghost");
		player.setLastUsedSurveyTool(surveyTool);
		if (surveyTool.getCurrentlySampling()) {
			crafter.sendSystemMessage("@survey:survey_sample", (byte) 0);
			return;
		}
		
		// QA tool lockup countermeasure
		if (surveyTool.getCurrentlySurveying() && surveyTool.getLastSurveyTime() < System.currentTimeMillis() - 3000) {
			surveyTool.setCurrentlySurveying(false);
			surveyTool.setLastSurveyTime(System.currentTimeMillis());
		}
		
		// Counter too frequent survey button activation
		if (surveyTool.getCurrentlySurveying()) {
			System.err.println("SurveyService: Pressed survey button too frequently");
			return;
		}
		
		if (core.terrainService.isWater(crafter.getPlanet(), crafter.getPosition().x, crafter.getPosition().z))
			crafter.sendSystemMessage("@survey:no_survey_in_water", (byte) 0);
		
//		Observer toolObserver    = surveyTool;
//		core.surveyService.addObserver(toolObserver);
		if (!toolIsInList(surveyTool))
			addActiveSurveyTool(surveyTool);
		
		String resourceNameString = commandArgs;
		GalacticResource resource = core.resourceService.grabResourceByName(resourceNameString);
		
		surveyTool.setCurrentlySurveying(true);
		surveyTool.setLastSurveyTime(System.currentTimeMillis());
		surveyTool.setSurveyResourceID(resource.getObjectID());
		synchronized (activeSurveyTools) {
			if (!activeSurveyTools.contains(surveyTool))
				activeSurveyTools.add(surveyTool);
		}
		
		String effectFile = surveyTool.getSurveyEffectString();
		PlayClientEffectLocMessage cEffMsg = new PlayClientEffectLocMessage(effectFile, crafter.getPlanet().getName(), crafter.getPosition());
		crafter.getClient().getSession().write(cEffMsg.serialize());
		crafter.sendSystemMessage("You begin to survey for " + commandArgs, (byte) 0);
	}
	
	public void requestSampling(CreatureObject crafter, SWGObject target, String commandArgs) {
		PlayerObject player = (PlayerObject) crafter.getSlottedObject("ghost");
		SurveyTool surveyTool = player.getLastUsedSurveyTool();
		
		if (surveyTool.getCurrentlySurveying()) {
			crafter.sendSystemMessage("@survey:sample_survey", (byte) 0);
			return;
		}
		
		if (crafter.getPosture() != 1) // QA
			surveyTool.setCurrentlySampling(false);
		
		if (surveyTool.getCurrentlySampling()) { // QA
			crafter.sendSystemMessage("@survey:already_sampling", (byte) 0);
			return;
		}
		
		if (crafter.getPosture() == 13)
			return; // QA
			
		if (crafter.isInCombat()) { // QA
			crafter.sendSystemMessage("@survey:sample_cancel_attack", (byte) 0);
			return;
		}
		
		if (crafter.getPosture() == 10 || crafter.getPosture() == 11) { // QA
			crafter.sendSystemMessage("You cannot sample while on a mount", (byte) 0);
			return;
		}
		
		surveyTool.setCurrentlyCoolingDown(false);
		GalacticResource sampleResource = (GalacticResource) NGECore.getInstance().objectService.getObject(surveyTool.getSurveyResourceID());
		if (surveyTool == null || sampleResource == null) { // QA
			crafter.sendSystemMessage("You must survey for a resource before you can sample it.", (byte) 0);
			surveyTool.setExceptionalState(false);
			surveyTool.setCurrentlySampling(false);
			removeActiveSurveyTool(surveyTool);
			return;
		}
		
		if (sampleResource.getName().equals(commandArgs)) {
			float localConcentration = sampleResource.deliverConcentrationForSurvey(crafter.getPlanetId(), crafter.getPosition().x, crafter.getPosition().z);
			//float localConcentration = 1.0F;
			if (localConcentration > 0.3) {
				// Is the tool ready?
				if (surveyTool.getCurrentlySampling() || surveyTool.getCurrentlyCoolingDown()) {
					int remaining = 0; // calculate remaining time
					crafter.sendSystemMessage("You will be able to sample again in " + remaining + " seconds.", (byte) 0); // "@survey:tool_recharge_time"
				} else {
					if (sampleResource.getResourceRoot().getResourceClass().equals("Radioactive")){ //resourceRoot.getResourceClass("Radioactive");
						createRadioactivityWarningSUIWindow(crafter, surveyTool);
						return;
					}
					
					crafter.setPosture((byte) 1);
					crafter.sendSystemMessage("You kneel", (byte) 0);
					
					//int samplingCost=125-(int)crafter.getSkillMod("surveying").getModifier();
					int samplingCost = 125;
					if (crafter.getAction() - samplingCost < 0) { // Check HAM
						crafter.sendSystemMessage("@survey:gamble_no_action", (byte) 0);
						crafter.setPosture((byte) 0);
						surveyTool.setCurrentlySampling(false);
						surveyTool.setExceptionalState(false);
						removeActiveSurveyTool(surveyTool);
						return;
					}
					
					surveyTool.setCurrentlySampling(true);
					surveyTool.setLastSampleTime(System.currentTimeMillis());
					addActiveSurveyTool(surveyTool);
					
					String effectFile = surveyTool.getSampleEffectString();
					PlayClientEffectLocMessage cEffMsg = new PlayClientEffectLocMessage(effectFile, crafter.getPlanet().getName(), crafter.getPosition());
					crafter.getClient().getSession().write(cEffMsg.serialize());
					
					crafter.sendSystemMessage("You begin to sample for " + commandArgs, (byte) 0);
					surveyTool.setCurrentlySampling(true);
					
					crafter.setAction(crafter.getAction() - samplingCost);
					
				}
			} else {
				crafter.sendSystemMessage("There are only trace amounts of " + commandArgs + " here.  Find a higher concentration of the resource, and try sampling again.", (byte) 0); // "@survey:trace_amount:"
				surveyTool.setCurrentlySampling(false);
				surveyTool.setCurrentlySurveying(false);
				//surveyTool.setLastSampleTime(System.currentTimeMillis());
			}
		} else {
			crafter.sendSystemMessage("You must survey for " + commandArgs + " before you can sample for it.", (byte) 0);
			surveyTool.setExceptionalState(false);
			surveyTool.setCurrentlySampling(false);
			removeActiveSurveyTool(surveyTool);
		}
	}
	
	public void continueSampling(SurveyTool surveyTool) {
		
		surveyTool.setCurrentlyCoolingDown(false);
		CreatureObject crafter = (CreatureObject) NGECore.getInstance().objectService.getObject(surveyTool.getUserID());
		
		if (crafter.getPosture() != 1) {
			crafter.sendSystemMessage("@survey:sample_cancel", (byte) 0);
			surveyTool.setExceptionalState(false);
			surveyTool.setCurrentlySampling(false);
			removeActiveSurveyTool(surveyTool);
			return;
		}
		if (crafter.getPosture() == 13)
			return;
		
		if (crafter.isInCombat()) {
			crafter.sendSystemMessage("@survey:sample_cancel_attack", (byte) 0);
			return;
		}
		
		GalacticResource sampleResource = (GalacticResource) NGECore.getInstance().objectService.getObject(surveyTool.getSurveyResourceID());
		float localConcentration = sampleResource.deliverConcentrationForSurvey(crafter.getPlanetId(), crafter.getPosition().x, crafter.getPosition().z);
		//float localConcentration = 1.0F;
		if (localConcentration > 0.1) {
			crafter.setPosture((byte) 1);
			
			// ToDo: overfilling resource container with continuesampling
			
			//int samplingCost=125-(int)crafter.getSkillMod("surveying").getModifier();
			int samplingCost = 125;
			if (crafter.getAction() - samplingCost < 0 && !surveyTool.isExceptionalState()) {
				crafter.sendSystemMessage("@survey:gamble_no_action", (byte) 0);
				crafter.setPosture((byte) 0);
				surveyTool.setCurrentlySampling(false);
				surveyTool.setExceptionalState(false);
				//removeActiveSurveyTool(surveyTool);
				return;
			}
			
			if (!surveyTool.isRecoveryMode()) {
				int exceptionalChance = new Random().nextInt(100);		 // 7 was good	
				if (exceptionalChance < 20 && !surveyTool.isExceptionalState()) {
					crafter.sendSystemMessage("@survey:gnode_d", (byte) 0);
					surveyTool.setExceptionalState(true);
					
					final SUIWindow window = core.suiService.createSUIWindow("Script.listBox", crafter, surveyTool, 0);
					window.setProperty("bg.caption.lblTitle:Text", "@base_player:swg");
					window.setProperty("Prompt.lblPrompt:Text", "@survey:gnode_d");
					window.addListBoxMenuItem("@survey:gnode_1", 0);
					window.addListBoxMenuItem("@survey:gnode_2", 1);
					window.setProperty("btnOk:visible", "True");
					window.setProperty("btnCancel:visible", "True");
					window.setProperty("btnOk:Text", "@ok");
					window.setProperty("btnCancel:Text", "@cancel");
					Vector<String> returnList = new Vector<String>();
					returnList.add("List.lstList:SelectedRow");
					
					window.addHandler(0, "", Trigger.TRIGGER_OK, returnList, new SUICallback() {
						@Override
						public void process(SWGObject owner, int eventType, Vector<String> returnList) {
							int index = Integer.parseInt(returnList.get(0));
							if (index == 0) {
								// Continue working
								CreatureObject crafter = (CreatureObject) owner;
								PlayerObject player = (PlayerObject) crafter.getSlottedObject("ghost");
								if (crafter != null) {
									SurveyTool surveyTool = player.getLastUsedSurveyTool();
									if (surveyTool != null) {
										surveyTool.setExceptionalState(false);
										core.suiService.closeSUIWindow(owner, 0);
										continueSampling(surveyTool);
										return;
									}
								}
							} else {
								// Attempt to recover	
								CreatureObject crafter = (CreatureObject) owner;
								PlayerObject player = (PlayerObject) crafter.getSlottedObject("ghost");
								SurveyTool surveyTool = player.getLastUsedSurveyTool();
								if (surveyTool != null) {
									surveyTool.setRecoveryMode(true);
									surveyTool.setExceptionalState(false);
									core.suiService.closeSUIWindow(owner, 0);
									continueSampling(surveyTool);
									return;
								}
							}
						}
					});
					
					core.suiService.openSUIWindow(window);
					return;
				}
				
				surveyTool.setCurrentlySampling(true);
				surveyTool.setLastSampleTime(System.currentTimeMillis());
				
				String effectFile = surveyTool.getSampleEffectString();
				PlayClientEffectLocMessage cEffMsg = new PlayClientEffectLocMessage(effectFile, crafter.getPlanet().getName(), crafter.getPosition());
				crafter.getClient().getSession().write(cEffMsg.serialize());
				
				crafter.setAction(crafter.getAction() - samplingCost);
				
			} else {
				// sampling cost for recovery
				//surveyTool.setRecoveryMode(false);
				samplingCost = 200;
				if (crafter.getAction() - samplingCost < 0) {
					crafter.sendSystemMessage("@survey:gamble_no_action", (byte) 0);
					crafter.setPosture((byte) 0);
					surveyTool.setCurrentlySampling(false);
					surveyTool.setExceptionalState(false);
					surveyTool.setLastSampleTime(System.currentTimeMillis());
					removeActiveSurveyTool(surveyTool);
					return;
				}
				surveyTool.setCurrentlySampling(true);
				surveyTool.setLastSampleTime(System.currentTimeMillis());
				surveyTool.setExceptionalState(false);
				
				String effectFile = surveyTool.getSampleEffectString();
				PlayClientEffectLocMessage cEffMsg = new PlayClientEffectLocMessage(effectFile, crafter.getPlanet().getName(), crafter.getPosition());
				crafter.getClient().getSession().write(cEffMsg.serialize());
				crafter.setAction(crafter.getAction() - samplingCost);
				
			}
			
			surveyTool.setCurrentlySampling(true);
			surveyTool.setLastSampleTime(System.currentTimeMillis());
			
			String effectFile = surveyTool.getSampleEffectString();
			PlayClientEffectLocMessage cEffMsg = new PlayClientEffectLocMessage(effectFile, crafter.getPlanet().getName(), crafter.getPosition());
			crafter.getClient().getSession().write(cEffMsg.serialize());
			
			crafter.setAction(crafter.getAction() - samplingCost);
			
		} else {
			crafter.sendSystemMessage("There are only trace amounts of " + sampleResource.getName() + " here.  Find a higher concentration of the resource, and try sampling again.", (byte) 0); // "@survey:trace_amount:"
			surveyTool.setCurrentlySampling(false);
			surveyTool.setCurrentlySurveying(false);
		}
	}
	
	public void addActiveSurveyTool(SurveyTool tool) {
		synchronized (activeSurveyTools) {
			if (!activeSurveyTools.contains(tool))
				activeSurveyTools.add(tool);
		}
	}
	
	public Vector<SurveyTool> getActiveSurveyTools() {
		return activeSurveyTools;
	}
	
	public void removeActiveSurveyTool(SurveyTool surveyTool) {
		synchronized (activeSurveyTools) {
			activeSurveyTools.remove(surveyTool);
		}
	}
	
	public boolean toolIsInList(SurveyTool surveyTool) {
		synchronized (activeSurveyTools) {
			for (SurveyTool tool : activeSurveyTools) {
				if (tool.getTanoID() == surveyTool.getTanoID())
					return true;
			}
		}
		return false;
	}
	
	@Override
	public void insertOpcodes(Map<Integer, INetworkRemoteEvent> arg0, Map<Integer, INetworkRemoteEvent> arg1) {
		
	}
	
	@Override
	public void shutdown() {
		// TODO Auto-generated method stub
		
	}
	
	public SUICallback handleExceptionalInput(SWGObject crafter, SUIWindow suiWindow) {
		
		SUICallback callback = suiWindow.getCallbackByEventId(1);
		return callback;
	}
	
	public void createSurveyRangeSUIWindow(SWGObject owner, TangibleObject target) {
		final SUIWindow window = core.suiService.createSUIWindow("Script.listBox", owner, target, 0);
		window.setProperty("bg.caption.lblTitle:Text", "@base_player:swg");
		window.setProperty("Prompt.lblPrompt:Text", "@survey:select_range");
		window.addListBoxMenuItem("64m x 3pts", 0);
		window.addListBoxMenuItem("128m x 4pts", 1);
		window.addListBoxMenuItem("192m x 4pts", 2);
		window.addListBoxMenuItem("256m x 5pts", 3);
		window.addListBoxMenuItem("320m x 5pts", 4);
		window.setProperty("btnOk:visible", "True");
		window.setProperty("btnCancel:visible", "True");
		window.setProperty("btnOk:Text", "@ok");
		window.setProperty("btnCancel:Text", "@cancel");
		Vector<String> returnList = new Vector<String>();
		returnList.add("List.lstList:SelectedRow");
		final SurveyTool outerSurveyTool = (SurveyTool) target;
		
		window.addHandler(0, "", Trigger.TRIGGER_OK, returnList, new SUICallback() {
			@Override
			public void process(SWGObject owner, int eventType, Vector<String> returnList) {
				CreatureObject crafter = (CreatureObject) owner;
				//crafter.sendSystemMessage("handleSurveyRangeInput process", (byte) 0);
				if (crafter != null) {
					if (outerSurveyTool != null) {
						int index = Integer.parseInt(returnList.get(0));
						if (index == 0) {
							outerSurveyTool.setSurveyRangeSetting((byte) 0);
						}
						if (index == 1) {
							outerSurveyTool.setSurveyRangeSetting((byte) 1);
						}
						if (index == 2) {
							outerSurveyTool.setSurveyRangeSetting((byte) 2);
						}
						if (index == 3) {
							outerSurveyTool.setSurveyRangeSetting((byte) 3);
						}
						if (index == 4) {
							outerSurveyTool.setSurveyRangeSetting((byte) 4);
						}
					}
				}
			}
		});
		core.suiService.openSUIWindow(window);
	}
	
	public void createRadioactivityWarningSUIWindow(SWGObject owner, TangibleObject target) {
		// ToDo:
		final SUIWindow window = core.suiService.createSUIWindow("Script.messageBox", owner, target, 0);
		window.setProperty("bg.caption.lblTitle:Text", "@base_player:swg");
		window.setProperty("Prompt.lblPrompt:Text", "@survey:radioactive_sample_d");
		window.setProperty("Prompt.lblPrompt:Text", "@survey:radioactive_sample_t");
		window.setProperty("btnOk:visible", "True");
		window.setProperty("btnCancel:visible", "True");
		window.setProperty("btnOk:Text", "@ok");
		window.setProperty("btnCancel:Text", "@cancel");
		
		Vector<String> returnList = new Vector<String>();
		returnList.add("List.lstList:SelectedRow");
		
		window.addHandler(0, "", Trigger.TRIGGER_OK, returnList, new SUICallback() {
			@Override
			public void process(SWGObject owner, int eventType, Vector<String> returnList) {
				((CreatureObject) owner).sendSystemMessage("Rad confirmed", (byte) 0);
			}
		});
		window.addHandler(1, "", Trigger.TRIGGER_CANCEL, returnList, new SUICallback() {
			@Override
			public void process(SWGObject owner, int eventType, Vector<String> returnList) {
				((CreatureObject) owner).sendSystemMessage("Rad declined", (byte) 0);
			}
		});
		core.suiService.openSUIWindow(window);
	}
	
	public SUICallback handleSurveyRangeInput(SWGObject crafter, SUIWindow suiWindow) {
		SUICallback callback = suiWindow.getCallbackByEventId(1);
		core.suiService.closeSUIWindow(crafter, 0);
		return callback;
	}
	
}