package net.wotonomy.test;

import java.io.Serializable;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.StringTokenizer;

import net.wotonomy.control.EOEditingContext;
import net.wotonomy.control.EOKeyValueCodingSupport;
import net.wotonomy.datastore.DataSoup;
import net.wotonomy.datastore.SerializedFileSoup;
import net.wotonomy.datastore.XMLFileSoup;
import net.wotonomy.foundation.internal.ValueConverter;

public class TestObject implements Serializable // , EOKeyValueCoding
{
	static final long serialVersionUID = -5482454640042392838L;

// for testing manual array faulting
	public EOEditingContext editingContext;

	public EOEditingContext getEditingContext() {
		return editingContext;
	};

	public TestObject() {
		date = new Date();
		firstName = randomParse("Bert|Ernie|Elmo|Zoe|Arthur|Emily|DJ|Grover|Oscar|Max|Big|Twinkle");
		middleName = new StringBuffer(
				randomParse("Rufus|Remy|Martin|Josephus|Ulysses|Homer|Bart|Tip|Onegin|Meredith|Jay"));
		lastName = randomParse("Alejandro|Alexander|Bird|Gosling|Joy|Van Hoff|Pedia|Marr|McNealy|Ping");
		address = randomParse("1|2|3|4") + randomParse("0|1|00|10|5|50") + randomParse("0|00|1|01|5|05|9|09||000") + " "
				+ randomParse("Merry|Berry|Perry|Jerry|Meadow|Falls|Elm|Raspberry|Strawberry") + " "
				+ randomParse("Road|Lane|Court|Drive|Parkway|Terrace");
		city = randomParse("Springfield|Sterling|Cascades|Vienna|Reston|Paris|London|Runnymeade");
		state = randomParse("TX|NJ|NY|VA|DC|MD|NC|SC|WV|AR|FL|CA|TN");
		zip = ValueConverter.getIntValue(randomParse("1|2|3|4") + "0" + randomParse("0|1|2|3|5")
				+ randomParse("6|7|8|9") + randomParse("6|7|8|9"));
		age = (short) (new Random().nextDouble() * 40 + 18);
		childCount = -1;
//	    children = null;
		childList = null;
	}

	protected Date date;

	public Date getCreateDate() {
		return date;
	}

	public void setCreateDate(Date aDate) {
		date = aDate;
	}

	protected String firstName;

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String aName) {
		firstName = aName;
	}

	protected String lastName;

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String aName) {
		if ("Jones".equals(aName))
			throw new RuntimeException("Jones not allowed");
		lastName = aName;
	}

	protected StringBuffer middleName;

	public StringBuffer getMiddleName() {
		return middleName;
	}

	public void setMiddleName(StringBuffer aName) {
		middleName = aName;
	}

	protected String address;

	public String getAddress() {
		return address;
	}

	public void setAddress(String anAddress) {
		address = anAddress;
	}

	protected String city;

	public String getCity() {
		return city;
	}

	public void setCity(String aCity) {
		city = aCity;
	}

	protected String state;

	public String getState() {
		return state;
	}

	public void setState(String aState) {
		state = aState;
	}

	protected int zip;

	public int getZipCode() {
		return zip;
	}

	public void setZipCode(int aZipCode) {
		zip = aZipCode;
	}

	protected short age;

	public short getAge() {
		return age;
	}

	public void setAge(short anAge) {
		age = anAge;
	}

	protected boolean special;

	public Boolean isSpecial() {
		return new Boolean(special);
	}

	public void setSpecial(Boolean isSpecial) {
		special = isSpecial.booleanValue();
	}

	/*
	 * protected Object[] children;
	 * 
	 * private Object[] getChildren() { if ( children == null ) { int n =
	 * getChildCount(); children = new Object[ n ]; for ( int i = 0; i < n; i++ ) {
	 * children[i] = new TestObject(); } //System.out.println(
	 * "TestObject.getChildren: " + toString() + " : " + getChildCount() ); } return
	 * children; } private void setChildren( Object[] aChildArray ) { children =
	 * aChildArray; childCount = aChildArray.length; }
	 * 
	 * // following child list implementation wraps child array
	 * 
	 * public List getChildList() { List result = new LinkedList(); Object[]
	 * childArray = getChildren(); for ( int i = 0; i < childArray.length; i++ ) {
	 * result.add( childArray[i] ); } return result; } public void setChildList(
	 * List aChildList ) { children = new Object[ aChildList.size() ]; for ( int i =
	 * 0; i < children.length; i++ ) { children[i] = (TestObject) aChildList.get( i
	 * ); } childCount = children.length; }
	 */
	protected int childCount;

	public int getChildCount() {
		if (childCount == -1) {
// uncomment this to enable random children
//			childCount = (int) ( random.nextDouble() * 6 ) - 3; // + 100; // tree scalability test
			if (childCount < 0)
				childCount = 0;
		}

// this tests internal count        
//		return childCount; 
// this tests deferred count    
		if (childList != null) {
			return childList.size();
		} else {
			return 0;
		}
	};

	// following child list implementation stands alone

	protected List childList;

	public List getChildList() {
		/*
		 * // this tests random child population if ( childList == null ) { int n =
		 * getChildCount(); childList = new LinkedList(); for ( int i = 0; i < n; i++ )
		 * { childList.add( new TestObject() ); } }
		 */
		// this tests manual loading
		if (childList == null) {
			childList = new LinkedList();
		}
		return childList;
	}

	public void setChildList(List aChildList) {
		childList = aChildList;
	}

	protected TestObject parent;

	public TestObject getParent() {
		return parent;
	}

	public void setParent(TestObject anObject) {
		parent = anObject;
	}

	public String getHash() {
		return Integer.toHexString(System.identityHashCode(this));
	}

	public String getFullName() {
//    	return getHash() + ": " + firstName + " " + middleName + " " + lastName;
		return firstName + " " + middleName + " " + lastName;
	}

	public boolean equals(Object anObject) {
		return anObject == this;
	}

	public String toString() {
		return "[" + getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(this)) + ":"
				+ getFullName() + "]";
	}

	// statics

	private static Random random = new Random();

	private static String randomParse(String aString) {
		String result = "";
		StringTokenizer tokens = new StringTokenizer(aString, "|");
		int n = (int) (random.nextDouble() * tokens.countTokens());
		for (int i = 0; i <= n; i++) {
			result = tokens.nextToken();
		}
		return result;
	}

	// interface EOKeyValueCoding:
	// disable this interface by commenting out the "implements" declaration

	/**
	 * Returns the value for the specified property. If the property does not exist,
	 * this method should call handleQueryWithUnboundKey.
	 */
	public Object valueForKey(String aKey) {
		System.out.println("valueForKey: " + aKey);
		return EOKeyValueCodingSupport.valueForKey(this, aKey);
	}

	/**
	 * Sets the property to the specified value. If the property does not exist,
	 * this method should call handleTakeValueForUnboundKey. If the property is of a
	 * type that cannot allow null (e.g. primitive types) and aValue is null, this
	 * method should call unableToSetNullForKey.
	 */
	public void takeValueForKey(Object aValue, String aKey) {
		System.out.println("takeValueForKey: " + aValue + " : " + aKey);
		EOKeyValueCodingSupport.takeValueForKey(this, aValue, aKey);
	}

	/**
	 * Returns the value for the private field that corresponds to the specified
	 * property.
	 */
	public Object storedValueForKey(String aKey) {
		System.out.println("storedValueForKey: " + aKey);
		return EOKeyValueCodingSupport.storedValueForKey(this, aKey);
	}

	/**
	 * Sets the the private field that corresponds to the specified property to the
	 * specified value.
	 */
	public void takeStoredValueForKey(Object aValue, String aKey) {
		System.out.println("takeStoredValueForKey: " + aValue + " : " + aKey);
		EOKeyValueCodingSupport.takeStoredValueForKey(this, aValue, aKey);
	}

	/**
	 * Called by valueForKey when the specified key is not found on this object.
	 * Implementing classes should handle the specified value or otherwise throw an
	 * exception.
	 */
	public Object handleQueryWithUnboundKey(String aKey) {
		System.out.println("handleQueryWithUnboundKey: " + aKey);
		return EOKeyValueCodingSupport.handleQueryWithUnboundKey(this, aKey);
	}

	/**
	 * Called by takeValueForKey when the specified key is not found on this object.
	 * Implementing classes should handle the specified value or otherwise throw an
	 * exception.
	 */
	public void handleTakeValueForUnboundKey(Object aValue, String aKey) {
		System.out.println("handleTakeValueForUnboundKey: " + aValue + " : " + aKey);
		EOKeyValueCodingSupport.handleTakeValueForUnboundKey(this, aValue, aKey);
	}

	/**
	 * Called by takeValueForKey when the type of the specified key is not allowed
	 * to be null, as is the case with primitive types. Implementing classes should
	 * handle this case appropriately or otherwise throw an exception.
	 */
	public void unableToSetNullForKey(String aKey) {
		System.out.println("unableToSetNullForKey: " + aKey);
		EOKeyValueCodingSupport.unableToSetNullForKey(this, aKey);
	}

	// main entry point

	public static void main(String[] argv) {
		int count = 100;
		boolean xmlMode = false;
		if (argv.length > 0) {
			Integer parsed = ValueConverter.getInteger(argv[0]);
			if (parsed != null)
				count = parsed.intValue();

			if (argv.length > 1) {
				if (argv[1].indexOf("xml") > -1) {
					xmlMode = true;
				}
			}
		}

		long millis = System.currentTimeMillis();

		DataSoup store = null;
		if (xmlMode) {
			store = new XMLFileSoup("testObjects-xml");
		} else {
			store = new SerializedFileSoup("testObjects-java");
		}

		Object o;
		for (int i = 0; i < count; i++) {
			store.addObject(new TestObject());
		}
		/*
		 * store.addIndex( "age", "age" ); store.addIndex( "zipCode", "zipCode" );
		 * store.addIndex( "firstName", "firstName" ); store.addIndex( "lastName",
		 * "lastName" );
		 */
		System.out.println(System.currentTimeMillis() - millis + " milliseconds");
	}
}