package wox.serial;

import java.lang.reflect.*;
import org.litesoft.core.typeutils.Objects;
import java.util.*;

/**
 * Utilities to compare two objects - weaker than
 * equals and adjusted to make serialized and deserialized objects
 * equivalent
 *
 * Version: 1.0
 * Author: Carlos R. Jaimez Gonzalez
 * Author: Simon M. Lucas
 * Site: http://woxserializer.sourceforge.net/
 *
 * Version: 1.5
 * Author: Steven M Lewis
 *
 * Version: 2.0
 * Author: George Smith
 * SVN: http://svn.xp-dev.com/svn/WOX2/
 * Note: XML form for vs 2 is more compact and therefor incompatible with vs 1
 */

public class ComparisonUtilities
{
    /**
     * true if two objects are of the same class with the same field values
     *
     * @param o1 item1
     * @param o2 item2
     *
     * @return true if they are the same
     */
    public static boolean equivalent( Object o1, Object o2 )
    {
        if ( o1 == o2 )
        {
            return true;
        }
        if ( o1 == null || o2 == null )
        {
            return false; // both null covered in first test
        }
        if ( o1.equals( o2 ) )
        {
            return true;
        }
        Class cls = o1.getClass();
        if ( cls != o2.getClass() )
        {
            return false;
        }
        // Primitive special case
        if ( cls.isPrimitive() )
        {
            return false; // o1.equals( o2 ) : handled above
        }
        // Enum special case
        if ( cls.isEnum() )
        {
            return false; // o1 == o2 : handled above
        }
        // Array special case
        if ( cls.isArray() )
        {
            return equivalentArrayValues( o1, o2 );
        }
        // List special case
        if ( List.class.isAssignableFrom( cls ) )
        {
            return equivalentListValues( (List) o1, (List) o2 );
        }
        // Map special case
        if ( Map.class.isAssignableFrom( cls ) )
        {
            return equivalentMapValues( (Map) o1, (Map) o2 );
        }

        return equivalentFieldValues( o1, o2 );
    }

    public static boolean equivalentFieldValues( Object o1, Object o2 )
    {
        Class zClass = o1.getClass();
        Field[] fields = zClass.getDeclaredFields();
        for ( Field info : fields )
        {
            if ( !equivalentFieldValue( info, o1, o2 ) )
            {
                return false;
            }
        }
        return true;
    }

    public static boolean equivalentArrayValues( Object o1, Object o2 )
    {
        if ( o1 == o2 )
        {
            return true;
        }
        if ( o1 == null || o2 == null )
        {
            return false; // both null covered in first test
        }
        int l1 = Array.getLength( o1 );
        if ( l1 != Array.getLength( o2 ) )
        {
            return false;
        }
        for ( int i = 0; i < l1; i++ )
        {
            if ( !equivalent( Array.get( o1, i ), Array.get( o2, i ) ) )
            {
                return false;
            }
        }
        return true;
    }

    /**
     * true if two  lists hold an equivalent collection in
     * the same order
     *
     * @param o1 item1
     * @param o2 item2
     *
     * @return true if they are the same
     */
    public static boolean equivalentListValues( List o1, List o2 )
    {
        if ( o1 == o2 )
        {
            return true;
        }
        if ( o1 == null || o2 == null )
        {
            return false; // both null covered in first test
        }
        if ( o1.size() != o2.size() )
        {
            return false;
        }
        for ( int i = 0; i < o1.size(); i++ )
        {
            if ( !equivalent( o1.get( i ), o2.get( i ) ) )
            {
                return false;
            }
        }
        return true;
    }

    /**
     * true if two  maps hold an equivalent collection
     *
     * @param o1 item1
     * @param o2 item2
     *
     * @return true if they are the same
     */
    public static boolean equivalentMapValues( Map o1, Map o2 )
    {
        if ( o1 == o2 )
        {
            return true;
        }
        if ( o1 == null || o2 == null )
        {
            return false; // both null covered in first test
        }
        if ( o1.size() != o2.size() )
        {
            return false;
        }
        for ( Object key : o1.keySet() )
        {
            if ( !o2.containsKey( key ) )
            {
                return false;
            }
            Object item1 = o1.get( key );
            Object item2 = o2.get( key );
            if ( !equivalent( item1, item2 ) )
            {
                return false;
            }
        }
        return true;
    }

    /**
     * true if two  fields hold an object -
     * the two objects are of the same class
     *
     * @param info field - must be present in both
     * @param o1   item1
     * @param o2   item2
     *
     * @return true if they are the same
     */
    protected static boolean equivalentFieldValue( Field info, Object o1, Object o2 )
    {
        try
        {
            info.setAccessible( true );
            Object f1 = info.get( o1 );
            Object f2 = info.get( o2 );
            return equivalent( f1, f2 );
        }
        catch ( IllegalAccessException e )
        {
            return false;
        }
    }
}