/*******************************************************************************
 * Copyright (c) 2004, 2006 IBM Corporation and others.
 * 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:
 *    IBM Corporation - Initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.internet.monitor.core.internal.provisional;

import java.util.Date;
import java.util.Properties;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.Platform;
import org.eclipse.wst.internet.monitor.core.internal.Monitor;
import org.eclipse.wst.internet.monitor.core.internal.Trace;
/**
 * Represents a TCP/IP request made between the client and the server.
 * Each request represents a request-response pair, where the request
 * is from client -> server, and the response is from server -> client.
 * <p>
 * Requests are created by a running monitor. They do not have a reference
 * back to the monitor because the monitor may have been deleted or modified
 * since the request was created.
 * </p>
 * <p>
 * This interface is intended to be extended only by clients
 * to extend the <code>protocolAdapters</code> extension point. 
 * </p>
 */
public class Request implements IAdaptable {
	protected Monitor monitor;
	protected Date date;
	protected long responseTime = -1;
	protected int localPort;
	protected String remoteHost;
	protected int remotePort;
	protected byte[] request;
	protected byte[] response;
	
	protected String name;
	protected String protocolId;

	protected Properties properties;
	
	/**
	 * Request2 content type (value 1) for the transport (header) of a request
	 * or response.
	 * 
	 * @see #getRequest(int)
	 * @see #getResponse(int)
	 */
	public static final int TRANSPORT = 1;

	/**
	 * Request2 content type (value 2) for the content (body) of a request
	 * or response.
	 * 
	 * @see #getRequest(int)
	 * @see #getResponse(int)
	 */
	public static final int CONTENT = 2;

	/**
	 * Request2 content type (value 3) for the entire content of a request
	 * or response.
	 * 
	 * @see #getRequest(int)
	 * @see #getResponse(int)
	 */
	public static final int ALL = 3;

	/**
	 * Create a new Request.
	 * 
	 * @param monitor a monitor
	 * @param protocolId the protocol id
	 * @param localPort a local port number
	 * @param remoteHost a remote hostname
	 * @param remotePort a remote port number
	 */
	public Request(Monitor monitor, String protocolId, int localPort, String remoteHost, int remotePort) {
		super();
		this.monitor = monitor;
		this.protocolId = protocolId;
		this.localPort = localPort;
		this.remoteHost = remoteHost;
		this.remotePort = remotePort;
		date = new Date();
		properties = new Properties();
		if (monitor != null)
			monitor.addRequest(this);
	}

	/**
	 * Returns the protocol responsible for creating this request.
	 * 
	 * @return the protocol id
	 */
	public String getProtocol() {
		return protocolId;
	}

	/**
	 * Returns the time this request was made.
	 *
	 * @return the timestamp
	 */
	public Date getDate() {
		return date;
	}

	/**
	 * Returns the local (client) port.
	 *
	 * @return the local port number
	 */
	public int getLocalPort() {
		return localPort;
	}

	/**
	 * Returns the remote (server) host.
	 *
	 * @return the remote host
	 */
	public String getRemoteHost() {
		return remoteHost;
	}

	/**
	 * Returns the remote (server) port.
	 *
	 * @return the remote port number
	 */
	public int getRemotePort() {
		return remotePort;
	}

	/**
	 * Returns the selected content of the request portion of this request.
	 * <p>
	 * [issue: I don't know how to explain this. For basic TCP/IP requests,
	 * distinction between transport and content is ignored.
	 * For HTTP requests, this TRANSPORT returns just the HTTP header and 
	 * CONTENT returns just the HTTP body without the headers. What would
	 * it mean for other protocols?
	 * </p>
	 *
	 * @param type the content type: one of {@link #TRANSPORT},
	 *    {@link #CONTENT}, or {@link #ALL}
	 * @return the content bytes
	 */
	public byte[] getRequest(int type) {
		return request;
	}

	/**
	 * Returns the selected content of the response portion of this request.
	 * <p>
	 * [issue: I don't know how to explain this. For basic TCP/IP requests,
	 * distinction between transport and content is ignored.
	 * For HTTP requests, this TRANSPORT returns just the HTTP header and 
	 * CONTENT returns just the HTTP body without the headers. What would
	 * it mean for other protocols?]
	 * </p>
	 *
	 * @param type the content type: one of {@link #TRANSPORT},
	 *    {@link #CONTENT}, or {@link #ALL}
	 * @return the content bytes
	 */
	public byte[] getResponse(int type) {
		return response;
	}

	/**
	 * Returns the server's response time in milliseconds. If the request
	 * has not been completed yet, -1 is returned.
	 *
	 * @return the server's response time, or -1 if there has been no
	 *    response yet
	 */
	public long getResponseTime() {
		return responseTime;
	}

	/**
	 * Returns a name for this request.
	 *
	 * @return the name
	 */
	public String getName() {
		if (name == null)
			return getRemoteHost() + ":" + getRemotePort();
		
		return name;
	}
	
	/**
	 * Sets the name of this request.
	 *
	 * @param n the name
	 */
	protected void setName(String n) {
		name = n;
	}

	/**
	 * Sets the given key-value property on this request. To remove a property,
	 * set the value to null.
	 * <p>
	 * This method is typically called by protocol adapters to attach protocol-
	 * specific fields to the request, but it may be called by any client.
	 * </p>
	 * 
	 * @param key the key
	 * @param value the value
	 */
	public void setProperty(String key, Object value) {
		try {
			if (properties.containsKey(key))
				properties.remove(key);
			if (value != null)
				properties.put(key, value);
		} catch (Exception e) {
			Trace.trace(Trace.SEVERE, "Could not add property", e);
		}
		monitor.requestChanged(this);
	}

	/**
	 * Returns the value of the property with the given key from this request.
	 * If the key does not exist, <code>null</code> is returned.
	 * 
	 * @param key the property key 
	 * @return the property value
	 */
	public Object getProperty(String key) {
		try {
			return properties.get(key);
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * Add to the request.
	 *
	 * @param addRequest byte[]
	 */
	public void addToRequest(byte[] addRequest) {
		if (addRequest == null || addRequest.length == 0)
			return;
	
		if (request == null || request.length == 0) {
			setRequest(addRequest);
			return;
		}
	
		int size = request.length + addRequest.length;
		byte[] b = new byte[size];
		System.arraycopy(request, 0, b, 0, request.length);
		System.arraycopy(addRequest, 0, b, request.length, addRequest.length);
		request = b;
		fireChangedEvent();
	}

	/**
	 * Add to the response.
	 *
	 * @param addResponse byte[]
	 */
	public void addToResponse(byte[] addResponse) {
		if (addResponse == null || addResponse.length == 0)
			return;
		
		if (response == null || response.length == 0) {
			setResponse(addResponse);
			return;
		}
		
		int size = response.length + addResponse.length;
		byte[] b = new byte[size];
		System.arraycopy(response, 0, b, 0, response.length);
		System.arraycopy(addResponse, 0, b, response.length, addResponse.length);
		response = b;
		fireChangedEvent();
	}

	/**
	 * Set the request.
	 *
	 * @param request byte[]
	 */
	protected void setRequest(byte[] request) {
		if (request == null || request.length == 0)
			return;
		
		this.request = request;
		monitor.requestChanged(this);
	}

	/**
	 * Set the response.
	 *
	 * @param response byte[]
	 */
	protected void setResponse(byte[] response) {
		if (response == null || response.length == 0)
			return;
	
		this.response = response;
		responseTime = System.currentTimeMillis() - date.getTime();
		monitor.requestChanged(this);
	}

	/**
	 * Returns the monitor that created this request.
	 * Change events will be fired from this monitor.
	 * <p>
	 * Note that the monitor may have been editted since this
	 * request was created, so you cannot rely on the monitor's
	 * hostname or port values.
	 * </p>
	 * 
	 * @return the monitor that created this request
	 */
	public IMonitor getMonitor() {
		return monitor;
	}

	/**
	 * Fire a change event to notify monitor listeners that the request has changed.
	 */
	protected void fireChangedEvent() {
		if (monitor != null)
			monitor.requestChanged(this);
	}

	/** (non-Javadoc)
	 * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
	 */
	public Object getAdapter(Class adapter) {
		return Platform.getAdapterManager().getAdapter(this, adapter);
	}
}