/*
 * Conditions Of Use
 *
 * This software was developed by employees of the National Institute of
 * Standards and Technology (NIST), an agency of the Federal Government.
 * Pursuant to title 15 Untied States Code Section 105, works of NIST
 * employees are not subject to copyright protection in the United States
 * and are considered to be in the public domain.  As a result, a formal
 * license is not needed to use the software.
 *
 * This software is provided by NIST as a service and is expressly
 * provided "AS IS."  NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED
 * OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT
 * AND DATA ACCURACY.  NIST does not warrant or make any representations
 * regarding the use of the software or the results thereof, including but
 * not limited to the correctness, accuracy, reliability or usefulness of
 * the software.
 *
 * Permission to use this software is contingent upon your acceptance
 * of the terms of this agreement
 *
 * .
 *
 */
/*******************************************************************************
 * Product of NIST/ITL Advanced Networking Technologies Division (ANTD).        *
 *******************************************************************************/
package gov.nist.core;

import java.util.*;
import java.io.Serializable;

/**
 * Implements a homogenous consistent linked list. All the objects in the linked
 * list must derive from the same root class. This is a useful constraint to
 * place on our code as this property is invariant.The list is created with the
 * superclass which can be specified as either a class name or a Class.
 *
 * @version 1.2
 *
 * @author M. Ranganathan <br/>
 *
 *
 *
 */
public abstract class GenericObjectList extends LinkedList<GenericObject> implements
        Serializable, Cloneable{
    // Useful constants.
    protected static final String SEMICOLON = Separators.SEMICOLON;

    protected static final String COLON = Separators.COLON;

    protected static final String COMMA = Separators.COMMA;

    protected static final String SLASH = Separators.SLASH;

    protected static final String SP = Separators.SP;

    protected static final String EQUALS = Separators.EQUALS;

    protected static final String STAR = Separators.STAR;

    protected static final String NEWLINE = Separators.NEWLINE;

    protected static final String RETURN = Separators.RETURN;

    protected static final String LESS_THAN = Separators.LESS_THAN;

    protected static final String GREATER_THAN = Separators.GREATER_THAN;

    protected static final String AT = Separators.AT;

    protected static final String DOT = Separators.DOT;

    protected static final String QUESTION = Separators.QUESTION;

    protected static final String POUND = Separators.POUND;

    protected static final String AND = Separators.AND;

    protected static final String LPAREN = Separators.LPAREN;

    protected static final String RPAREN = Separators.RPAREN;

    protected static final String DOUBLE_QUOTE = Separators.DOUBLE_QUOTE;

    protected static final String QUOTE = Separators.QUOTE;

    protected static final String HT = Separators.HT;

    protected static final String PERCENT = Separators.PERCENT;

    protected int indentation;

    protected String listName; // For debugging

    private ListIterator<? extends GenericObject> myListIterator;

    private String stringRep;

    protected Class<?> myClass;

    protected String separator;

    protected String getIndentation() {
        char[] chars = new char[indentation];
        java.util.Arrays.fill(chars, ' ');
        return new String(chars);
    }

    /**
     * Return true if this supports reflection based cloning.
     */
    protected static boolean isCloneable(Object obj) {
        return obj instanceof Cloneable;
    }

    public static boolean isMySubclass(Class<?> other) {
        return GenericObjectList.class.isAssignableFrom(other);

    }

    /**
     * Makes a deep clone of this list.
     */
    public Object clone() {
        GenericObjectList retval = (GenericObjectList) super.clone();
        for (ListIterator<GenericObject> iter = retval.listIterator(); iter.hasNext();) {
            GenericObject obj = (GenericObject) ((GenericObject) iter.next())
                    .clone();
            iter.set(obj);
        }
        return retval;
    }



    public void setMyClass(Class cl) {
        myClass = cl;
    }

    protected GenericObjectList() {
        super();
        listName = null;
        stringRep = "";
        separator = ";";
    }

    protected GenericObjectList(String lname) {
        this();
        listName = lname;
    }

    /**
     * A Constructor which takes a list name and a class name (for assertion
     * checking).
     */

    protected GenericObjectList(String lname, String classname) {
        this(lname);
        try {
            myClass = Class.forName(classname);
        } catch (ClassNotFoundException ex) {
            InternalErrorHandler.handleException(ex);
        }

    }

    /**
     * A Constructor which takes a list name and a class (for assertion
     * checking).
     */

    protected GenericObjectList(String lname, Class objclass) {
        this(lname);
        myClass = objclass;
    }

    /**
     * Traverse the list given a list iterator
     */
    protected GenericObject next(ListIterator iterator) {
        try {
            return (GenericObject) iterator.next();
        } catch (NoSuchElementException ex) {
            return null;
        }
    }

    /**
     * This is the default list iterator.This will not handle nested list
     * traversal.
     */
    protected GenericObject first() {
        myListIterator = this.listIterator(0);
        try {
            return (GenericObject) myListIterator.next();
        } catch (NoSuchElementException ex) {
            return null;
        }
    }

    /**
     * Fetch the next object from the list based on the default list iterator
     */
    protected GenericObject next() {
        if (myListIterator == null) {
            myListIterator = this.listIterator(0);
        }
        try {
            return (GenericObject) myListIterator.next();
        } catch (NoSuchElementException ex) {
            myListIterator = null;
            return null;
        }
    }

    /**
     * Concatenate two compatible header lists, adding the argument to the tail
     * end of this list.
     *
     * @param <var>
     *            topFlag </var> set to true to add items to top of list
     */
    protected void concatenate(GenericObjectList objList) {
        concatenate(objList, false);
    }

    /**
     * Concatenate two compatible header lists, adding the argument either to
     * the beginning or the tail end of this list. A type check is done before
     * concatenation.
     *
     * @param <var>
     *            topFlag </var> set to true to add items to top of list else
     *            add them to the tail end of the list.
     */
    protected void concatenate(GenericObjectList objList, boolean topFlag) {
        if (!topFlag) {
            this.addAll(objList);
        } else {
            // add given items to the top end of the list.
            this.addAll(0, objList);
        }
    }

    /**
     * string formatting function.
     */

    private void sprint(String s) {
        if (s == null) {
            stringRep += getIndentation();
            stringRep += "<null>\n";
            return;
        }

        if (s.compareTo("}") == 0 || s.compareTo("]") == 0) {
            indentation--;
        }
        stringRep += getIndentation();
        stringRep += s;
        stringRep += "\n";
        if (s.compareTo("{") == 0 || s.compareTo("[") == 0) {
            indentation++;
        }
    }

    /**
     * Convert this list of headers to a formatted string.
     */

    public String debugDump() {
        stringRep = "";
        Object obj = this.first();
        if (obj == null)
            return "<null>";
        sprint("listName:");
        sprint(listName);
        sprint("{");
        while (obj != null) {
            sprint("[");
            sprint(((GenericObject) obj).debugDump(this.indentation));
            obj = next();
            sprint("]");
        }
        sprint("}");
        return stringRep;
    }

    /**
     * Convert this list of headers to a string (for printing) with an
     * indentation given.
     */

    public String debugDump(int indent) {
        int save = indentation;
        indentation = indent;
        String retval = this.debugDump();
        indentation = save;
        return retval;
    }

    public void addFirst(GenericObject objToAdd) {
        if (myClass == null) {
            myClass = objToAdd.getClass();
        } else {
            super.addFirst(objToAdd);
        }
    }

    /**
     * Do a merge of the GenericObjects contained in this list with the
     * GenericObjects in the mergeList. Note that this does an inplace
     * modification of the given list. This does an object by object merge of
     * the given objects.
     *
     * @param mergeList
     *            is the list of Generic objects that we want to do an object by
     *            object merge with. Note that no new objects are added to this
     *            list.
     *
     */

    public void mergeObjects(GenericObjectList mergeList) {

        if (mergeList == null)
            return;
        Iterator it1 = this.listIterator();
        Iterator it2 = mergeList.listIterator();
        while (it1.hasNext()) {
            GenericObject outerObj = (GenericObject) it1.next();
            while (it2.hasNext()) {
                Object innerObj = it2.next();
                outerObj.merge(innerObj);
            }
        }
    }

    /**
     * Encode the list in semicolon separated form.
     *
     * @return an encoded string containing the objects in this list.
     * @since v1.0
     */
    public String encode() {
        if (this.isEmpty())
            return "";
        StringBuffer encoding = new StringBuffer();
        ListIterator iterator = this.listIterator();
        if (iterator.hasNext()) {
            while (true) {
                Object obj = iterator.next();
                if (obj instanceof GenericObject) {
                    GenericObject gobj = (GenericObject) obj;
                    encoding.append(gobj.encode());
                } else {
                    encoding.append(obj.toString());
                }
                if (iterator.hasNext())
                    encoding.append(separator);
                else
                    break;
            }
        }
        return encoding.toString();
    }

    /**
     * Alias for the encode function above.
     */
    public String toString() {
        return this.encode();
    }

    /**
     * Set the separator (for encoding the list)
     *
     * @since v1.0
     * @param sep
     *            is the new seperator (default is semicolon)
     */
    public void setSeparator(String sep) {
        separator = sep;
    }
    
    /**
     * Hash code. We never expect to put this in a hash table so return a constant.
     */
    public int hashCode() { return 42; }

    /**
     * Equality checking predicate.
     *
     * @param other
     *            is the object to compare ourselves to.
     * @return true if the objects are equal.
     */
    public boolean equals(Object other) {
        if (other == null ) return false;
        if (!this.getClass().equals(other.getClass()))
            return false;
        GenericObjectList that = (GenericObjectList) other;
        if (this.size() != that.size())
            return false;
        ListIterator myIterator = this.listIterator();
        while (myIterator.hasNext()) {
            Object myobj = myIterator.next();
            ListIterator hisIterator = that.listIterator();
            try {
                while (true) {
                    Object hisobj = hisIterator.next();
                    if (myobj.equals(hisobj))
                        break;
                }
            } catch (NoSuchElementException ex) {
                return false;
            }
        }
        ListIterator hisIterator = that.listIterator();
        while (hisIterator.hasNext()) {
            Object hisobj = hisIterator.next();
            myIterator = this.listIterator();
            try {
                while (true) {
                    Object myobj = myIterator.next();
                    if (hisobj.equals(myobj))
                        break;
                }
            } catch (NoSuchElementException ex) {
                return false;
            }
        }
        return true;
    }

    /**
     * Match with a template (return true if we have a superset of the given
     * template. This can be used for partial match (template matching of SIP
     * objects). Note -- this implementation is not unnecessarily efficient :-)
     *
     * @param other
     *            template object to compare against.
     */

    public boolean match(Object other) {
        if (!this.getClass().equals(other.getClass()))
            return false;
        GenericObjectList that = (GenericObjectList) other;
        ListIterator hisIterator = that.listIterator();
        outer: while (hisIterator.hasNext()) {
            Object hisobj = hisIterator.next();
            Object myobj = null;
            ListIterator myIterator = this.listIterator();
            while (myIterator.hasNext()) {
                myobj = myIterator.next();
                if (myobj instanceof GenericObject)
                    System.out.println("Trying to match  = "
                            + ((GenericObject) myobj).encode());
                if (GenericObject.isMySubclass(myobj.getClass())
                        && ((GenericObject) myobj).match(hisobj))
                    break outer;
                else if (GenericObjectList.isMySubclass(myobj.getClass())
                        && ((GenericObjectList) myobj).match(hisobj))
                    break outer;
            }
            System.out.println(((GenericObject) hisobj).encode());
            return false;
        }
        return true;
    }
}