/*
 * Created on May 6, 2008
 * Created by Paul Gardner
 * 
 * Copyright (C) Azureus Software, Inc, All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * 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 General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */


package com.aelitis.azureus.core.metasearch.impl;

import java.io.File;
import java.io.InputStream;
import java.net.URL;
import java.util.*;

import org.gudy.azureus2.core3.config.COConfigurationManager;
import org.gudy.azureus2.core3.internat.MessageText;
import org.gudy.azureus2.core3.torrent.TOTorrent;
import org.gudy.azureus2.core3.util.*;
import org.gudy.azureus2.core3.xml.util.XUXmlWriter;

import org.gudy.azureus2.plugins.PluginInterface;
import org.gudy.azureus2.plugins.PluginListener;
import org.gudy.azureus2.plugins.ui.UIManager;
import org.gudy.azureus2.plugins.ui.UIManagerEvent;
import org.gudy.azureus2.plugins.utils.FeatureManager;
import org.gudy.azureus2.plugins.utils.StaticUtilities;
import org.gudy.azureus2.plugins.utils.FeatureManager.FeatureDetails;
import org.gudy.azureus2.plugins.utils.FeatureManager.Licence;
import org.gudy.azureus2.plugins.utils.search.Search;
import org.gudy.azureus2.plugins.utils.search.SearchException;
import org.gudy.azureus2.plugins.utils.search.SearchInitiator;
import org.gudy.azureus2.plugins.utils.search.SearchInstance;
import org.gudy.azureus2.plugins.utils.search.SearchListener;
import org.gudy.azureus2.plugins.utils.search.SearchObserver;
import org.gudy.azureus2.plugins.utils.search.SearchProvider;
import org.gudy.azureus2.plugins.utils.search.SearchProviderResults;
import org.gudy.azureus2.plugins.utils.search.SearchResult;
import org.gudy.azureus2.pluginsimpl.local.PluginInitializer;
import org.gudy.azureus2.pluginsimpl.local.utils.UtilitiesImpl;

import com.aelitis.azureus.core.custom.Customization;
import com.aelitis.azureus.core.custom.CustomizationManager;
import com.aelitis.azureus.core.custom.CustomizationManagerFactory;
import com.aelitis.azureus.core.messenger.config.PlatformMetaSearchMessenger;
import com.aelitis.azureus.core.metasearch.Engine;
import com.aelitis.azureus.core.metasearch.MetaSearch;
import com.aelitis.azureus.core.metasearch.MetaSearchException;
import com.aelitis.azureus.core.metasearch.MetaSearchManager;
import com.aelitis.azureus.core.metasearch.MetaSearchManagerListener;
import com.aelitis.azureus.core.metasearch.Result;
import com.aelitis.azureus.core.metasearch.ResultListener;
import com.aelitis.azureus.core.metasearch.SearchParameter;
import com.aelitis.azureus.core.metasearch.impl.plugin.PluginEngine;
import com.aelitis.azureus.core.subs.Subscription;
import com.aelitis.azureus.core.subs.SubscriptionManager;
import com.aelitis.azureus.core.subs.SubscriptionManagerFactory;
import com.aelitis.azureus.core.vuzefile.VuzeFile;
import com.aelitis.azureus.core.vuzefile.VuzeFileComponent;
import com.aelitis.azureus.core.vuzefile.VuzeFileHandler;
import com.aelitis.azureus.core.vuzefile.VuzeFileProcessor;
import com.aelitis.azureus.util.ConstantsVuze;
import com.aelitis.azureus.util.ImportExportUtils;

public class 
MetaSearchManagerImpl
	implements MetaSearchManager, UtilitiesImpl.searchManager, AEDiagnosticsEvidenceGenerator
{
	private static final boolean AUTO_MODE_DEFAULT		= true;
	
	
	private static final String	LOGGER_NAME = "MetaSearch";
	
	private static final int REFRESH_MILLIS = 23*60*60*1000;
	
	private static MetaSearchManagerImpl singleton;	
	
	public static void
	preInitialise()
	{
		VuzeFileHandler.getSingleton().addProcessor(
			new VuzeFileProcessor()
			{
				public void
				process(
					VuzeFile[]		files,
					int				expected_types )
				{
					for (int i=0;i<files.length;i++){
						
						VuzeFile	vf = files[i];
						
						VuzeFileComponent[] comps = vf.getComponents();
						
						for (int j=0;j<comps.length;j++){
							
							VuzeFileComponent comp = comps[j];
							
							int	comp_type = comp.getType();
							
							if ( comp_type == VuzeFileComponent.COMP_TYPE_METASEARCH_TEMPLATE ){
								
								try{
									Engine e = 
										getSingleton().importEngine(
											comp.getContent(), 
											(expected_types & VuzeFileComponent.COMP_TYPE_METASEARCH_TEMPLATE) == 0 );
									
									comp.setProcessed();
									
									if ( e != null ){
										
										comp.setData( Engine.VUZE_FILE_COMPONENT_ENGINE_KEY, e );
									}
								}catch( Throwable e ){
									
									Debug.printStackTrace(e);
								}
							}else if ( comp_type == VuzeFileComponent.COMP_TYPE_METASEARCH_OPERATION ){
								
								getSingleton().addOperation( comp.getContent());
								
								comp.setProcessed();
							}
						}
					}
				}
			});	
		
		TorrentUtils.addTorrentAttributeListener(
				new TorrentUtils.torrentAttributeListener()
				{
					public void 
					attributeSet(
						TOTorrent 	torrent,
						String 		attribute, 
						Object 		value )
					{
						if ( 	attribute == TorrentUtils.TORRENT_AZ_PROP_OBTAINED_FROM && 
								!TorrentUtils.isReallyPrivate( torrent )){
							
							try{
								getSingleton().checkPotentialAssociations( torrent.getHash(), (String)value );
								
							}catch( Throwable e ){
								
								Debug.printStackTrace(e);
							}
						}
					}
				});
	}
	
	public static synchronized MetaSearchManagerImpl
	getSingleton()
	{
		if ( singleton == null ){
			
			singleton = new MetaSearchManagerImpl();
		}
		return( singleton );
	}
	
	private MetaSearchImpl	meta_search;
	private AsyncDispatcher	dispatcher = new AsyncDispatcher( 10000 );
	
	private AESemaphore	initial_refresh_sem = new AESemaphore( "MetaSearch:initrefresh" );
	
	private AESemaphore	refresh_sem = new AESemaphore( "MetaSearch:refresh", 1 );
	
	private boolean	checked_customization;
	
	private AsyncDispatcher					op_dispatcher 	= new AsyncDispatcher(5*1000);
	private List<MetaSearchManagerListener>	listeners 		= new ArrayList<MetaSearchManagerListener>();
	private List<Map>						operations		= new ArrayList<Map>();
	
	private String		extension_key;
	
	private Map<String,EngineImpl>	potential_associations = 
		new LinkedHashMap<String,EngineImpl>(32,0.75f,true)
		{
			protected boolean 
			removeEldestEntry(
		   		Map.Entry<String,EngineImpl> eldest) 
			{
				return size() > 32;
			}
		};
	protected
	MetaSearchManagerImpl()
	{
		meta_search = new MetaSearchImpl( this );
		
		AEDiagnostics.addEvidenceGenerator( this );
		
		extension_key = COConfigurationManager.getStringParameter( "metasearch.extkey.latest", "" );

		if ( extension_key.length() == 0 ){
			
			extension_key = null;
		}
		
		setupExtensions();
		
		SimpleTimer.addPeriodicEvent(
			"MetaSearchRefresh",
			REFRESH_MILLIS,
			new TimerEventPerformer()
			{
				public void 
				perform(
					TimerEvent 	event ) 
				{
					refresh();
				}
			});
		
		refresh();
		
		UtilitiesImpl.addSearchManager( this );
	}
	
	public void 
	addProvider(
		PluginInterface		pi,
		SearchProvider 		provider ) 
	{
		String	id = pi.getPluginID() + "." + provider.getProperty( SearchProvider.PR_NAME );
		
		try{
			meta_search.importFromPlugin( id, provider );
			
		}catch( Throwable e ){
			
			Debug.out( "Failed to add search provider '" + id + "' (" + provider + ")", e );
		}
	}
	
	public void 
	removeProvider(
		PluginInterface		pi,
		SearchProvider 		provider ) 
	{
		String	id = pi.getPluginID() + "." + provider.getProperty( SearchProvider.PR_NAME );
		
		try{
			Engine[] engines = meta_search.getEngines( false, false );
			
			for ( Engine engine: engines ){
				
				if ( engine instanceof PluginEngine ){
					
					PluginEngine pe = (PluginEngine)engine;
					
					if ( pe.getProvider() == provider ){
						
						engine.delete();
					}
				}
			}
		}catch( Throwable e ){
			
			Debug.out( "Failed to remove search provider '" + id + "' (" + provider + ")", e );
		}
	}
	
	public SearchProvider[]
  	getProviders()
	{
		Engine[] engines = meta_search.getEngines( true, false );
		
		SearchProvider[] result = new SearchProvider[engines.length];
		
		for (int i=0;i<engines.length;i++){
				
			result[i] = new engineInfo( engines[i] );
		}
		
		return( result );
	}
	
	public Search 
	createSearch(
		String 		provider_ids,
		String 		properties_str )
	
		throws SearchException 
	{
		String[]	bits = XUXmlWriter.splitWithEscape( provider_ids, ',' );
		
		long[]	pids = new long[ bits.length ];
		
		for ( int i=0; i<bits.length; i++ ){
			
			pids[i] = Long.parseLong( bits[i] );
		}

		Map<String,String>	properties = new HashMap<String, String>();
		
		bits = XUXmlWriter.splitWithEscape( properties_str, ',' );

		for ( int i=0; i<bits.length; i++ ){

			String[] x = XUXmlWriter.splitWithEscape( bits[i], '=' );
			
			properties.put( x[0].trim(), x[1].trim());
		}
		
		return( createSearch( pids, properties, null ));
	}
	
  	public Search
  	createSearch(
  		SearchProvider[]	providers,
  		Map<String,String>	properties,
  		SearchListener		listener )
  	
  		throws SearchException
  	{
  		long[]	pids;
  		
  		if ( providers == null ){
  			
  			pids = new long[0];
  			
  		}else{
  			
  			pids = new long[providers.length];
  			
  			for (int i=0;i<pids.length;i++){
			
  				Long	id = (Long)providers[i].getProperty( SearchProvider.PR_ID );
			
  				if ( id == null ){
				
  					throw( new SearchException( "Unknown provider - no id available" ));
  				}
  				
  				pids[i] = id;
			}
  		}
  		
  		return( createSearch( pids, properties, listener ));
  	}
  	
  	protected Search
  	createSearch(
  		long[]				provider_ids,
  		Map<String,String>	properties,
  		SearchListener		listener )
  	
  		throws SearchException
  	{
		List<SearchParameter>	sps = new ArrayList<SearchParameter>();

 		String	search_term = properties.get( SearchInitiator.PR_SEARCH_TERM );
 		
 		if ( search_term == null ){
 			
 			throw( new SearchException( "Search term is mandatory" ));
 		}
 		
		sps.add( new SearchParameter( "s", search_term ));

 		String	mature 		= properties.get( SearchInitiator.PR_MATURE );
  		
		if ( mature != null ){
			
			sps.add( new SearchParameter( "m", mature.toString()));
		}
	
		SearchParameter[] parameters = (SearchParameter[])sps.toArray(new SearchParameter[ sps.size()] );

		Map<String,String>	context = new HashMap<String, String>();
		
		context.put( Engine.SC_FORCE_FULL, "true" );

		String	headers 		= null;
		int		max_per_engine	= 256;
		
		SearchObject search = new SearchObject( listener );
		
		Engine[]	used_engines;
		
		if ( provider_ids.length == 0 ){
			
			used_engines = getMetaSearch().search( search, parameters, headers, context, max_per_engine );

		}else{
			
			List<Engine>	selected_engines = new ArrayList<Engine>();
			
			for ( long id: provider_ids ){
				
				Engine engine = meta_search.getEngine( id );
				
				if ( engine == null ){
					
					throw( new SearchException( "Unknown engine id - " + id ));
					
				}else{
					
					selected_engines.add( engine );
				}
			}
			
			Engine[] engines = selected_engines.toArray( new Engine[ selected_engines.size()] );
	
			used_engines = getMetaSearch().search( engines, search, parameters, headers, context, max_per_engine );
		}
		
		search.setEnginesUsed( used_engines );
		
		return( search );
  	}
	
	protected void
	refresh()
	{
		dispatcher.dispatch(
			new AERunnable()
			{
				public void 
				runSupport() 
				{
					if ( dispatcher.getQueueSize() == 0 ){
						
						try{
							syncRefresh();
														
						}catch( Throwable e ){
							
						}
					}
				}
			});
	}
	
	protected void
	ensureEnginesUpToDate()
	{
		long timeout = meta_search.getEngineCount() == 0?(30*1000):(10*1000);
		
		if ( !initial_refresh_sem.reserve( timeout )){
			
			log( "Timeout waiting for initial refresh to complete, continuing" );
		}
	}
	
	protected void
	syncRefresh()
	
		throws MetaSearchException
	{
		boolean refresh_completed 	= false;
		boolean	first_run			= false;
		
		try{
			refresh_sem.reserve();
			
			first_run = COConfigurationManager.getBooleanParameter( "metasearch.refresh.first_run", true );
			
			if ( !checked_customization ){
				
				checked_customization = true;
				
				CustomizationManager cust_man = CustomizationManagerFactory.getSingleton();
				
				Customization cust = cust_man.getActiveCustomization();
				
				if ( cust != null ){
					
					String cust_name 	= COConfigurationManager.getStringParameter( "metasearch.custom.name", "" );
					String cust_version = COConfigurationManager.getStringParameter( "metasearch.custom.version", "0" );
					
					boolean	new_name 	= !cust_name.equals( cust.getName());
					boolean	new_version = org.gudy.azureus2.core3.util.Constants.compareVersions( cust_version, cust.getVersion() ) < 0;
					
					if ( new_name || new_version ){

						log( "Customization: checking templates for " + cust.getName() + "/" + cust.getVersion());
						
						try{
							InputStream[] streams = cust.getResources( Customization.RT_META_SEARCH_TEMPLATES );
							
							if ( streams.length > 0 && new_name ){
								
									// reset engines
								
								log( "    setting auto-mode to false" );
								
								setAutoMode( false );
								
								/*
								Engine[]	engines = meta_search.getEngines( false, false );

								for (int i=0;i<engines.length;i++){
									
									Engine engine = engines[i];
									
									if ( engine.getSelectionState()) == Engine.SEL_STATE_MANUAL_SELECTED ){
										
									}
								}
								*/
							}
							for (int i=0;i<streams.length;i++){
								
								InputStream is = streams[i];
								
								try{
									VuzeFile vf = VuzeFileHandler.getSingleton().loadVuzeFile(is);
									
									if ( vf != null ){
										
										VuzeFileComponent[] comps = vf.getComponents();
										
										for (int j=0;j<comps.length;j++){
											
											VuzeFileComponent comp = comps[j];
											
											if ( comp.getType() == VuzeFileComponent.COMP_TYPE_METASEARCH_TEMPLATE ){
												
												try{
													Engine e = 
														getSingleton().importEngine( comp.getContent(), false ); 
													
													log( "    updated " + e.getName());
													
													e.setSelectionState( Engine.SEL_STATE_MANUAL_SELECTED );
													
												}catch( Throwable e ){
													
													Debug.printStackTrace(e);
												}
											}
										}
									}
								}finally{
									
									try{
										is.close();
										
									}catch( Throwable e ){
									}
								}
							}
						}finally{
							
							COConfigurationManager.setParameter( "metasearch.custom.name", cust.getName());
							COConfigurationManager.setParameter( "metasearch.custom.version", cust.getVersion());
						}
					}
				}
			}
			
			log( "Refreshing engines" );
					
				// featured templates are always shown - can't be deselected
				// popular ones are selected if in 'auto' mode
				// manually selected ones are, well, manually selected
			
			Map<Long,PlatformMetaSearchMessenger.templateInfo>		vuze_selected_ids 		= new HashMap<Long, PlatformMetaSearchMessenger.templateInfo>();
			Map<Long,PlatformMetaSearchMessenger.templateInfo>		vuze_preload_ids 		= new HashMap<Long,PlatformMetaSearchMessenger.templateInfo>();
			
			Set<Long>		featured_ids 			= new HashSet<Long>();
			Set<Long>		popular_ids 			= new HashSet<Long>();
			Set<Long>		manual_vuze_ids 		= new HashSet<Long>();
			
			boolean		auto_mode = isAutoMode();
					
			Engine[]	engines = meta_search.getEngines( false, false );
	
			String	fud = meta_search.getFUD();
			
			try{
				PlatformMetaSearchMessenger.templateInfo[] featured = PlatformMetaSearchMessenger.listFeaturedTemplates( extension_key, fud );
				
				String featured_str = "";
				
				for (int i=0;i<featured.length;i++){
					
					PlatformMetaSearchMessenger.templateInfo template = featured[i];
					
					if ( !template.isVisible()){
						
						continue;
					}
					
					Long key = new Long( template.getId());
					
					vuze_selected_ids.put( key,	template );
					
					featured_ids.add( key );
					
					featured_str += (featured_str.length()==0?"":",") + key;
				}
					
				log( "Featured templates: " + featured_str );
				
				if ( auto_mode || first_run ){
					
					PlatformMetaSearchMessenger.templateInfo[] popular = PlatformMetaSearchMessenger.listTopPopularTemplates( extension_key, fud );
					
					String popular_str = "";
					String preload_str = "";
					
					for (int i=0;i<popular.length;i++){
						
						PlatformMetaSearchMessenger.templateInfo template = popular[i];
						
						if ( !template.isVisible()){
							
							continue;
						}
						
						Long	key = new Long( template.getId());
						
						if ( auto_mode ){
							
							if ( !vuze_selected_ids.containsKey( key )){
								
								vuze_selected_ids.put( key,	template );
								
								popular_ids.add( key );
								
								popular_str += (popular_str.length()==0?"":",") + key;
							}
						}else{
							
							if ( !vuze_preload_ids.containsKey( key )){
								
								vuze_preload_ids.put( key, template );
																
								preload_str += (preload_str.length()==0?"":",") + key;
							}
						}
					}
					
					log( "Popular templates: " + popular_str );
					
					if ( preload_str.length() > 0 ){
						
						log( "Pre-load templates: " + popular_str );
					}
				}
						
					// pick up explicitly selected vuze ones
				
				String manual_str = "";
				
				for (int i=0;i<engines.length;i++){
					
					Engine	engine = engines[i];
					
					Long key = new Long( engine.getId());
					
					if ( 	engine.getSource() == Engine.ENGINE_SOURCE_VUZE &&
							engine.getSelectionState() == Engine.SEL_STATE_MANUAL_SELECTED &&
							!vuze_selected_ids.containsKey( key )){
						
						manual_vuze_ids.add( key );
					}
				}
				
				if ( manual_vuze_ids.size() > 0 ){
					
					long[]	manual_ids = new long[manual_vuze_ids.size()];
					
					Iterator<Long> it = manual_vuze_ids.iterator();
					
					int	pos = 0;
					
					while( it.hasNext()){
						
						manual_ids[pos++] = it.next().longValue();
					}
					
					PlatformMetaSearchMessenger.templateInfo[] manual = PlatformMetaSearchMessenger.getTemplateDetails( extension_key, manual_ids );
										
					for (int i=0;i<manual.length;i++){
						
						PlatformMetaSearchMessenger.templateInfo template = manual[i];
						
						if ( !template.isVisible()){
							
							continue;
						}
						
						Long	key = new Long( template.getId());
													
						vuze_selected_ids.put( key, template );
														
						manual_str += (manual_str.length()==0?"":",") + key;
					}
				}
				
				log( "Manual templates: " + manual_str );
				
				Map<Long,Engine> existing_engine_map = new HashMap<Long,Engine>();
				
				String existing_str = "";
				
				for (int i=0;i<engines.length;i++){
					
					Engine	engine = engines[i];
					
					Long key = new Long( engine.getId());
	
					existing_engine_map.put( key, engine );
					
					existing_str += (existing_str.length()==0?"":",") + key + 
										"[source=" + Engine.ENGINE_SOURCE_STRS[engine.getSource()] +
										",type=" + engine.getType() + 
										",selected=" + Engine.SEL_STATE_STRINGS[engine.getSelectionState()] + "]";
				}
				
				log( "Existing templates: " + existing_str );
				
					// we've compiled a list of the engines we should have and their latest dates
				
					// update any that are out of date
				
				Iterator<Map.Entry<Long,PlatformMetaSearchMessenger.templateInfo>> it = vuze_selected_ids.entrySet().iterator();
				
				while( it.hasNext()){
					
					Map.Entry<Long,PlatformMetaSearchMessenger.templateInfo> entry = it.next();
					
					vuze_preload_ids.remove( entry.getKey());
					
					long	id 			= entry.getKey().longValue();
					
					PlatformMetaSearchMessenger.templateInfo template = entry.getValue();
					
					long	modified 	= template.getModifiedDate();
									
					Engine this_engine = (Engine)existing_engine_map.get( new Long(id));
					
					boolean	update = this_engine == null || this_engine.getLastUpdated() < modified;
	
					if ( update ){
						
						PlatformMetaSearchMessenger.templateDetails details = PlatformMetaSearchMessenger.getTemplate( extension_key, id );
	
						log( "Downloading definition of template " + id );
						log( details.getValue());
						
						if ( details.isVisible()){
							
							try{
								this_engine = 
									meta_search.importFromJSONString( 
										details.getType()==PlatformMetaSearchMessenger.templateDetails.ENGINE_TYPE_JSON?Engine.ENGINE_TYPE_JSON:Engine.ENGINE_TYPE_REGEX,
										details.getId(),
										details.getModifiedDate(),
										details.getRankBias(),
										details.getName(),
										details.getValue());
								
								this_engine.setSource( Engine.ENGINE_SOURCE_VUZE );
																
								meta_search.addEngine( this_engine );
								
							}catch( Throwable e ){
								
								log( "Failed to import engine '" + details.getValue() + "'", e );
							}
						}	
					}else if ( this_engine.getRankBias() != template.getRankBias()){
						
						this_engine.setRankBias( template.getRankBias());
						
						log( "Updating rank bias for " + this_engine.getString() + " to " + template.getRankBias());

					}else{
						
						log( "Not updating " + this_engine.getString() + " as unchanged" );
					}
					
					if ( this_engine != null ){
							
						int sel_state = this_engine.getSelectionState();
						
						if ( sel_state == Engine.SEL_STATE_DESELECTED ){
						
							log( "Auto-selecting " + this_engine.getString());
							
							this_engine.setSelectionState( Engine.SEL_STATE_AUTO_SELECTED );
							
						}else if ( auto_mode && sel_state == Engine.SEL_STATE_MANUAL_SELECTED ){
							
							log( "Switching Manual to Auto select for " + this_engine.getString());
							
							this_engine.setSelectionState( Engine.SEL_STATE_AUTO_SELECTED );
						}
					}
				}
				
					// do any pre-loads
				
				it = vuze_preload_ids.entrySet().iterator();
				
				while( it.hasNext()){
					
					Map.Entry<Long,PlatformMetaSearchMessenger.templateInfo> entry = it.next();
					
					long	id 			= ((Long)entry.getKey()).longValue();
									
					Engine this_engine = (Engine)existing_engine_map.get( new Long(id));
						
					if ( this_engine == null ){
						
						PlatformMetaSearchMessenger.templateDetails details = PlatformMetaSearchMessenger.getTemplate( extension_key, id );
	
						log( "Downloading pre-load definition of template " + id );
						log( details.getValue());
						
						if ( details.isVisible()){
							
							try{
								this_engine = 
									meta_search.importFromJSONString( 
										details.getType()==PlatformMetaSearchMessenger.templateDetails.ENGINE_TYPE_JSON?Engine.ENGINE_TYPE_JSON:Engine.ENGINE_TYPE_REGEX,
										details.getId(),
										details.getModifiedDate(),
										details.getRankBias(),
										details.getName(),
										details.getValue());
								
								this_engine.setSource( Engine.ENGINE_SOURCE_VUZE );
								
								this_engine.setSelectionState( Engine.SEL_STATE_DESELECTED );
																
								meta_search.addEngine( this_engine );
								
							}catch( Throwable e ){
								
								log( "Failed to import engine '" + details.getValue() + "'", e );
							}
						}			
					}
				}
				
					// deselect any not in use
				
				for (int i=0;i<engines.length;i++){
					
					Engine	engine = engines[i];
					
					if ( 	engine.getSource() == Engine.ENGINE_SOURCE_VUZE &&
							engine.getSelectionState() == Engine.SEL_STATE_AUTO_SELECTED &&
							!vuze_selected_ids.containsKey( new Long( engine.getId()))){
						
						log( "Deselecting " + engine.getString() + " as no longer visible on Vuze");
						
						engine.setSelectionState( Engine.SEL_STATE_DESELECTED );
					}
				}
				
					// finally pick up any unreported selection changes and re-affirm positive selections
				
				for (int i=0;i<engines.length;i++){
					
					Engine	engine = engines[i];
					
					if ( 	engine.getSource() == Engine.ENGINE_SOURCE_VUZE &&
							engine.getSelectionState() == Engine.SEL_STATE_MANUAL_SELECTED ){
						
						engine.recordSelectionState();
						
					}else{
						
						engine.checkSelectionStateRecorded();
					}
				}
				
				refresh_completed = true;
				
			}catch( Throwable e ){
				
				log( "Refresh failed", e );
				
				throw( new MetaSearchException( "Refresh failed", e ));
			}
		}finally{
			
			if ( first_run && refresh_completed ){
				
				COConfigurationManager.setParameter( "metasearch.refresh.first_run", false );
			}
			
			refresh_sem.release();
			
			initial_refresh_sem.releaseForever();
		}
	}
	
	public MetaSearch 
	getMetaSearch() 
	{
		return( meta_search );
	}
	
	public boolean
	isAutoMode()
	{
		return( COConfigurationManager.getBooleanParameter( "metasearch.auto.mode", AUTO_MODE_DEFAULT ));
	}
	
	protected void
	setAutoMode(
		boolean	auto )
	{
		COConfigurationManager.setParameter( "metasearch.auto.mode", auto );
	}
	
	public void
	setSelectedEngines(
		long[]		ids,
		boolean		auto )
	
		throws MetaSearchException
	{
		try{
			String	s = "";
			
			for (int i=0;i<ids.length;i++){
				
				s += (i==0?"":",") + ids[i];
			}
			
			log( "setSelectedIds: " + s + ", auto=" + auto );
			
				// first update state of auto and existing engines 
			
			COConfigurationManager.setParameter( "metasearch.auto.mode", auto );

			Engine[]	engines = meta_search.getEngines( false, false );
			
			Map<Long,Engine>	engine_map = new HashMap<Long,Engine>();
			
			for( int i=0;i<engines.length;i++){
				
				engine_map.put( new Long( engines[i].getId()), engines[i] );
			}
				
			Set<Engine> selected_engine_set = new HashSet<Engine>();
			
			for (int i=0;i<ids.length;i++){
				
				long	 id = ids[i];
				
				Engine existing = (Engine)engine_map.get(new Long(id));
				
				if ( existing != null ){
					
					existing.setSelectionState( Engine.SEL_STATE_MANUAL_SELECTED );
					
					selected_engine_set.add( existing );
				}
			}
		
				// now refresh - this will pick up latest state of things
			
			syncRefresh();
			
			engines = meta_search.getEngines( false, false );

				// next add in any missing engines
			
			for (int i=0;i<ids.length;i++){
				
				long	 id = ids[i];
				
				Engine existing = (Engine)engine_map.get(new Long(id));
				
				if ( existing == null ){
														
					PlatformMetaSearchMessenger.templateDetails details = PlatformMetaSearchMessenger.getTemplate( extension_key, id );
	
					log( "Downloading definition of template " + id );
					log( details.getValue());
					
					Engine new_engine = 
						meta_search.importFromJSONString( 
							details.getType()==PlatformMetaSearchMessenger.templateDetails.ENGINE_TYPE_JSON?Engine.ENGINE_TYPE_JSON:Engine.ENGINE_TYPE_REGEX,
							details.getId(),
							details.getModifiedDate(),
							details.getRankBias(),
							details.getName(),
							details.getValue());
							
					new_engine.setSelectionState( Engine.SEL_STATE_MANUAL_SELECTED );
										
					new_engine.setSource( Engine.ENGINE_SOURCE_VUZE );
						
					meta_search.addEngine( new_engine );
					
					selected_engine_set.add( new_engine );
				}
			}
			
				// deselect any existing manually selected ones that are no longer selected
			
			for( int i=0;i<engines.length;i++){

				Engine e = engines[i];
				
				if ( e.getSelectionState() == Engine.SEL_STATE_MANUAL_SELECTED ){
					
					if ( !selected_engine_set.contains( e )){
				
						e.setSelectionState( Engine.SEL_STATE_DESELECTED  );
					}
				}
			}
		}catch( Throwable e ){
			
			e.printStackTrace();
			
			if ( e instanceof MetaSearchException ){
				
				throw((MetaSearchException)e);
			}
			
			throw( new MetaSearchException( "Failed to set selected engines", e ));
		}
	}
	
	public Engine
	addEngine(
		long		id,
		int			type,
		String		name,
		String		json_value )
	
		throws MetaSearchException
	{
		if ( id == -1 ){
			
			id = getLocalTemplateID();
		}
		
		try{
			Engine engine = 
				meta_search.importFromJSONString( 
					type, id, SystemTime.getCurrentTime(), 1, name, json_value );
			
			engine.setSource( Engine.ENGINE_SOURCE_LOCAL );
			
			engine.setSelectionState( Engine.SEL_STATE_MANUAL_SELECTED );
			
			meta_search.addEngine( engine );
			
			return( engine );
			
		}catch( Throwable e ){
			
			throw( new MetaSearchException( "Failed to add engine", e ));
		}
	}
	
	public boolean
	isImportable(
		VuzeFile		vf )
	{
		VuzeFileComponent[] comps = vf.getComponents();
		
		for (int j=0;j<comps.length;j++){
			
			VuzeFileComponent comp = comps[j];
			
			int	comp_type = comp.getType();
			
			if ( comp_type == VuzeFileComponent.COMP_TYPE_METASEARCH_TEMPLATE ){
				
				try{
					EngineImpl engine = (EngineImpl)meta_search.importFromBEncodedMap( comp.getContent());
					
					long	id = engine.getId();
					
					Engine existing = meta_search.getEngine( id );
					
					if ( existing != null ){
						
						if ( existing.getSelectionState() == Engine.SEL_STATE_DESELECTED || !existing.sameLogicAs( engine )){
							
							return( true );
						}
					}else{
						try{						
							Engine[] engines = meta_search.getEngines( false, false );
								
							boolean is_new = true;
							
							for ( Engine e: engines ){
									
								if ( e.getSelectionState() != Engine.SEL_STATE_DESELECTED && e.sameLogicAs( engine )){
										
									is_new = false;
									
									break;
								}
							}
							
							if ( is_new ){
								
								return( true );
							}
						}catch( Throwable e ){	
						}	
					}
				}catch( Throwable e ){				
				}
			}
		}
		
		return( false );
	}
	
	public Engine
	importEngine(
		Map			map,
		boolean		warn_user )
	
		throws MetaSearchException
	{
		try{
			EngineImpl engine = (EngineImpl)meta_search.importFromBEncodedMap(map);
			
			long	id = engine.getId();
			
			Engine existing = meta_search.getEngine( id );
			
			if ( existing != null ){
				
				if ( existing.sameLogicAs( engine )){
					
					if ( warn_user ){
						
						UIManager ui_manager = StaticUtilities.getUIManager( 120*1000 );
						
						String details = MessageText.getString(
								"metasearch.addtemplate.dup.desc",
								new String[]{ engine.getName() });
						
						ui_manager.showMessageBox(
								"metasearch.addtemplate.dup.title",
								"!" + details + "!",
								UIManagerEvent.MT_OK );
					}
					
					return( existing );
				}
			}else{
									
				try{						
					Engine[] engines = meta_search.getEngines( false, false );
						
					for ( Engine e: engines ){
							
						if ( e.sameLogicAs( engine )){
								
							return( e );
						}
					}
				}catch( Throwable e ){
					
				}
			}
			
			if ( warn_user ){
				
				UIManager ui_manager = StaticUtilities.getUIManager( 120*1000 );
				
				String details = MessageText.getString(
						"metasearch.addtemplate.desc",
						new String[]{ engine.getName() });
				
				long res = ui_manager.showMessageBox(
						"metasearch.addtemplate.title",
						"!" + details + "!",
						UIManagerEvent.MT_YES | UIManagerEvent.MT_NO );
				
				if ( res != UIManagerEvent.MT_YES ){
					
					throw( new MetaSearchException( "User declined the template" ));
				}
			}
				// if local template then we try to use the id as is otherwise we emsure that
				// it is a local one
			
			if ( id >= 0 && id < Integer.MAX_VALUE ){
				
				id = getLocalTemplateID();
				
				engine.setId( id );
			}
			
			engine.setSource( Engine.ENGINE_SOURCE_LOCAL );
			
			engine.setSelectionState( Engine.SEL_STATE_MANUAL_SELECTED );
			
			meta_search.addEngine( engine );
			
			if ( warn_user ){
				
				UIManager ui_manager = StaticUtilities.getUIManager( 120*1000 );
				
				String details = MessageText.getString(
						"metasearch.addtemplate.done.desc",
						new String[]{ engine.getName() });
				
				ui_manager.showMessageBox(
						"metasearch.addtemplate.done.title",
						"!" + details + "!",
						UIManagerEvent.MT_OK );
			}
			
			return( engine );
			
		}catch( Throwable e ){
			
			if ( warn_user ){
				
				UIManager ui_manager = StaticUtilities.getUIManager( 120*1000 );
				
				String details = MessageText.getString(
						"metasearch.addtemplate.failed.desc",
						new String[]{ Debug.getNestedExceptionMessage(e) });
				
				ui_manager.showMessageBox(
						"metasearch.addtemplate.failed.title",
						"!" + details + "!",
						UIManagerEvent.MT_OK );
			}
			
			throw( new MetaSearchException( "Failed to add engine", e ));
		}
	}
	
	protected void
	addPotentialAssociation(
		EngineImpl		engine,
		String			key )
	{		
		if ( engine.isShareable() && !engine.isAuthenticated()){
			
			synchronized( potential_associations ){
				
				potential_associations.put( key, engine );
			}
		}
	}
	
	private void
	checkPotentialAssociations(
		byte[]		hash,
		String		key )
	{
		EngineImpl	engine;
		
		synchronized( potential_associations ){
			
			engine = potential_associations.remove( key );
		}
	
		if ( engine != null ){
	
			try{
				VuzeFile vf = engine.exportToVuzeFile( true );
				
				byte[] bytes = vf.exportToBytes();
												
				String url_str = "vuze://?body=" + new String( bytes, Constants.BYTE_ENCODING );
								
				SubscriptionManager sub_man = SubscriptionManagerFactory.getSingleton();
		
				Subscription subs =
					sub_man.createSingletonRSS(
						vf.getName() + ": " + engine.getName() + " (v" + engine.getVersion() + ")",
						new URL( url_str ),
						Integer.MAX_VALUE );
			
				subs.setSubscribed( true );
			
				subs.addAssociation( hash );
				
			}catch( Throwable e ){
				
				Debug.out( e );
			}
		}
	}
	
	public Engine[]
	loadFromVuzeFile(
		File		file )
	{
		VuzeFile vf = VuzeFileHandler.getSingleton().loadVuzeFile( file.getAbsolutePath());
		
		if ( vf != null ){
			
			return( loadFromVuzeFile( vf ));
		}
		
		return( new Engine[0]);
	}
	
	public Engine[]
	loadFromVuzeFile(
		VuzeFile		vf )
	{
		List<Engine>	result = new ArrayList<Engine>();
		
		VuzeFileComponent[] comps = vf.getComponents();
		
		for (int j=0;j<comps.length;j++){
			
			VuzeFileComponent comp = comps[j];
			
			if ( comp.getType() == VuzeFileComponent.COMP_TYPE_METASEARCH_TEMPLATE ){
				
				try{
					result.add( importEngine( comp.getContent(), false ));
											
				}catch( Throwable e ){
					
					Debug.printStackTrace(e);
				}
			}
		}
		
		return(result.toArray(new Engine[result.size()]));
	}
	
	public long
	getLocalTemplateID()
	{
		synchronized( this ){
			
			Random random = new Random();
			
			while( true ){
			
				long id = ((long)Integer.MAX_VALUE) + random.nextInt( Integer.MAX_VALUE );
				
				if ( meta_search.getEngine( id ) == null ){
					
					return( id );
				}
			}
		}
	}
	
	public void
	addListener(
		MetaSearchManagerListener		listener )
	{			
		synchronized( listeners ){
			
			listeners.add( listener );
		}
			
		dispatchOps();
	}
	
	public void
	removeListener(
		MetaSearchManagerListener		listener )
	{
		
	}
	
	private void
	addOperation(
		Map		map )
	{
		synchronized( listeners ){
			
			operations.add( map );
		}
		
		dispatchOps();
	}
	
	private void
	dispatchOps()
	{
		op_dispatcher.dispatch(
			new AERunnable()
			{
				public void
				runSupport()
				{
					List<MetaSearchManagerListener>	l;
					List<Map>						o;
					
					synchronized( listeners ){
					
						if ( listeners.size() == 0 || operations.size() == 0 ){
							
							return;
						}
						
						l = new ArrayList<MetaSearchManagerListener>( listeners );
						
						o = new ArrayList<Map>( operations );
						
						operations.clear();
					}
					
					for ( MetaSearchManagerListener listener: l ){
						
						for ( Map operation: o ){
					
							try{

								int	type = ImportExportUtils.importInt( operation, "type", -1 );
								
								if ( type == 1 ){
									
									String	term = ImportExportUtils.importString( operation, "term", null );
								
									if ( term == null ){
										
										Debug.out( "search term missing" );
										
									}else{
										
										listener.searchRequest( term );
									}
								}else{
								
									Debug.out( "unknown operation type " + type );
								}								
							}catch( Throwable e ){
								
								Debug.out( e );
							}
						}
					}
				}
			});
	}
	
	private void
	setupExtensions()
	{
		PluginInterface pi = PluginInitializer.getDefaultInterface();
		
		final FeatureManager fm = pi.getUtilities().getFeatureManager();
					
		fm.addListener(
			new FeatureManager.FeatureManagerListener()
			{
				public void
				licenceAdded(
					Licence	licence )
				{
					getExtensions( fm, false );
				}
				
				public void
				licenceChanged(
					Licence	licence )
				{
					getExtensions( fm, false );
				}
				
				public void
				licenceRemoved(
					Licence	licence )
				{
					getExtensions( fm, false );
				}
			});
		
		if ( pi.getPluginState().isInitialisationComplete()){
			
			getExtensions( fm, true );
			
		}else{
			
			pi.addListener(
				new PluginListener()
				{
					public void
					initializationComplete()
					{
						getExtensions( fm, false );
					}
					
					public void
					closedownInitiated()
					{
					}
					
					public void
					closedownComplete()
					{	
					}
				});
		}
	}
	
	private void
	getExtensions(
		FeatureManager		fm,
		boolean				init )
	{
		String	existing_ext 	= extension_key;
		String	latest_ext		= null;
		
		FeatureDetails[] fds = fm.getFeatureDetails( "core" );
		
		for ( FeatureDetails fd: fds ){
				
			if ( !fd.hasExpired()){
				
				String finger_print = (String)fd.getProperty( FeatureDetails.PR_FINGERPRINT );
					
				if ( finger_print != null ){
				
					latest_ext = fd.getLicence().getShortID() + "-" + finger_print;
					
					break;
				}
			}
		}

		if ( existing_ext != latest_ext ){
			
			if ( existing_ext == null || latest_ext == null || !existing_ext.equals( latest_ext )){
				
				extension_key	= latest_ext;
				
				COConfigurationManager.setParameter( "metasearch.extkey.latest", latest_ext==null?"":latest_ext );
				
				if ( !init ){
					
					refresh();
				}
			}
		}
	}
	
	protected String
	getExtensionKey()
	{
		return( extension_key );
	}
	
	public void 
	log(
		String 		s,
		Throwable 	e )
	{
		AEDiagnosticsLogger diag_logger = AEDiagnostics.getLogger( LOGGER_NAME );
		
		diag_logger.log( s );
		diag_logger.log( e );
		
		if ( ConstantsVuze.DIAG_TO_STDOUT ){
			
			System.out.println(Thread.currentThread().getName() + "|"
					+ System.currentTimeMillis() + "] " + s + ": " + Debug.getNestedExceptionMessage(e));
		}	
	}
	
	public void 
	log(
		String 	s )
	{
		AEDiagnosticsLogger diag_logger = AEDiagnostics.getLogger( LOGGER_NAME );
		
		diag_logger.log( s );
		
		if ( ConstantsVuze.DIAG_TO_STDOUT ){
			
			System.out.println(Thread.currentThread().getName() + "|"
					+ System.currentTimeMillis() + "] " + s);
		}
	}
	
	public void
	generate(
		IndentWriter		writer )
	{
		writer.println( "Metasearch: auto=" + isAutoMode());
			
		try{
			writer.indent();

			meta_search.generate( writer );
			
		}finally{
			
			writer.exdent();
		}
	}
	
	protected static class
	SearchObject
		implements Search, ResultListener
	{
		private SearchListener		listener;
		
		private Map<Long,engineInfo>	engine_map = new HashMap<Long, engineInfo>();
		private boolean					engines_set;
		
		private List<SearchProviderResults>	pending_results = new ArrayList<SearchProviderResults>();
		
		private boolean	is_complete;
		
		protected
		SearchObject(
			SearchListener	_listener )
		{
			listener = _listener;
		}
		
		protected void
		setEnginesUsed(
			Engine[]	engines )
		{
			boolean	report_complete;
			
			synchronized( engine_map ){
				
				for ( Engine e: engines ){
					
					getInfo( e );
				}
				
				engines_set = true;
				
				report_complete = reportOverallComplete();
			}
			
			if ( listener != null && report_complete ){
					
				listener.completed();
			}
		}
		
		private boolean
		reportOverallComplete()
		{
			if ( is_complete || !engines_set ){
				
				return( false );
			}
			
			for ( engineInfo info: engine_map.values()){
				
				if ( !info.isComplete()){
					
					return( false );
				}
			}
			
			is_complete = true;
			
			return( true );
		}
		
		protected engineInfo
		getInfo(
			Engine		engine )
		{
			synchronized( engine_map ){

				engineInfo res = engine_map.get( engine.getId());
				
				if ( res == null ){
					
					res = new engineInfo( engine );
					
					engine_map.put( engine.getId(), res );
				}
				
				return( res );
			}
		}
		
		public void 
		contentReceived(
			Engine 		engine, 
			String 		content )
		{	
				// boring
		}
		
		public void 
		matchFound( 
			Engine 		engine, 
			String[] 	fields )
		{	
			// boring
		}
		
		public void 
		resultsReceived(
			Engine 			engine,
			final Result[] 	results )
		{
			SearchProviderResults	result;

			synchronized( engine_map ){
				
				final engineInfo info = getInfo( engine );
				
				result = 
					new SearchProviderResults()
					{
						public SearchProvider
						getProvider()
						{
							return( info );
						}
						
						public SearchResult[]
						getResults()
						{
							return( wrapResults( results ));
						}
						
						public boolean
						isComplete()
						{
							return( false );
						}
						
						public SearchException
						getError()
						{
							return( null );
						}
					};
					
				pending_results.add( result );
			}
			
			if ( listener != null ){
				
				listener.receivedResults( new SearchProviderResults[]{ result });
			}
		}
		
		public void 
		resultsComplete(
			Engine 		engine )
		{
			boolean					report_complete;
			SearchProviderResults	result;
			
			synchronized( engine_map ){
				
				final engineInfo info = getInfo( engine );
				
				info.setComplete();
				
				report_complete = reportOverallComplete();
			
				result = 
					new SearchProviderResults()
					{
						public SearchProvider
						getProvider()
						{
							return( info );
						}
						
						public SearchResult[]
						getResults()
						{
							return( new SearchResult[0] );
						}
						
						public boolean
						isComplete()
						{
							return( true );
						}
						
						public SearchException
						getError()
						{
							return( null );
						}
					};
					
				pending_results.add( result );
			}
			
			if ( listener != null ){
				
				listener.receivedResults( new SearchProviderResults[]{ result });
				
				if ( report_complete ){
					
					listener.completed();
				}
			}
		}
		
		protected void
		failed(
			Engine						engine,
			final SearchException		error )
		{
			boolean					report_complete;
			SearchProviderResults	result;
			
			synchronized( engine_map ){
				
				final engineInfo info = getInfo( engine );
				
				info.setComplete();
				
				report_complete = reportOverallComplete();
				
				result = 
						new SearchProviderResults()
						{
							public SearchProvider
							getProvider()
							{
								return( info );
							}
							
							public SearchResult[]
							getResults()
							{
								return( new SearchResult[0] );
							}
							
							public boolean
							isComplete()
							{
								return( false );
							}
							
							public SearchException
							getError()
							{
								return( error );
							}
						};
						
				pending_results.add( result );
			}
			
			if ( listener != null ){
				
				listener.receivedResults( new SearchProviderResults[]{ result });
				
				if ( report_complete ){
					
					listener.completed();
				}
			}
		}
		
		public void 
		engineFailed(
			Engine 		engine, 
			Throwable 	cause )
		{
			failed( engine, new SearchException( "Search failed", cause ));
		}
		
		public void 
		engineRequiresLogin(
			Engine 		engine, 
			Throwable 	cause )
		{
			failed( engine, new SearchException( "Authentication required", cause ));
		}
		
		protected SearchResult[]
		wrapResults(
			Result[]	res )
		{
			SearchResult[] x = new SearchResult[ res.length ];
			
			for ( int i=0;i<x.length;i++){
				
				x[i] = new resultWrapper( res[i] );
			}
			
			return( x );
		}
		
		public SearchProviderResults[]
     	getResults()
		{
     		synchronized( engine_map ){

     			SearchProviderResults[] result = pending_results.toArray( new SearchProviderResults[pending_results.size()]);
     			
     			pending_results.clear();
     			
     			return( result );
     		}
		}
     	
     	public boolean
     	isComplete()
     	{
     		synchronized( engine_map ){
     			
     			if ( !is_complete ){
     				
     				return( false );
     			}
     			
     			if ( pending_results.size() > 0 ){
     				
     				return( false );
     			}
     			
     			return( true );
     		}
     	}
     	
     	protected static class
     	resultWrapper
     		implements SearchResult
     	{
     		private Result	result;
     		
     		protected
     		resultWrapper(
     			Result		_result )
     		{
     			result	= _result;
     		}
     		
     		public Object
     		getProperty(
     			int		property_name )
     		{
     			switch( property_name ){
	     			case PR_NAME:{
	     			
	     				return( result.getName());
	     			}
	     			case PR_PUB_DATE:{
	     				
	     				return( result.getPublishedDate());
	     			}
	     			case PR_SIZE:{
	     				
	     				return( result.getSize());
	     			}
	     			case PR_LEECHER_COUNT:{
	     				
	     				return( new Long( result.getNbPeers()));
	     			}
	     			case PR_SEED_COUNT:{
	     				
	     				return( new Long( result.getNbSeeds()));
	     			}
	     			case PR_SUPER_SEED_COUNT:{
	     				
	     				return( new Long( result.getNbSuperSeeds()));
	     			}
	     			case PR_CATEGORY:{
	     				
	     				return( result.getCategory());
	     			}
	     			case PR_COMMENTS:{
	     				
	     				return( new Long( result.getComments()));
	     			}
	     			case PR_VOTES:{
	     				
	     				return( new Long( result.getVotes()));
	     			}
	     			case PR_CONTENT_TYPE:{
	     				
	     				return( result.getContentType());
	     			}
	     			case PR_DETAILS_LINK:{
	     				
	     				return( result.getCDPLink());
	     			}
	     			case PR_DOWNLOAD_LINK:{
	     				
	     				return( result.getDownloadLink());
	     			}
	     			case PR_PLAY_LINK:{
	     				
	     				return( result.getPlayLink());
	     			}
	     			case PR_PRIVATE:{
	     				
	     				return( result.isPrivate());
	     			}
	     			case PR_DRM_KEY:{
	     				
	     				return( result.getDRMKey());
	     			}
	     			case PR_DOWNLOAD_BUTTON_LINK:{
	     				
	     				return( result.getDownloadButtonLink());
	     			}
	     			case PR_RANK:{
	     			
	     				float rank = result.getRank();
	     				
	     				return( new Long(rank==-1?-1:(long)( rank * 100 )));
	     			}
	     			case PR_ACCURACY:{
	     			
	     				float accuracy = result.getAccuracy();
	     				
	     				return( new Long(accuracy==-1?-1:(long)( accuracy * 100 )));
	     			}
	     			case PR_VOTES_DOWN:{
	     				
	     				return( new Long( result.getVotesDown()));
	     			}
	     			case PR_UID:{
	     			
	     				return( result.getUID());
	     			}
	     			case PR_HASH:{
	     				
	     				String base32_hash = result.getHash();
	     				
	     				if ( base32_hash != null ){
	     					
	     					return( Base32.decode( base32_hash ));
	     				}
	     				
	     				return( null );
	     			}
	     			default:{
	     				
	     				Debug.out( "Unknown property type " + property_name );
	     			}
     			}
     			
     			return( null );
     		}
     	}
	}
	
    protected static class
    engineInfo
    	implements SearchProvider
    {
    	private Engine		engine;
     		
    	private boolean		complete;
    	
    	protected
    	engineInfo(
    		Engine		_engine )
    	{
    		engine	= _engine;
    	}
    
    	protected void
    	setComplete()
    	{
    		complete	= true;
    	}
    	
    	protected boolean
    	isComplete()
    	{
    		return( complete );
    	}
    	
		public SearchInstance
		search(
			Map<String,Object>	search_parameters,
			SearchObserver		observer )
		
			throws SearchException
		{
			throw( new SearchException( "Not supported" ));
		}
		
		public Object
		getProperty(
			int			property )
		{
			if ( property == PR_ID ){
				
				return( engine.getId());
				
			}else if ( property == PR_NAME ){
				
				return( engine.getName());
				
			}else{
				
				return( null );
			}
		}
		
		public void
		setProperty(
			int			property,
			Object		value )
		{
			Debug.out( "Not supported" );
		}
	}
    
    public static void
    main(
    	String[]	args )
    {
    	try{
			VuzeFile	vf = VuzeFileHandler.getSingleton().create();
			
			Map contents = new HashMap();
			
			contents.put( "type", new Long( 1 ));
			contents.put( "term", "donkey" );
			
			vf.addComponent(
				VuzeFileComponent.COMP_TYPE_METASEARCH_OPERATION,
				contents);
			
			vf.write( new File( "C:\\temp\\search.vuze" ));
			
    	}catch( Throwable e ){
    		
    		e.printStackTrace();
    	}
    }
}
