/*******************************************************************************
 * Copyright (c) 2010 Markus Alexander Kuppe.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Markus Alexander Kuppe (ecf-dev_eclipse.org <at> lemmster <dot> de) - initial API and implementation
 ******************************************************************************/
package org.eclipse.ecf.provider.dnssd;

import java.io.EOFException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.SortedSet;

import org.eclipse.core.runtime.Assert;
import org.eclipse.ecf.core.ContainerConnectException;
import org.eclipse.ecf.core.events.ContainerConnectedEvent;
import org.eclipse.ecf.core.events.ContainerConnectingEvent;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.identity.IDCreateException;
import org.eclipse.ecf.core.identity.IDFactory;
import org.eclipse.ecf.core.identity.Namespace;
import org.eclipse.ecf.core.security.IConnectContext;
import org.eclipse.ecf.core.util.Trace;
import org.eclipse.ecf.discovery.DiscoveryContainerConfig;
import org.eclipse.ecf.discovery.IServiceInfo;
import org.eclipse.ecf.discovery.identity.IServiceTypeID;
import org.xbill.DNS.DClass;
import org.xbill.DNS.Lookup;
import org.xbill.DNS.Message;
import org.xbill.DNS.NSRecord;
import org.xbill.DNS.Name;
import org.xbill.DNS.Rcode;
import org.xbill.DNS.Record;
import org.xbill.DNS.SOARecord;
import org.xbill.DNS.SRVRecord;
import org.xbill.DNS.SimpleResolver;
import org.xbill.DNS.TextParseException;
import org.xbill.DNS.Type;
import org.xbill.DNS.Update;

public class DnsSdDiscoveryAdvertiser extends DnsSdDiscoveryContainerAdapter {
	
	private static final String _DNS_UPDATE = "_dns-update._udp."; //$NON-NLS-1$
	private static final boolean ADD = true;
	private static final boolean REMOVE = false;

	public DnsSdDiscoveryAdvertiser() {
		super(DnsSdNamespace.NAME, new DiscoveryContainerConfig(IDFactory
				.getDefault().createStringID(
						DnsSdDiscoveryAdvertiser.class.getName())));
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ecf.provider.dnssd.DnsSdDiscoveryLocator#registerService(org.eclipse.ecf.discovery.IServiceInfo)
	 */
	public void registerService(final IServiceInfo serviceInfo) {
		Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "registerService(IServiceInfo serviceInfo)", "Registering service"); //$NON-NLS-1$ //$NON-NLS-2$
		sendToServer(serviceInfo, ADD); 
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ecf.provider.dnssd.DnsSdDiscoveryLocator#unregisterService(org.eclipse.ecf.discovery.IServiceInfo)
	 */
	public void unregisterService(final IServiceInfo serviceInfo) {
		Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "unregisterService(IServiceInfo serviceInfo)", "Unregistering service"); //$NON-NLS-1$ //$NON-NLS-2$
		sendToServer(serviceInfo, REMOVE);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ecf.discovery.AbstractDiscoveryContainerAdapter#unregisterAllServices()
	 */
	public void unregisterAllServices() {
		Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "unregisterAllServices()", "Unregistering all services"); //$NON-NLS-1$ //$NON-NLS-2$
		throw new UnsupportedOperationException("Not yet implemented, see http://bugs.eclipse.org/321959"); //$NON-NLS-1$
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ecf.discovery.AbstractDiscoveryContainerAdapter#purgeCache()
	 */
	public IServiceInfo[] purgeCache() {
		// purge cache means renew resolver?
		throw new UnsupportedOperationException("Not yet implemented, see http://bugs.eclipse.org/"); //$NON-NLS-1$
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ecf.provider.dnssd.DnsSdDiscoveryLocator#connect(org.eclipse.ecf.core.identity.ID, org.eclipse.ecf.core.security.IConnectContext)
	 */
	public void connect(final ID aTargetID, final IConnectContext connectContext)
			throws ContainerConnectException {

		Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "connect(ID aTargetID, IConnectContext connectContext)", "connecting container"); //$NON-NLS-1$ //$NON-NLS-2$

		// connect can only be called once
		if (targetID != null || getConfig() == null) {
			throw new ContainerConnectException(Messages.DnsSdDiscoveryAdvertiser_Container_Already_Connected);
		}

		//TODO convert non DnsSdServiceTypeIDs into DSTIDs
		if(aTargetID == null) {
			targetID = new DnsSdServiceTypeID();
		} else {
			final Namespace ns = getConnectNamespace();
			try {
				targetID = (DnsSdServiceTypeID) ns.createInstance(new Object[]{aTargetID});
			} catch(IDCreateException e) {
				throw new ContainerConnectException(e);
			}
		}
		
		// instantiate a default resolver
		if(resolver == null) {
			try {
				resolver = new SimpleResolver();
				resolver.setTCP(true);
			} catch (UnknownHostException e) {
				throw new ContainerConnectException(e);
			}
		}

		// done setting up this provider, send event
		fireContainerEvent(new ContainerConnectingEvent(this.getID(), targetID,
				connectContext));
		fireContainerEvent(new ContainerConnectedEvent(this.getID(), targetID));
	}

	protected void sendToServer(final IServiceInfo serviceInfo, final boolean mode) {
		Assert.isNotNull(serviceInfo);
		Assert.isLegal(serviceInfo.getServiceID() instanceof DnsSdServiceID);
		final DnsSdServiceID serviceID = (DnsSdServiceID) serviceInfo.getServiceID();
		try {
			final Record srvRecord = serviceID.toSRVRecord(); // TYPE.SRV
			final Record[] txtRecords = serviceID.toTXTRecords(srvRecord); // TYPE.TXT
			final Name name = serviceID.getDnsName();
		
			final String[] registrationDomains = getRegistrationDomains(serviceID.getServiceTypeID());
		
			for (int i = 0; i < registrationDomains.length; i++) {
				final Name zone = new Name(registrationDomains[i]);
				final Name fqdn = new Name(name.toString() + "." + zone.toString()); //$NON-NLS-1$
				final Update update = new Update(zone);

				//TYPE.SRV
				if(mode == ADD) {
					//TODO add absent/present condition checks
					update.replace(srvRecord.withName(fqdn));
				} else {
					update.delete(srvRecord.withName(fqdn));
				}
				
				//TYPE.TXT
				for (int j = 0; j < txtRecords.length; j++) {
					if(mode == ADD) {
						update.add(txtRecords[j].withName(fqdn));
					} else {
						update.delete(txtRecords[j].withName(fqdn));
					}
				}
				
				// set up a the resolver for the given domain (a scope might use different domains)
				final Collection dnsServers = getUpdateDomain(zone);
				if(dnsServers.size() == 0) {
					throw new DnsSdDiscoveryException(Messages.DnsSdDiscoveryAdvertiser_No_DynDns_Servers_Found);
				}
				for (final Iterator iterator = dnsServers.iterator(); iterator.hasNext();) {
					final SRVRecord dnsServer = (SRVRecord) iterator.next();
					
					// try to send msg and fail gracefully if more dns servers are available
					final Name target = dnsServer.getTarget();
					final Message response;
					final InetAddress byName;
					try {
						byName = InetAddress.getByName(target.toString());

						((SimpleResolver) resolver).setAddress(byName);
						((SimpleResolver) resolver).setPort(dnsServer.getPort());
						
						response = resolver.send(update);
					} catch (UnknownHostException uhe) {
						if(iterator.hasNext()) {
							continue;
						} else {
							throw new DnsSdDiscoveryException(uhe);
						}
					} catch (EOFException eof) {
						if(iterator.hasNext()) {
							continue;
						} else {
							throw new DnsSdDiscoveryException(eof);
						}
					}
					
					// catch some errors and fall back to the next dnsServer
					if (response.getRcode() != Rcode.NOERROR) {
						if(iterator.hasNext()) {
							continue;
						} else {
							throw DnsSdDiscoveryException.getException(response.getRcode());
						}
					}
				}
			}
		} catch (Exception e) {
			throw new DnsSdDiscoveryException(e);
		}
	}

	protected Collection getUpdateDomain(final Name zone) throws TextParseException {
		Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "getUpdateDomain(Name zone)", "Getting update domain"); //$NON-NLS-1$ //$NON-NLS-2$
		// query for special "_dns-update" SRV records which mark the server to use for dyndns
		final Lookup query = new Lookup(_DNS_UPDATE + zone, Type.SRV);
		// use the SRV record with the lowest priority/weight first
		final SortedSet srvRecords = getSRVRecord(query, new SRVRecordComparator());

		// if no dedicated "_dns-update" server is configured, fall back to regular authoritative server
		if(srvRecords.size() == 0) {
			Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "getUpdateDomain(Name zone)", "Found no _dns-update SRV records in zone"); //$NON-NLS-1$ //$NON-NLS-2$
			return getAuthoritativeNameServer(zone);
		}
		return srvRecords; 
	}
	
	protected Collection getAuthoritativeNameServer(final Name zone) throws TextParseException {
		Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "getAuthoritativeNameServer(Name zone)", "Trying to find authoritative name server"); //$NON-NLS-1$ //$NON-NLS-2$
		final Set result = new HashSet();
		final Name name = new Name(_DNS_UPDATE + zone);
		
		//query for NS records
		Lookup query = new Lookup(zone, Type.NS);
		query.setResolver(resolver);
		Record[] queryResult = query.run();
		//TODO file bug upstream that queryResult may never be null
		int length = queryResult == null ? 0 : queryResult.length;
		for (int j = 0; j < length; j++) {
			final Record record = queryResult[j];
			if(record instanceof NSRecord) {
				final NSRecord nsRecord = (NSRecord) record;
				final Name target = nsRecord.getTarget();
				result.add(new SRVRecord(name, DClass.IN, nsRecord.getTTL(), 0, 0, SimpleResolver.DEFAULT_PORT, target));
			}
		}
		
		//query for primary ns in SOA record (may overwrite/be equal to one of the ns records)
		query = new Lookup(zone, Type.SOA);
		query.setResolver(resolver);
		queryResult = query.run();
		//TODO file bug upstream that queryResult may never be null
		length = queryResult == null ? 0 : queryResult.length;
		for (int j = 0; j < length; j++) {
			final Record record = queryResult[j];
			if(record instanceof SOARecord) {
				final SOARecord soaRecord = (SOARecord) record;
				result.add(new SRVRecord(name, DClass.IN, soaRecord.getTTL(), 0, 0, SimpleResolver.DEFAULT_PORT, soaRecord.getHost()));
			}
		}
		return result; 
	}

	protected String[] getRegistrationDomains(final IServiceTypeID aServiceTypeId) {
		Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "getRegistrationDomains(IServiceTypeID aServiceTypeId)", "Getting registration domains"); //$NON-NLS-1$ //$NON-NLS-2$
		final String[] rrs = new String[] {BnRDnsSdServiceTypeID.REG_DOMAINS, BnRDnsSdServiceTypeID.DEFAULT_REG_DOMAIN};
		final Collection registrationDomains = getBrowsingOrRegistrationDomains(aServiceTypeId, rrs);
		final String[] scopes = aServiceTypeId.getScopes();
		for (int i = 0; i < scopes.length; i++) {
			scopes[i] = scopes[i].concat("."); //$NON-NLS-1$
		}
		return registrationDomains.size() == 0 ? scopes : (String[]) registrationDomains.toArray(new String[registrationDomains.size()]); 
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ecf.discovery.AbstractDiscoveryContainerAdapter#getContainerName()
	 */
	public String getContainerName() {
		return Activator.DISCOVERY_CONTAINER_NAME_VALUE + Activator.ADVERTISER;
	}
}