/**
    * Pyx4me framework
    * Copyright (C) 2006-2008 pyx4j.com.
    * 
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   * 
   * @author vlads
   * @version $Id: ServiceSearchMojo.java 2066 2008-06-21 23:16:18Z vlads $
   */
  package com.pyx4me.maven.obex;
  
  import java.io.IOException;
  import java.util.StringTokenizer;
  
  import javax.bluetooth.BluetoothStateException;
  import javax.bluetooth.DeviceClass;
  import javax.bluetooth.DiscoveryListener;
  import javax.bluetooth.LocalDevice;
  import javax.bluetooth.RemoteDevice;
  import javax.bluetooth.ServiceRecord;
  import javax.bluetooth.UUID;
  
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.plugin.logging.Log;
  import org.apache.maven.project.MavenProject;
  
  /**
   * The obex:search task finds OBEX Object Push Service on device.
   * 
   * @author vlads
   * 
   * @goal search
   * @description Finds OBEX Object Push Service on device.
   */
  public class ServiceSearchMojo extends AbstractDeviceMojo {
  
  	/**
  	 * The Maven project reference where the plugin is currently being executed.
  	 * The default value is populated from maven.
  	 * 
  	 * @parameter expression="${project}"
  	 * @readonly
  	 * @required
  	 */
  	protected MavenProject mavenProject;
  
  	public void execute() throws MojoExecutionException, MojoFailureException {
  		if (serverSufix == null) {
  			findOBEX(getServerConfig(null), getLog());
  		} else {
  			if (serverSufix.startsWith(",")) {
  				findOBEX(getServerConfig(null), getLog());
  			}
  			StringTokenizer tok = new StringTokenizer(serverSufix, ",");
  			while (tok.hasMoreTokens()) {
  				findOBEX(getServerConfig(tok.nextToken()), getLog());
  			}
  		}
  	}
  
  	private static class RemoteDeviceExt extends RemoteDevice {
  		public RemoteDeviceExt(String address) {
  			super(address);
  		}
  	}
  
  	private static class BluetoothServiceSearch implements DiscoveryListener {
  
  		public final UUID L2CAP = new UUID(0x0100);
  
  		public final UUID RFCOMM = new UUID(0x0003);
  
  		public final UUID OBEX = new UUID(0x0008);
  
  		public final UUID OBEX_OBJECT_PUSH = new UUID(0x1105);
  
  		public final UUID OBEX_FILE_TRANSFER = new UUID(0x1106);
  
  		Log log;
  
  		boolean inquiring;
  
  		int servicesSearchTransID;
  
  		String serviceURL;
  
  		BluetoothServiceSearch(Log log) {
 			this.log = log;
 		}
 
 		public boolean startServiceSearch(RemoteDevice device) {
 			inquiring = false;
 			serviceURL = null;
 			try {
 				UUID[] searchUuidSet = new UUID[] { L2CAP, RFCOMM, OBEX_OBJECT_PUSH };
 				int[] attrIDs = new int[] { 0x0100 // Service name
 				};
 
 				servicesSearchTransID = LocalDevice.getLocalDevice().getDiscoveryAgent().searchServices(attrIDs,
 						searchUuidSet, device, this);
 			} catch (BluetoothStateException e) {
 				log.error("Cannot start inquiry", e);
 				return false;
 			}
 			inquiring = true;
 			return inquiring;
 		}
 
 		public void deviceDiscovered(RemoteDevice btDevice, DeviceClass cod) {
 		}
 
 		public void inquiryCompleted(int discType) {
 		}
 
 		public void servicesDiscovered(int transID, ServiceRecord[] servRecord) {
 			for (int i = 0; i < servRecord.length; i++) {
 				String url = servRecord[i].getConnectionURL(ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false);
 				if (url == null) {
 					continue;
 				}
 				int schemeEnd = url.indexOf("://");
 				if (schemeEnd == -1) {
 					continue;
 				}
 				String scheme = url.substring(0, schemeEnd);
 				if (!scheme.equals("btgoep")) {
 					continue;
 				}
 				int hostEnd = url.indexOf(':', scheme.length() + 3);
 				if (hostEnd == -1) {
 					continue;
 				}
 				String host = url.substring(scheme.length() + 3, hostEnd);
 				String paramsStr = url.substring(hostEnd + 1);
 				StringTokenizer tok = new StringTokenizer(paramsStr, ";");
 				String port;
 				if (tok.hasMoreTokens()) {
 					port = tok.nextToken();
 				} else {
 					port = paramsStr;
 				}
 
 				serviceURL = host + ":" + port;
 
 				log.info("  -> found service: " + serviceURL);
 			}
 		}
 
 		public void serviceSearchCompleted(int transID, int respCode) {
 			switch (respCode) {
 			case SERVICE_SEARCH_ERROR:
 				log.info("  -> Error occurred while processing the service search");
 				break;
 			case SERVICE_SEARCH_TERMINATED:
 				break;
 			case SERVICE_SEARCH_DEVICE_NOT_REACHABLE:
 				log.info("  -> Device not reachable");
 				break;
 			default:
 				if (serviceURL == null) {
 					log.info("  -> OBEX Object Push service not found");
 				}
 			}
 			inquiring = false;
 		}
 
 	}
 
 	private static String getFriendlyName(RemoteDevice device) {
 		try {
 			String name = device.getFriendlyName(false);
 			if ((name == null) || (name.length() == 0)) {
 				return device.getBluetoothAddress();
 			} else {
 				return name;
 			}
 		} catch (IOException e) {
 			return device.getBluetoothAddress();
 		}
 	}
 
 	private String findOBEX(ServerConfig cfg, Log log) {
 		configureBlueCove(cfg, log);
 		String addr = cfg.url;
 		int hostEnd = addr.indexOf(':');
 		if (hostEnd != -1) {
 			addr = addr.substring(0, hostEnd);
 		}
 		return findOBEX(addr, cfg.alias, log);
 	}
 
 	public static String findOBEX(String btAddress, String alias, Log log) {
 		RemoteDevice device = new RemoteDeviceExt(btAddress);
 		if (alias == null) {
 			alias = getFriendlyName(device);
 		}
 		log.info("OBEX Service Search on " + alias);
 
 		BluetoothServiceSearch bss = new BluetoothServiceSearch(log);
 		if (!bss.startServiceSearch(device)) {
 			log.error("Cannot start inquiry");
 		} else {
 			while (bss.inquiring) {
 				try {
 					Thread.sleep(1000);
 				} catch (Exception e) {
 				}
 			}
 		}
 		return bss.serviceURL;
 	}
 
 }