/*
 * Created on 20-Dec-2005
 * Created by Paul Gardner
 * Copyright (C) 2005, 2006 Aelitis, 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.
 * 
 * AELITIS, SAS au capital de 46,603.30 euros
 * 8 Allee Lenotre, La Grille Royale, 78600 Le Mesnil le Roi, France.
 *
 */

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

import java.net.Inet4Address;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.List;

import org.gudy.azureus2.core3.config.COConfigurationListener;
import org.gudy.azureus2.core3.config.COConfigurationManager;
import org.gudy.azureus2.core3.util.*;

import com.aelitis.azureus.core.instancemanager.AZInstanceManagerAdapter;
import com.aelitis.azureus.core.networkmanager.admin.NetworkAdmin;
import com.aelitis.azureus.plugins.dht.DHTPlugin;
import com.aelitis.azureus.plugins.dht.DHTPluginContact;
import com.aelitis.azureus.plugins.dht.DHTPluginListener;
import com.aelitis.azureus.plugins.upnp.UPnPPlugin;

public class 
AZMyInstanceImpl
	extends AZInstanceImpl
{
	public static final long	FORCE_READ_EXT_MIN	= 8*60*60*1000;
	public static final long	UPNP_READ_MIN		= 5*60*1000;
	
	private AZInstanceManagerAdapter	adapter;
	private AZInstanceManagerImpl		manager;
	
	private String				id;
	private InetAddress			internal_address;
	private int					tcp_port;
	private int					udp_port;
	private int					udp_non_data_port;
	
	private long				last_upnp_read;
	
	private InetAddress			dht_address;
	private long				dht_address_time;
	
	private long				last_force_read_ext;
	private InetAddress			last_external_address;
	
	protected
	AZMyInstanceImpl(
		AZInstanceManagerAdapter	_adapter,
		AZInstanceManagerImpl		_manager )

	{
		adapter	= _adapter;
		manager	= _manager;
		
		id	= adapter.getID();
		
		if ( id.length() == 0 ){
			
			id	= "" + SystemTime.getCurrentTime();
		}
		
		id = ByteFormatter.encodeString( new SHA1Simple().calculateHash( id.getBytes()));
		
		COConfigurationManager.addListener( 
			new COConfigurationListener()
			{
				public void
				configurationSaved()
				{
					readConfig( false );
				}
			});
		
		readConfig( true );
		
		adapter.addListener(
			new AZInstanceManagerAdapter.StateListener()
			{
				public void
				started()
				{		        	
				    DHTPlugin dht = adapter.getDHTPlugin();
				    
			    	if ( dht != null ){
			    		
			        	dht.addListener(
			        		new DHTPluginListener()
			        		{
			        			public void
			        			localAddressChanged(
			        				DHTPluginContact	local_contact )
			        			{
			        				InetAddress latest_dht_address = local_contact.getAddress().getAddress();
			        								        				
			        				if ( sameFamily( internal_address, latest_dht_address )){
			        				
				        				dht_address 		= latest_dht_address;
				        				dht_address_time	= SystemTime.getCurrentTime();
				        				
				        				manager.informChanged( AZMyInstanceImpl.this );
			        				}
			        			}
			        		});
			    	}
				}
				
				public void
				stopped()
				{
				}
			});
	}
	
	protected void
	readConfig(
		boolean	first_time )
	{
		InetAddress	new_internal_address	= NetworkAdmin.getSingleton().getSingleHomedServiceBindAddress();
		
		if ( new_internal_address == null ){
			
			try{
				new_internal_address = InetAddress.getByName( "0.0.0.0" );
				
			}catch( Throwable e ){			
			}
		}
				
		int[]	ports = adapter.getPorts();
		
		int	new_tcp_port			= ports[0];
		int	new_udp_port			= ports[1];
		int	new_udp_non_data_port	= ports[2];
		
		boolean	same = true;
		
		if ( !first_time ){
			
			same = 	internal_address.equals( new_internal_address) &&
					tcp_port == new_tcp_port &&
					udp_port == new_udp_port &&
					udp_non_data_port == new_udp_non_data_port;
		}
		
		internal_address 	= new_internal_address;
		tcp_port			= new_tcp_port;
		udp_port			= new_udp_port;
		udp_non_data_port	= new_udp_non_data_port;
		
		if ( !same ){
			
			manager.informChanged( this );
		}
	}
	
	protected InetAddress
	readExternalAddress()
	{
		InetAddress	 external_address = null;

			// no point in kicking off any queries if we're closing
		
		if ( manager.isClosing()){
			
			external_address	= last_external_address;
			
			if ( external_address == null ){
				
				try{
					external_address = InetAddress.getByName("127.0.0.1");
					
				}catch( Throwable e ){
					
					Debug.printStackTrace(e);
				}
			}
			
			return( external_address );
		}
		        	
	    DHTPlugin dht = adapter.getDHTPlugin();
	    	    
	    	// if DHT has informed us of an address then we use this - most reliable up to date one
	    	// unless the version server cache time is more recent
	    
	    if ( dht_address != null && dht_address_time <= SystemTime.getCurrentTime()){
	    	
	    	AZInstanceManagerAdapter.VCPublicAddress a = adapter.getVCPublicAddress();

	    	if ( a != null ){
	    		
	    		long cache_time = a.getCacheTime(); 
	    		
		    	if ( cache_time <= dht_address_time ){
		    		
		    		external_address = dht_address;
		    	}
	    	}
	    }

	    if ( 	external_address == null &&
	    		( dht == null || dht.getStatus() != DHTPlugin.STATUS_RUNNING )){
		
	    		// use cached version if available and the DHT isn't

	    	AZInstanceManagerAdapter.VCPublicAddress a = adapter.getVCPublicAddress();
	    			
			if ( a != null ){
				
				try{
					
					external_address	= InetAddress.getByName( a.getAddress());
					
				}catch( Throwable e ){
					
					Debug.printStackTrace(e);
				}
			}
		}
		
		if ( external_address == null && dht != null  ){
			
				// no cache, use DHT (this will hang during initialisation, hence the use of cached
				// version above
			
			try{
				InetAddress latest_dht_address = dht.getLocalAddress().getAddress().getAddress();
				
					// ignore any v6 addresses from DHT
				
				if ( sameFamily( internal_address, latest_dht_address )){
					
					external_address = latest_dht_address;
				}
	        	
			}catch( Throwable e ){
			}
		}
		
		long	now = SystemTime.getCurrentTime();
		
		if ( last_force_read_ext > now ){
			
			last_force_read_ext	= now;
		}
		
		boolean	ok_to_try_ext = now - last_force_read_ext > FORCE_READ_EXT_MIN;
		
	    	// try upnp - limit frequency unless external read is possible in which
			// case we try upnp first
			// currently we only use UPnP to validate our current external address, not
			// to deduce new ones (as for example there may be multiple upnp devices and
			// we don't know which one to believe
	   
		if ( external_address == null && last_external_address != null ){
			
			if ( last_upnp_read > now ){
				
				last_upnp_read = now;
			}
			
			if ( now - last_upnp_read > UPNP_READ_MIN || ok_to_try_ext ){
				
				last_upnp_read	= now;
				
				try{
				   	UPnPPlugin upnp = adapter.getUPnPPlugin();
				 
				   	if ( upnp != null ){
				   		
				    	String[]	addresses = upnp.getExternalIPAddresses();
				    	
				    	for (int i=0;i<addresses.length;i++){
				    		
				    		if ( addresses[i].equals( last_external_address.getHostAddress())){
				    			
				    			external_address = last_external_address; 
				    			
				    			break;
				    		}
				    	}
				    }
				}catch( Throwable e ){
				}
			}
		}
		
		if ( external_address == null ){
			
				// force read it
			
			if ( ok_to_try_ext ){
				
				last_force_read_ext	= now;
				
				external_address = adapter.getPublicAddress();
			}
		}
		
			// no good address available		
		
		if ( external_address == null ){
				
			if ( last_external_address != null ){
				
				external_address = last_external_address;
				
			}else{
				try{
					external_address = InetAddress.getByName("127.0.0.1");
					
				}catch( Throwable e ){
					
					Debug.printStackTrace(e);
				}
			}
		}else{
			
			last_external_address	= external_address;
		}
		
		return( external_address );
	}
	
	protected boolean
	sameFamily(
		InetAddress	a1,
		InetAddress a2 )
	{		
		return( a1 instanceof Inet4Address == a2 instanceof Inet4Address );
	}
			
	public String
	getID()
	{
		return( id );
	}
	
	public String
	getApplicationID()
	{
		return( SystemProperties.getApplicationIdentifier() + "_" + SystemProperties.getApplicationVersion());
	}
	
	public InetAddress
	getInternalAddress()
	{
		return( internal_address );
	}
	
	public List 
	getInternalAddresses() 
	{
		List	l = new ArrayList();
		
		if ( internal_address != null ){
			
			l.add( internal_address );
		}
		
		return( l );
	}
	
	public InetAddress
	getExternalAddress()
	{
		return( readExternalAddress());
	}
	
	public int
	getTCPListenPort()
	{
		return( tcp_port );
	}
	
	public int
	getUDPListenPort()
	{
		return( udp_port );
	}
	
	public int 
	getUDPNonDataListenPort() 
	{
		return( udp_non_data_port );
	}
}
