package org.litesoft.rest.adapters;

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

import org.litesoft.rest.utils.*;

/**
 * This class is the common super class of all JAXB generated classes, and is specifically for the purposes
 * of supporting a reflection based implementation of equals, hashCode, and toString.
 * <p/>
 * While the implementations are based on the Apache Commons reflection based implementations, we diverge
 * from those implementations by relying on the "public get???()" methods.
 */
@javax.xml.bind.annotation.XmlTransient
public class JAXBgeneratedClassSuperClass implements Serializable,
                                                     ToStringBuildable
{
    private static class RuntimeReflectionException extends RuntimeException
    {
        private RuntimeReflectionException( Throwable cause )
        {
            super( cause );
        }
    }

    private transient AccessorManager mAccessorManager;

    private AccessorManager getAssessorManager()
    {
        if ( mAccessorManager == null )
        {
            mAccessorManager = new AccessorManager( this.getClass() );
        }
        return mAccessorManager;
    }

    @Override
    public void toStringBuild( int pIndentLevel, StringBuilder pSB )
    {
        pSB.append( getClass().getSimpleName() ).append( ':' );
        pIndentLevel++;
        for ( Accessor zAccessor : getAssessorManager().getAccessors() )
        {
            Object zValue = zAccessor.getValue( this );
            if ( zValue != null )
            {
                pSB.append( '\n' );
                for ( int i = 0; i < pIndentLevel; i++ )
                {
                    pSB.append( "  " );
                }
                pSB.append( zAccessor.getGetterName() ).append( '=' );
                if ( zValue instanceof ToStringBuildable )
                {
                    ((ToStringBuildable) zValue).toStringBuild( pIndentLevel, pSB );
                }
                else
                {
                    pSB.append( zValue );
                }
            }
        }
    }

    @Override
    public String toString()
    {
        StringBuilder sb = new StringBuilder();
        toStringBuild( 0, sb );
        return sb.toString();
    }

    @Override
    public int hashCode()
    {
        int zHash = 0;
        for ( Accessor zAccessor : getAssessorManager().getAccessors() )
        {
            zHash *= 37;
            Object zValue = zAccessor.getValue( this );
            if ( zValue != null )
            {
                zHash += zValue.hashCode();
            }
        }
        return zHash;
    }

    /**
     * Reflection based equals (like the Apache Commons reflection based version- see class note) where one must be an
     * instance of the other and they must have the same getter methods!
     */
    @Override
    public boolean equals( Object obj )
    {
        return (this == obj) || ((obj instanceof JAXBgeneratedClassSuperClass) && equals( (JAXBgeneratedClassSuperClass) obj ));
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public boolean hasValues()
    {
        for ( Accessor zAccessor : getAssessorManager().getAccessors() )
        {
            Object zValue = zAccessor.getValue( this );
            if ( zValue != null )
            {
                return true;
            }
        }
        return false;
    }

    @SuppressWarnings({"unchecked"})
    private static boolean acceptableEqualTypes( Class pThis, Class pThem )
    {
        return pThis.isAssignableFrom( pThem ) || pThem.isAssignableFrom( pThis );
    }

    private static boolean areEqual( Object pThis, Object pThem )
    {
        return (pThis == pThem) || ((pThis != null) && pThis.equals( pThem ));
    }

    private boolean equals( JAXBgeneratedClassSuperClass them )
    {
        if ( acceptableEqualTypes( this.getClass(), them.getClass() ) )
        {
            AccessorManager zAMthis = this.getAssessorManager();
            AccessorManager zAMthem = them.getAssessorManager();

            Accessor[] zThisAccessors = zAMthis.getAccessors();
            if ( zThisAccessors.length == zAMthem.getAccessors().length )
            {
                for ( int i = 0; i < zThisAccessors.length; i++ )
                {
                    Accessor zThisAccessor = zThisAccessors[i];
                    Accessor zThemAccessor = zAMthem.getAccessor( i, zThisAccessor ); // Null == Not Found
                    if ( (zThemAccessor == null) || !areEqual( zThisAccessor.getValue( this ), zThemAccessor.getValue( them ) ) )
                    {
                        return false;
                    }
                }
                return true;
            }
        }
        return false;
    }

    private static class AccessorManager
    {
        private Accessor[] mAccessors;

        public AccessorManager( Class pClass )
        {
            Method[] zMethods = pClass.getMethods();
            List<Accessor> zAccessors = new ArrayList<Accessor>( zMethods.length );
            for ( Method zMethod : zMethods )
            {
                if ( isGetter( zMethod ) )
                {
                    String zName = zMethod.getName();
                    zAccessors.add( new Accessor( zName.substring( 3 ), // drop the "get"
                                                  zMethod ) );
                }
            }
            Arrays.sort( mAccessors = zAccessors.toArray( new Accessor[zAccessors.size()] ) );
        }

        private static boolean isGetter( Method pMethod )
        {
            String zName = pMethod.getName();
            return !void.class.equals( pMethod.getReturnType() ) && //
                   !zName.equals( "getClass" ) && //
                   (zName.indexOf( '_' ) == -1) && //
                   zName.startsWith( "get" ) && //
                   (pMethod.getParameterTypes().length == 0);
        }

        public Accessor[] getAccessors()
        {
            return mAccessors;
        }

        public Accessor getAccessor( int pStartingSearchIndex, Accessor pThemAccessor )
        {
            return find( pThemAccessor, 0, pStartingSearchIndex, mAccessors.length - 1 );
        }

        private Accessor find( Accessor pThemAccessor, int pFrom, int pAt, int pThru )
        {
            Accessor zAccessor;
            while ( !pThemAccessor.equals( zAccessor = mAccessors[pAt] ) )
            {
                int zCmp = zAccessor.compareTo( pThemAccessor );
                if ( zCmp == 0 ) // Same Name but not Equal == Different ReturnType
                {
                    return null;
                }
                if ( zCmp > 0 ) // zAccessor > pThemAccessor
                {
                    pThru = pAt - 1;
                }
                else // zAccessor < pThemAccessor
                {
                    pFrom = pAt + 1;
                }
                if ( pFrom > pThru )
                {
                    return null;
                }
                pAt = (pFrom + pThru) / 2; // hopefully optimized to a simple shift!
            }
            return zAccessor;
        }
    }

    private static final class Accessor implements Comparable<Accessor>
    {
        private String mGetterName;
        private Method mMethod;
        private Class mReturnType;

        public Accessor( String pGetterName, Method pMethod )
        {
            mGetterName = pGetterName;
            mReturnType = (mMethod = pMethod).getReturnType();
        }

        public String getGetterName()
        {
            return mGetterName;
        }

        public Object getValue( Object o )
                throws RuntimeReflectionException
        {
            try
            {
                return mMethod.invoke( o );
            }
            catch ( IllegalAccessException e )
            {
                throw new RuntimeReflectionException( e );
            }
            catch ( InvocationTargetException e )
            {
                throw new RuntimeReflectionException( e );
            }
            catch ( RuntimeException e )
            {
                throw new RuntimeReflectionException( e );
            }
        }

        @Override
        public int compareTo( Accessor them )
        {
            return this.mGetterName.compareTo( them.mGetterName );
        }

        public boolean equals( Accessor them )
        {
            return (this == them) || ((them != null) //
                                      && this.mGetterName.equals( them.mGetterName ) //
                                      && this.mReturnType.equals( them.mReturnType ));
        }

        @Override
        public boolean equals( Object obj )
        {
            return (this == obj) || ((obj instanceof Accessor) && equals( (Accessor) obj ));
        }

        @Override
        public int hashCode()
        {
            return mGetterName.hashCode();
        }
    }
}