package Torello.HTML;

import java.util.Vector;
import java.io.Serializable;
import java.util.Comparator;

/**
 * The abstract parent class of all three {@code NodeIndex} classes, {@link TagNodeIndex},
 * {@link TextNodeIndex} and {@link CommentNodeIndex}.
 * 
 * <BR /><BR /><EMBED CLASS='external-html' DATA-FILE-ID=NODE_INDEX>
 * 
 * @param <NODE> The class of {@code HTMLNode} represented by this {@code NodeIndex} instance.
 * @see HTMLNode
 * @see CommentNodeIndex
 * @see TagNodeIndex
 * @see TextNodeIndex
 */
@SuppressWarnings("rawtypes")
public abstract class NodeIndex<NODE extends HTMLNode>
    implements CharSequence, Serializable, Cloneable, Replaceable
{
    // ********************************************************************************************
    // ********************************************************************************************
    // Fields
    // ********************************************************************************************
    // ********************************************************************************************


    /** <EMBED CLASS='external-html' DATA-FILE-ID=SVUID> */
    public static final long serialVersionUID = 1;

    /**
     * An index to a node from a web-page.   This index must point to a the exact same node inside
     * of a vectorized-html page as the node stored in member-field {@code HTMLNode 'n'}.  
     */
    public final int index;

    /**
     * A {@code HTMLNode} from a web-page.  This node is supposed to be the same node stored at the
     * index specified by member-field {@code int 'index'} of some vectorized-html web-page in
     * memory or on disk.
     */
    public NODE n;


    // ********************************************************************************************
    // ********************************************************************************************
    // Constructor
    // ********************************************************************************************
    // ********************************************************************************************


    /** 
     * a default constructor.  This assigns a value to the index field.
     * 
     * @param index This is the vector-index location of HTMLNode 'n' inside of a vectorized-HTML
     * web-page.
     * 
     * <BR /><BR /><B><SPAN STYLE="color: red;">STALE DATA NOTE:</B></SPAN> This class is a
     * minor-use class, not one of the primary data classes.  This instance shall become 'useless'
     * the moment the vector that was used to instantiate this class is modified, and the node 'n'
     * is no longer at vector-index 'index.'  These "NodeIndex" classes are retained, not
     * deprecated due to the fundamental nature of using the classes of the NodeSearch Package.
     * Data is easily made stale.  Generally, when modifying HTML Vectors, the easiest thing to do
     * is <I><B>to remember to modify a vector at specific locations by iterating from the end of
     * the vector, back to the beginning.</I></B>  This will generally prevent "state-data
     * vector-indexes" from rearing their ugly head.
     * 
     * @param n An HTMLNode that needs to be the node found in the underlying vector at
     * vector-index 'index.'
     *
     * @throws IndexOutOfBoundsException if {@code index} is negative, this exception is thrown.
     * @throws NullPointerException if {@code n} is null.
     */
    protected NodeIndex(int index, NODE n)
    {
        this.index = index;
        this.n = n;

        if (n == null)  throw new NullPointerException(
            "HTMLNode parameter 'n' to this constructor was passed a null value, but this " +
            "is not allowed here."
        );

        if (index < 0)  throw new IndexOutOfBoundsException(
            "Integer parameter 'index' to this constructor was passed a negative value: " +
            index
        );
    }

    /**
     * Simple dispatch method helper that switches on the class of input parameter {@code 'n'}.
     * 
     * @param n Any of the three Java HTML defined {@code HTMLNode} subclasses - {@link TagNode},
     * {@link TextNode} or {@code CommentNode}
     * 
     * @return A {@code NodeIndex} inheriting class that is appropriate to {@code 'n'}.
     * 
     * @throws IllegalArgumentException If the user has extended class {@code HTMLNode}, and passed
     * this unrecognized {@code HTMLNode} Type.
     */
    public static final NodeIndex<?> newNodeIndex(int index, HTMLNode n)
    {
        Class<?> newNodeClass = n.getClass();

        if (TagNode.class.isAssignableFrom(newNodeClass))
            return new TagNodeIndex(index, (TagNode) n);

        if (TextNode.class.isAssignableFrom(newNodeClass))
            return new TextNodeIndex(index, (TextNode) n);

        if (CommentNode.class.isAssignableFrom(newNodeClass))
            return new CommentNodeIndex(index, (CommentNode) n);

        throw new IllegalArgumentException
            ("Parameter 'n' has a Type that is an Unrecognized HTMLNode-SubClass Type");
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // java.lang.Object Methods
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * Java's {@code public boolean equals(Object o)} requirements.
     * 
     * <BR /><BR /><B CLASS=JDDescLabel>Final Method:</B>
     * 
     * <BR />This method is final, and cannot be modified by sub-classes.
     * 
     * @param o This may be any Java Object, but only ones of {@code 'this'} type whose
     * internal-values are identical will bring this method to return true.
     * 
     * @return {@code TRUE} If {@code 'this'} equals another object {@code HTMLNode}.
     */
    public final boolean equals(Object o)
    {
        if (o == null) return false;
        if (o == this) return true;

        if (! this.getClass().equals(o.getClass())) return false;

        NodeIndex<?> other = (NodeIndex) o;

        return other.n.str.equals(this.n.str) && (other.index == this.index);
    }

    /**
     * Java's hash-code requirement.
     * 
     * @return A hash-code that may be used when storing this node in a java hashed-collection.
     * The {@link #index} of this {@code NodeIndex} ought to be be a unique hash.
     */
    public int hashCode() { return index; }

    /**
     * Java's {@code interface Comparable<T>} requirements.  This does a very simple comparison
     * using the vector-index position.
     * 
     * <BR /><BR /><B><SPAN STYLE="color: red;">FINAL METHOD:</B></SPAN> This method is final, and
     * cannot be modified by sub-classes.
     * 
     * @param ni Any other {@code NodeIndex} to be compared to {@code 'this' NodeIndex}
     * 
     * @return An integer that fulfils Java's {@code interface Comparable<T> public boolean
     * compareTo(T t)} method requirements.
     * 
     * @see #index
     */
    // @SuppressWarnings("rawtypes")
    // public final int compareTo(NodeIndex ni)
    // { return this.index - ni.index; }

    /**
     * This is an "alternative Comparitor" that can be used for sorting instances of this class.
     * It should work with the {@code Collections.sort(List, Comparator)} method in the standard
     * JDK package {@code java.util.*;}
     * 
     * <BR /><BR /><B CLASS=JDDescLabel>Comparitor Heuristic:</B>
     * 
     * <BR />This version utilizes the standard JDK method {@code String.compareTo(String)}.
     * 
     * @see HTMLNode#str
     */
    public static final Comparator<TextNodeIndex> comp2 =
        (TextNodeIndex txni1, TextNodeIndex txni2) -> txni1.n.str.compareTo(txni2.n.str);
    
    /**
     * This is an "alternative Comparitor" that can be used for sorting instances of this class.
     * It should work with the {@code Collections.sort(List, Comparator)} method in the standard
     * JDK package {@code java.util.*;}
     * 
     * <BR /><BR /><B CLASS=JDDescLabel>Comparitor Heuristic:</B>
     * 
     * <BR />This version utilizes the standard JDK method
     * {@code String.compareToIgnoreCase(String)}.
     * 
     * @see HTMLNode#str
     */
    public static final Comparator<TextNodeIndex> comp3 =
        (TextNodeIndex txni1, TextNodeIndex txni2) -> txni1.n.str.compareToIgnoreCase(txni2.n.str);


    // ********************************************************************************************
    // ********************************************************************************************
    // CharSequence Methods
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * Returns the char value at the specified index of the {@code public final String str} field
     * of {@code 'this'} field {@code public final HTMLNode n}.
     * An index ranges from zero to length() - 1. The first char value of the sequence is at index
     * zero, the next at index one, and so on, as for array indexing.
     * 
     * <BR /><BR />If the char value specified by the index is a surrogate, the surrogate value is
     * returned.
     * 
     * <BR /><BR /><B CLASS=JDDescLabel>Final Method:</B>
     * 
     * <BR />This method is final, and cannot be modified by sub-classes.
     * 
     * @param index The index of the char value to be returned
     * 
     * @return The specified char value
     */
    public final char charAt(int index) { return n.str.charAt(index); }

    /**
     * Returns the length of the {@code public final String str} field of {@code 'this'} field
     * {@code public final HTMLNode n}. The length is the number of 16-bit chars in the sequence.
     * 
     * <BR /><BR /><B CLASS=JDDescLabel>Final Method:</B>
     * 
     * <BR />This method is final, and cannot be modified by sub-classes.
     * 
     * @return the number of chars in {@code this.n.str}
     */
    public final int length() { return n.str.length(); }

    /**
     * Returns a CharSequence that is a subsequence of the {@code public final String str} field of
     * {@code 'this'} field {@code public final HTMLNode n}.
     * The subsequence starts with the char value at the specified index and ends with the char
     * value at index end - 1. The length (in chars) of the returned sequence is end - start,  so
     * if start == end then an empty sequence is returned.
     * 
     * <BR /><BR /><B CLASS=JDDescLabel>Final Method:</B>
     * 
     * <BR />This method is final, and cannot be modified by sub-classes.
     * 
     * @param start The start index, inclusive
     * 
     * @param end The end index, exclusive
     * 
     * @return The specified subsequence
     */
    public final CharSequence subSequence(int start, int end)
    { return n.str.substring(start, end); }

    /**
     * Returns the {@code public final String str} field of {@code 'this'} field {@code public
     * final HTMLNode n}.
     * 
     * <BR /><BR /><B CLASS=JDDescLabel>Final Method:</B>
     * 
     * <BR />This method is final, and cannot be modified by sub-classes.
     * 
     * @return A string consisting of exactly this sequence of characters.
     * 
     * @see HTMLNode#str
     */
    public final String toString()
    { return n.str; }


    // ********************************************************************************************
    // ********************************************************************************************
    // Replaceable Methods
    // ********************************************************************************************
    // ********************************************************************************************


    public int originalSize() { return 1; }
    public int currentSize() { return 1; };


    public int originalLocationStart() { return index; }
    public int originalLocationEnd() { return index + 1; }


    public NODE firstCurrentNode() { return n; }
    public NODE lastCurrentNode() { return n; }

    private Vector<HTMLNode> CURRENT_NODES = null;

    public Vector<HTMLNode> currentNodes()
    {
        if (CURRENT_NODES == null)  CURRENT_NODES = new Vector<>(1);
        CURRENT_NODES.add(n);
        return CURRENT_NODES;
    }


    public boolean addAllInto(Vector<HTMLNode> fileVec) { return fileVec.add(n); }

    public boolean addAllInto(int index, Vector<HTMLNode> fileVec)
    {
        fileVec.insertElementAt(n, index);
        return true;
    }

    public int update(Vector<HTMLNode> fileVec)
    { fileVec.setElementAt(n, index);  return 0; }
}