package org.hamcrest.core;

import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.hamcrest.Matcher;

import java.lang.reflect.Array;


/**
 
* Is the value equal to another value, as tested by the
 
* {@link java.lang.Object#equals} invokedMethod?
 
*/

public class IsEqual<T> extends BaseMatcher<T> {
    
private final Object expectedValue;

    
public IsEqual(T equalArg) {
        
expectedValue = equalArg;
    
}

    
@Override
    
public boolean matches(Object actualValue) {
        
return areEqual(actualValue, expectedValue);
    
}

    
@Override
    
public void describeTo(Description description) {
        
description.appendValue(expectedValue);
    
}

    
private static boolean areEqual(Object actual, Object expected) {
        
if (actual == null) {
            
return expected == null;
        
}
        

        
if (expected != null && isArray(actual)) {
            
return isArray(expected) && areArraysEqual(actual, expected);
        
}
        

        
return actual.equals(expected);
    
}

    
private static boolean areArraysEqual(Object actualArray, Object expectedArray) {
        
return areArrayLengthsEqual(actualArray, expectedArray) && areArrayElementsEqual(actualArray, expectedArray);
    
}

    
private static boolean areArrayLengthsEqual(Object actualArray, Object expectedArray) {
        
return Array.getLength(actualArray) == Array.getLength(expectedArray);
    
}

    
private static boolean areArrayElementsEqual(Object actualArray, Object expectedArray) {
        
for (int i = 0; i < Array.getLength(actualArray); i++) {
            
if (!areEqual(Array.get(actualArray, i), Array.get(expectedArray, i))) {
                
return false;
            
}
        
}
        
return true;
    
}

    
private static boolean isArray(Object o) {
        
return o.getClass().isArray();
    
}

    
/**
     
* Creates a matcher that matches when the examined object is logically equal to the specified
     
* <code>operand</code>, as determined by calling the {@link java.lang.Object#equals} method on
     
* the <b>examined</b> object.
     
*
 

     
* <p>If the specified operand is <code>null</code> then the created matcher will only match if
     
* the examined object's <code>equals</code> method returns <code>true</code> when passed a
     
* <code>null</code> (which would be a violation of the <code>equals</code> contract), unless the
     
* examined object itself is <code>null</code>, in which case the matcher will return a positive
     
* match.</p>
     
*
 

     
* <p>The created matcher provides a special behaviour when examining <code>Array</code>s, whereby
     
* it will match if both the operand and the examined object are arrays of the same length and
     
* contain items that are equal to each other (according to the above rules) <b>in the same
     
* indexes</b>.</p>
 

     
* For example:
     
* <pre>
     
* assertThat("foo", equalTo("foo"));
     
* assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
     
* </pre>
     
*
 

     
*/

    
public static <T> Matcher<T> equalTo(T operand) {
        
return new IsEqual<>(operand);
    
}

    
/**
     
* Creates an
 
 
matcher that does not enforce the values being
     
* compared to be of the same static type.
     
*/

    
public static Matcher<Object> equalToObject(Object operand) {
        
return new IsEqual<>(operand);
    
}
}