/**
    *  BlueCove - Java library for Bluetooth
    *  Copyright (C) 2008 Michael Lifshits
    *  Copyright (C) 2008 Vlad Skarzhevskyy
    *
    *  Licensed to the Apache Software Foundation (ASF) under one
    *  or more contributor license agreements.  See the NOTICE file
    *  distributed with this work for additional information
    *  regarding copyright ownership.  The ASF licenses this file
   *  to you 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: EmulatorConfiguration.java 2642 2008-12-23 00:21:23Z skarzhevskyy $
   */
  package com.intel.bluetooth.emu;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.Serializable;
  import java.lang.reflect.Field;
  import java.lang.reflect.Modifier;
  import java.util.Hashtable;
  import java.util.Map;
  import java.util.Properties;
  
  import com.intel.bluetooth.BluetoothConsts;
  import com.intel.bluetooth.DebugLog;
  import com.intel.bluetooth.RemoteDeviceHelper;
  
  /**
   * Defines Emulator configuration properties.
   * 
   * See properties defined in javax.bluetooth.LocalDevice.getProperty();
   */
  public class EmulatorConfiguration implements Serializable {
  
  	private static final long serialVersionUID = 1L;
  
  	/**
  	 * Name of configuration file or resource.
  	 * 
  	 * Defaults to "bluecove.emulator.properties". Can be changed using system property "bluecove.emulator.properties"
  	 * 
  	 */
  	public static final String CONFIG_FILE_NAME = "bluecove.emulator.properties";
  
  	/**
  	 * Allow to define device name. <br/>
  	 * Example
  	 * 
  	 * <pre>
  	 * 0B1000000000.deviceName=My Device Server
  	 * # Device is Computer
  	 * 0B1000000000.deviceClass=0x0100
  	 * 
  	 * 0B1000000001.deviceName=My Device Client
  	 * # Device is Phone
  	 * 0B1000000001.deviceClass=0x0200
  	 * 
  	 * <pre>
  	 */
  	public static final String deviceName = "deviceName";
  
  	/**
  	 * Allow to define device class.
  	 * 
  	 * @see deviceName
  	 */
  	public static final String deviceClass = "deviceClass";
  
  	/**
  	 * Defaults to '0B1000000000'.
  	 */
  	protected long firstDeviceAddress = 0x0B1000000000L;
  
  	/**
  	 * Defaults to "EmuDevice".
  	 * 
  	 */
  	protected String deviceNamePrefix = "EmuDevice";
  
  	/**
  	 * Created Devices are initially discoverable.
  	 */
  	protected boolean deviceDiscoverable = true;
  
 	/**
 	 * Discoverable duration in seconds for LIAC. Defaults to <code>3</code>.
 	 */
 	protected int durationLIAC = 3;
 
 	/**
 	 * deviceInquiryDuration in seconds, Defaults to <code>11</code>.
 	 */
 	protected int deviceInquiryDuration = 11;
 
 	/**
 	 * Device Inquiry Duration is random. Defaults to <code>false</code>.
 	 */
 	protected boolean deviceInquiryRandomDelay = true;
 
 	/**
 	 * Defaults to 8K.
 	 */
 	protected int connectionBufferSize = 8 * 1024;
 
 	/**
 	 * Defaults to <code>true</code>.
 	 */
 	protected boolean linkEncryptionSupported = true;
 
 	/**
 	 * stream.flush() will Block sender till client reads all data.
 	 */
 	protected boolean senderFlushBlock = false;
 
 	/**
 	 * Monitor if client device is active.
 	 * 
 	 * RMI timeout is up to 10 minutes. This property enables killing application and recovery faster.
 	 */
 	protected int keepAliveSeconds = 5;
 
 	private Map<String, String> propertiesMap;
 
 	public EmulatorConfiguration() {
 		propertiesMap = new Hashtable<String, String>();
 		final String TRUE = "true";
 		final String FALSE = "false";
 		propertiesMap.put(BluetoothConsts.PROPERTY_BLUETOOTH_CONNECTED_DEVICES_MAX, "7");
 		propertiesMap.put(BluetoothConsts.PROPERTY_BLUETOOTH_SD_TRANS_MAX, "7");
 		propertiesMap.put(BluetoothConsts.PROPERTY_BLUETOOTH_CONNECTED_INQUIRY_SCAN, TRUE);
 		propertiesMap.put(BluetoothConsts.PROPERTY_BLUETOOTH_CONNECTED_PAGE_SCAN, TRUE);
 		propertiesMap.put(BluetoothConsts.PROPERTY_BLUETOOTH_CONNECTED_INQUIRY, TRUE);
 		propertiesMap.put(BluetoothConsts.PROPERTY_BLUETOOTH_CONNECTED_PAGE, TRUE);
 		propertiesMap.put(BluetoothConsts.PROPERTY_BLUETOOTH_SD_ATTR_RETRIEVABLE_MAX, "255");
 		propertiesMap.put(BluetoothConsts.PROPERTY_BLUETOOTH_MASTER_SWITCH, FALSE);
 		propertiesMap.put(BluetoothConsts.PROPERTY_BLUETOOTH_L2CAP_RECEIVEMTU_MAX, "2048");
 	}
 
 	public void loadConfigFile() {
 		String configName = System.getProperty(CONFIG_FILE_NAME, CONFIG_FILE_NAME);
 		// Try file to find the file first
 		File file = new File(configName);
 		if (file.exists()) {
 			try {
 				load(new FileInputStream(file));
 			} catch (IOException e) {
 				DebugLog.error("Error loading properties from file " + file.getAbsolutePath(), e);
 			}
 		} else {
 			// find the resource in the classPath
 			if (!configName.startsWith("/")) {
 				configName = "/" + configName;
 			}
 			InputStream input = this.getClass().getResourceAsStream(configName);
 			if (input != null) {
 				try {
 					load(input);
 				} catch (IOException e) {
 					DebugLog.error("Error loading properties from resource " + configName, e);
 				}
 			}
 		}
 	}
 
 	private void load(InputStream input) throws IOException {
 		Properties values = new Properties();
 		try {
 			values.load(input);
 		} finally {
 			input.close();
 		}
 		for (Map.Entry<Object, Object> me : values.entrySet()) {
 			Object value = me.getValue();
 			if (value == null) {
 				continue;
 			}
 			String txt = value.toString().trim();
 			if (txt.length() == 0) {
 				continue;
 			}
 			propertiesMap.put(me.getKey().toString(), txt);
 		}
 		copyPertiesToFields();
 	}
 
 	private void copyPertiesToFields() {
 		Field[] fields = this.getClass().getDeclaredFields();
 		for (Field field : fields) {
 			if (Modifier.isStatic(field.getModifiers())) {
 				continue;
 			}
 			String value = propertiesMap.get(field.getName());
 			if (value == null) {
 				continue;
 			}
 			Class<?> type = field.getType();
 			try {
 				if (String.class.isAssignableFrom(type)) {
 					field.set(this, value);
 				} else if (boolean.class.isAssignableFrom(type)) {
 					field.setBoolean(this, valueToBoolean(value));
 				} else if (int.class.isAssignableFrom(type)) {
 					field.setInt(this, valueToInt(value));
 				} else if (long.class.isAssignableFrom(type)) {
 					field.setLong(this, valueToLong(value));
 				}
 			} catch (Throwable e) {
 				DebugLog.error("Error setting property " + field.getName(), e);
 			}
 		}
 	}
 
 	private boolean valueToBoolean(String value) {
 		if (value.equalsIgnoreCase("true") || "1".equals(value)) {
 			return true;
 		} else {
 			return false;
 		}
 	}
 
 	public static int valueToInt(String value) {
 		if (value.startsWith("0x")) {
 			return Integer.parseInt(value.substring(2), 16);
 		} else {
 			return Integer.parseInt(value);
 		}
 	}
 
 	public static long valueToLong(String value) {
 		if (value.startsWith("0x")) {
 			return Long.parseLong(value.substring(2), 16);
 		} else {
 			return Long.parseLong(value);
 		}
 	}
 
 	public EmulatorConfiguration clone(long localAddress) {
 		String namePrefix = RemoteDeviceHelper.getBluetoothAddress(localAddress) + ".";
 		EmulatorConfiguration deviceConfig = new EmulatorConfiguration();
 		for (Map.Entry<String, String> me : this.propertiesMap.entrySet()) {
 			String key = me.getKey();
 			String value = me.getValue();
 			deviceConfig.propertiesMap.put(key, value);
 			if (key.startsWith(namePrefix)) {
 				deviceConfig.propertiesMap.put(key.substring(namePrefix.length()), value);
 			}
 		}
 		deviceConfig.copyPertiesToFields();
 		return deviceConfig;
 	}
 
 	public int getDurationLIAC() {
 		return durationLIAC;
 	}
 
 	public int getDeviceInquiryDuration() {
 		return deviceInquiryDuration;
 	}
 
 	public boolean isDeviceInquiryRandomDelay() {
 		return deviceInquiryRandomDelay;
 	}
 
 	public long getFirstDeviceAddress() {
 		return firstDeviceAddress;
 	}
 
 	/**
 	 * Get specific device property.
 	 * 
 	 * If specific not found, return global value.
 	 * 
 	 * @param address
 	 *            device address
 	 * @param property
 	 * @return value or null
 	 */
 	public String getProperty(long address, String property) {
 		String addressString = RemoteDeviceHelper.getBluetoothAddress(address);
 		String v = getProperty(addressString + "." + property);
 		if (v != null) {
 			return v;
 		} else {
 			return getProperty(property);
 		}
 	}
 
 	public String getProperty(String property) {
 		return (String) propertiesMap.get(property);
 	}
 
 	public int getIntProperty(String property) {
 		return Integer.valueOf(getProperty(property)).intValue();
 	}
 
 	public String getDeviceNamePrefix() {
 		return deviceNamePrefix;
 	}
 
 	public boolean isDeviceDiscoverable() {
 		return this.deviceDiscoverable;
 	}
 
 	public int getConnectionBufferSize() {
 		return connectionBufferSize;
 	}
 
 	public boolean isLinkEncryptionSupported() {
 		return this.linkEncryptionSupported;
 	}
 
 	public int getKeepAliveSeconds() {
 		return keepAliveSeconds;
 	}
 
 	public boolean isSenderFlushBlock() {
 		return this.senderFlushBlock;
 	}
 }