/*
 * Created on Feb 1, 2007
 * Created by Paul Gardner
 * Copyright (C) 2007 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 63.529,40 euros
 * 8 Allee Lenotre, La Grille Royale, 78600 Le Mesnil le Roi, France.
 *
 */


package com.aelitis.azureus.core.peer.cache;

import java.net.InetAddress;
import java.util.*;

import org.gudy.azureus2.core3.ipfilter.BannedIp;
import org.gudy.azureus2.core3.ipfilter.IPFilterListener;
import org.gudy.azureus2.core3.ipfilter.IpFilter;
import org.gudy.azureus2.core3.ipfilter.IpFilterManagerFactory;
import org.gudy.azureus2.core3.torrent.TOTorrent;
import org.gudy.azureus2.core3.util.AEThread;
import org.gudy.azureus2.core3.util.Constants;
import org.gudy.azureus2.core3.util.Debug;
import org.gudy.azureus2.core3.util.HostNameToIPResolver;
import org.gudy.azureus2.core3.util.IPToHostNameResolver;
import org.gudy.azureus2.core3.util.IPToHostNameResolverListener;
import org.gudy.azureus2.core3.util.SystemTime;

import com.aelitis.azureus.core.download.DownloadManagerEnhancer;
import com.aelitis.azureus.core.download.EnhancedDownloadManager;
import com.aelitis.azureus.core.peer.cache.cachelogic.CLCacheDiscovery;

public class 
CacheDiscovery 
{
	private static final IpFilter ip_filter = IpFilterManagerFactory.getSingleton().getIPFilter();

	private static final CacheDiscoverer[] discoverers = {
		
		new CLCacheDiscovery(),
	};
	
	private static Set	cache_ips = Collections.synchronizedSet(new HashSet());
	
	public static void
	initialise(
		final DownloadManagerEnhancer		dme )
	{
		
		ip_filter.addListener(
			new IPFilterListener()
			{
				public boolean
				canIPBeBanned(
					String			ip )
				{
					return( canBan( ip ));
				}
				
				public void
				IPBanned(
					BannedIp		ip )
				{
				}

				public void 
				IPBlockedListChanged(
					IpFilter	filter)
				{
				}
				
				public boolean 
				canIPBeBlocked(
					String 	ip, 
					byte[] 	torrent_hash) 
				{
					EnhancedDownloadManager dm = dme.getEnhancedDownload( torrent_hash );
					
					if ( dm == null ){
						
						return( true );
					}
					
					if ( dm.isPlatform()){
						
						return( canBan( ip ));
					}
					
					return( true );
				}
			});
		
		new AEThread( "CacheDiscovery:ban checker", true )
			{
				public void
				runSupport()
				{
					BannedIp[] bans = ip_filter.getBannedIps();
				
					for (int i=0;i<bans.length;i++){
						
						String	ip = bans[i].getIp();
						
						if ( !canBan( ip )){
							
							ip_filter.unban( ip );
						}
					}
				}
			}.start();
	}
	
	private static boolean
	canBan(
		final String	ip )
	{
		if ( cache_ips.contains( ip )){
			
			return( false );
		}
		
		try{
			InetAddress address = HostNameToIPResolver.syncResolve( ip );
			
			final String host_address = address.getHostAddress();
			
			if ( cache_ips.contains( host_address )){
	
				return( false );
			}
			
				// reverse lookups can be very slow
			
			IPToHostNameResolver.addResolverRequest(
				ip,
				new IPToHostNameResolverListener()
				{
					public void 
					IPResolutionComplete(
						String 		result, 
						boolean 	succeeded )
					{
						String[]	ok_domains = Constants.AZUREUS_DOMAINS;
						
						for (int i=0;i<ok_domains.length;i++){
							
							if ( result.endsWith( "." + ok_domains[i] )){
								
								cache_ips.add( host_address );
								
								ip_filter.unban( host_address, true );
							}
						}
					}
				});
		
			return( true );
			
		}catch( Throwable e ){
			
			Debug.printStackTrace( e );
			
			return( true );
		}
	}
	
	public static CachePeer[]
	lookup(
		TOTorrent	torrent )
	{
		CachePeer[]	res;
		
		if ( discoverers.length == 1 ){
			
			res = discoverers[0].lookup( torrent );
			
		}else{
		
			List	result = new ArrayList();
			
			for (int i=0;i<discoverers.length;i++){
				
				CachePeer[] peers = discoverers[i].lookup( torrent );
				
				for (int j=0;j<peers.length;j++){
					
					result.add( peers[i] );
				}
			}
			
			res = (CachePeer[])result.toArray( new CachePeer[result.size()]);
		}
		
		for (int i=0;i<res.length;i++){
			
			String	ip = res[i].getAddress().getHostAddress();
				
			cache_ips.add( ip );
			
			ip_filter.unban( ip );
		}
		
		return( res );
	}
	
	public static CachePeer
	categorisePeer(
		byte[]					peer_id,
		final InetAddress		ip,
		final int				port )
	{
		for (int i=0;i<discoverers.length;i++){
			
			CachePeer	cp = discoverers[i].lookup( peer_id, ip, port );
			
			if ( cp != null ){
				
				return( cp );
			}
		}
		
		return( new CachePeerImpl( CachePeer.PT_NONE, ip, port ));
	}
	
	public static class
	CachePeerImpl
		implements CachePeer
	{
		private int				type;
		private InetAddress		address;
		private int				port;
		private long			create_time;
		private long			inject_time;
		private long			speed_change_time;
		private boolean			auto_reconnect	= true;
		
		public
		CachePeerImpl(
			int			_type,
			InetAddress	_address,
			int			_port )
		{
			type	= _type;
			address	= _address;
			port	= _port;
			
			create_time	= SystemTime.getCurrentTime();
		}
		
		public int
		getType()
		{
			return( type );
		}
		
		public InetAddress
		getAddress()
		{
			return( address );
		}
		
		public int
		getPort()
		{
			return( port );
		}
		
		public long
		getCreateTime(
			long	now )
		{
			if ( create_time > now ){
				
				create_time	= now;
			}
			
			return( create_time );
		}
		
		public long
		getInjectTime(
			long	now )
		{
			if ( inject_time > now ){
				
				inject_time	= now;
			}
			
			return( inject_time );
		}
		
		public void
		setInjectTime(
			long	time )
		{
			inject_time	= time;
		}
		
		public long
		getSpeedChangeTime(
			long	now )
		{
			if ( speed_change_time > now ){
				
				speed_change_time	= now;
			}
			
			return( speed_change_time );
		}
		
		public void
		setSpeedChangeTime(
			long	time )
		{
			speed_change_time	= time;
		}
		
		public boolean
		getAutoReconnect()
		{
			return( auto_reconnect );
		}
		
		public void
		setAutoReconnect(
			boolean		auto )
		{
			auto_reconnect	= auto;
		}
		
		public boolean
		sameAs(
			CachePeer	other )
		{
			return( 
					getType() == other.getType() &&
					getAddress().getHostAddress().equals( other.getAddress().getHostAddress()) &&
					getPort() == other.getPort());
		}
		
		public String
		getString()
		{
			return( "type=" + getType() + ",address=" + getAddress() + ",port=" + getPort());
		}
	}
}
