package com.huawei.insa2.util;

import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.Vector;

public class Debug {

	private Debug() {
	}

	public static final void myAssert(boolean condition) {
		if (!condition)
			throw new AssertFailed();
		else
			return;
	}

	public static void setDumpStream(OutputStream os) {
		out = new PrintWriter(os);
	}

	public static void setDumpStream(Writer w) {
		out = new PrintWriter(w);
	}

	public static void setDumpIndent(String indent) {
		indentString = indent;
	}

	public static String getDumpIndent() {
		return indentString;
	}

	public static final void dump() {
		out.println(dumpHead());
		out.flush();
	}

	public static final void dump(int i) {
		out.println(String.valueOf(dumpHead()) + String.valueOf(i));
		out.flush();
	}

	public static final void dump(long l) {
		out.println(String.valueOf(dumpHead()) + String.valueOf(l));
		out.flush();
	}

	public static final void dump(float f) {
		out.println(String.valueOf(dumpHead()) + String.valueOf(f));
		out.flush();
	}

	public static final void dump(double d) {
		out.println(String.valueOf(dumpHead()) + String.valueOf(d));
		out.flush();
	}

	public static final void dump(boolean b) {
		out.println(String.valueOf(dumpHead()) + String.valueOf(b));
		out.flush();
	}

	public static final void dump(char ch) {
		out.println(String.valueOf(dumpHead()) + String.valueOf(ch));
		out.flush();
	}

	public static final void dump(byte data[], int offset, int length) {
		dump(dumpHead(), data, offset, length);
	}

	public static final void dump(byte data[]) {
		dump(dumpHead(), data);
	}

	public static final void dump(Object obj) {
		dump(dumpHead(), 3, new Vector(), obj);
	}

	public static final void dump(Object obj, String prefix) {
		dump(String.valueOf(prefix) + String.valueOf(dumpHead()), 3,
				new Vector(), obj);
	}

	public static final void dump(Object obj, int depth) {
		dump(dumpHead(), depth, new Vector(), obj);
	}

	private static final void dump(String prefix, int depth,
			Vector checkCircuit, Vector v) {
		if (v == null) {
			dump(prefix, "null");
			return;
		}
		dumpBegin(prefix, checkCircuit, v);
		for (int i = 0; i < v.size(); i++) {
			Object item = v.elementAt(i);
			StringBuffer itemPrefix = new StringBuffer();
			itemPrefix.append(indent(prefix));
			itemPrefix.append('[');
			itemPrefix.append(i);
			itemPrefix.append("] ");
			itemPrefix.append(formatClassName(item.getClass(), item));
			itemPrefix.append(" @");
			itemPrefix.append(System.identityHashCode(item));
			dump(itemPrefix.toString(), depth, checkCircuit, item);
		}

		dumpEnd(prefix, checkCircuit, v);
	}

	private static final void dumpServletRequest(String prefix, Object request) {
		try {
			if (request == null) {
				dump(prefix, "null");
				return;
			}
			dumpBegin(prefix, new Vector(), request);
			Class c = request.getClass();
			Method m1 = null;
			m1 = c.getMethod("getParameterNames", new Class[0]);
			String name;
			StringBuffer sb;
			for (Enumeration e = (Enumeration) m1
					.invoke(request, new Object[0]); e.hasMoreElements(); dump(
					indent(prefix), String
							.valueOf(String.valueOf((new StringBuffer(String
									.valueOf(String.valueOf(name)))).append(
									" = ").append(sb))))) {
				name = e.nextElement().toString();
				Method m2 = c.getMethod("getParameterValues",
						new Class[] { java.lang.String.class });
				String values[] = (String[]) m2.invoke(request,
						new Object[] { name });
				sb = new StringBuffer();
				for (int i = 0; i < values.length; i++) {
					sb.append(values[i]);
					if (i != values.length - 1)
						sb.append(" ; ");
				}

			}

			dumpEnd(prefix, new Vector(), request);
		} catch (Exception ex) {
			ex.printStackTrace(out);
		}
	}

	private static final void dump(String prefix, int depth,
			Vector checkCircuit, Enumeration e) {
		if (e == null) {
			dump(prefix, "null");
			return;
		}
		dumpBegin(prefix, checkCircuit, e);
		int i = 0;
		for (; e.hasMoreElements(); dump(String.valueOf(String
				.valueOf((new StringBuffer(String.valueOf(String
						.valueOf(indent(prefix))))).append('[').append(i++)
						.append("] "))), depth, checkCircuit, e.nextElement()))
			;
		dumpEnd(prefix, checkCircuit, e);
	}

	private static final void dump(String prefix, Throwable t) {
		if (t == null) {
			dump(prefix, "null");
			return;
		} else {
			dumpBegin(prefix, new Vector(), t);
			t.printStackTrace(out);
			dumpEnd(prefix, new Vector(), t);
			return;
		}
	}

	private static final void dump(String prefix, byte data[], int offset,
			int length) {
		if (data == null) {
			dump(prefix, "null");
			return;
		}
		if (offset < 0 || data.length < offset + length) {
			dump(prefix, String.valueOf(String.valueOf((new StringBuffer(
					"IndexOutOfBounds:data.length=")).append(data.length)
					.append(" offset=").append(offset).append(" length=")
					.append(length))));
			return;
		}
		dumpBegin(prefix, new Vector(), data);
		int end = offset + length;
		dump(indent(prefix),
				"[HEX]  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f | 0123456789abcdef");
		dump(indent(prefix),
				"------------------------------------------------------------------------");
		for (int i = offset; i < end; i += 16) {
			byte row[] = { 48, 48, 48, 48, 58, 32, 48, 48, 32, 48, 48, 32, 48,
					48, 32, 48, 48, 32, 48, 48, 32, 48, 48, 32, 48, 48, 32, 48,
					48, 32, 48, 48, 32, 48, 48, 32, 48, 48, 32, 48, 48, 32, 48,
					48, 32, 48, 48, 32, 48, 48, 32, 48, 48, 32, 124, 32, 46,
					46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46 };
			setHex(row, 3, i);
			for (int j = i; j < i + 16; j++)
				if (j < end) {
					int b = data[j];
					if (b < 0)
						b += 256;
					setHex(row, 7 + (j - i) * 3, b);
					if (b >= 32 && b < 127)
						row[(56 + j) - i] = (byte) b;
				} else {
					row[6 + (j - i) * 3] = 32;
					row[7 + (j - i) * 3] = 32;
					row[56 + (j - i)] = 32;
				}

			dump(indent(prefix), new String(row));
		}

		dumpEnd(prefix, new Vector(), data);
	}

	private static final void dump(String prefix, byte b[]) {
		dump(prefix, b, 0, b.length <= 512 ? b.length : 512);
	}

	private static final void dump(String prefix, int depth,
			Vector checkCircuit, Map map) {
		if (map == null)
			dump(prefix, "null");
		dumpBegin(prefix, checkCircuit, map);
		for (Iterator i = map.keySet().iterator(); i.hasNext();) {
			Object key = i.next();
			Object value = map.get(key);
			if (value instanceof String)
				dump(indent(prefix), String.valueOf(String
						.valueOf((new StringBuffer(String.valueOf(String
								.valueOf(key.toString())))).append(" = ")
								.append(value))));
			else
				dump(String.valueOf(String.valueOf((new StringBuffer(String
						.valueOf(String.valueOf(indent(prefix))))).append(
						key.toString()).append(" = "))), depth, checkCircuit,
						map.get(key));
		}

		dumpEnd(prefix, checkCircuit, map);
	}

	private static final void dump(String prefix, String str) {
		out.println(String.valueOf(prefix) + String.valueOf(str));
		out.flush();
	}

	private static final void dump(String prefix, int depth,
			Vector checkCircuit, Object objs[]) {
		if (objs == null) {
			dump(prefix, "null");
			return;
		}
		dumpBegin(prefix, checkCircuit, ((Object) (objs)));
		for (int i = 0; i < objs.length; i++)
			dump(String.valueOf(String.valueOf((new StringBuffer(String
					.valueOf(String.valueOf(indent(prefix))))).append('[')
					.append(i).append("] "))), depth, checkCircuit, objs[i]);

		dumpEnd(prefix, checkCircuit, ((Object) (objs)));
	}

	private static void dump(String prefix, int depth, Vector checkCircuit,
			Object obj) {
		if (obj == null) {
			dump(prefix, "null");
			return;
		}
		try {
			if ((obj instanceof String) || (obj instanceof Number)
					|| (obj instanceof Character) || (obj instanceof Boolean)) {
				dump(prefix, obj.toString());
				return;
			}
			if (checkCircuit
					.contains(new Integer(System.identityHashCode(obj)))) {
				StringBuffer sb = new StringBuffer();
				sb.append(formatClassName(obj.getClass(), obj));
				sb.append(" @");
				sb.append(System.identityHashCode(obj));
				sb.append(' ');
				dump(prefix, " {Circle recursion!}");
				return;
			}
			if (getDepth(prefix) > depth) {
				String str = String.valueOf(String.valueOf((new StringBuffer(
						String.valueOf(String.valueOf(formatClassName(obj
								.getClass(), obj))))).append(" @").append(
						System.identityHashCode(obj))));
				if (prefix.trim().endsWith(str.trim()))
					str = "";
				String toStr;
				try {