package pkg_graphique;

import java.io.File;
import java.io.FileNotFoundException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Scanner;

/**
 * Classe utilitaire pour des tests utilisant la reflection
 * @author Denis BUREAU
 * @version 2010.03.14
 * TODO: pb avec annotations dans isMethodP()
 */
public class TestUtil
{
  
  public static boolean isConstantInt( Field pF, String pL, String pT, String pN, int pV )
  {
    boolean vR;
    try {
      pF.setAccessible(true); // in case of private
      vR= isField( pF, pL, pT, pN )
          && pV == ((Integer)(pF.get( null ))).intValue();
    }
    catch ( IllegalAccessException iae ) { // valeur non accessible
      System.out.println( "pb d'acces a la constante"+pN );
      vR= false;
//       String vName= pF.getDeclaringClass().getSimpleName() + ".java";
//       Scanner vSc= null;
//       try {
//         vSc= new Scanner( new File( vName ) );
//         while ( vSc.hasNext() && !vR ) {
//           String vWord= vSc.next();
//           if ( vWord.equals( "@Override" ) && vSc.hasNext() ) {
//             vWord= vSc.next();
//             System.out.println( "[2:" + vWord + "]" );
//           } // if pT
//         } // while
//       }
//       catch ( FileNotFoundException fnfe ) {
//         System.out.println( "isConstantInt: " + vName + " not found !" );
//       }
//       finally {
//         if ( vSc != null )
//           vSc.close();
//       }
    } // catch
    return vR;
  } // isConstantInt()

  public static boolean isField( Field pF, String pL, String pT, String pN )
  { // pUblic prOtected pAckage prIvate ou anyProtection
    return hasModifiers( pF, pL ) && pF.getType().getSimpleName().equals( pT )
        && pF.getName().equals( pN );
  } // isField()

  public static boolean isConstructor( Constructor pC, String pL, int pN )
  { // pUblic prOtected pAckage prIvate ou anyProtection
    return hasModifiers( pC, pL ) && pC.getParameterTypes().length == pN;
  } // isConstructor()

  public static boolean isMethod( Method pM, String pL, String pN, int pP )
  { // pUblic prOtected pAckage prIvate ou anyProtection
    return hasModifiers( pM, pL ) && pM.getName().equals( pN )
        && pM.getParameterTypes().length == pP;
  } // isMethod()

  public static boolean isMethodP( Method pM, String pL, String pT, String pN, String[] pP )
  { // pUblic prOtected pAckage prIvate ou anyProtection
    boolean vR;
    vR = pM.getName().equals( pN );
    if ( pL.contains( "r" ) ) {
//       vR = vR && (pM.getAnnotation( Override.class ) != null);
//       System.out.println(java.util.Arrays.toString(pM.getDeclaredAnnotations()));
      pL = pL.replace( "r", "" );
    } // r
    vR = vR && hasModifiers( pM, pL );
    vR = vR && pM.getReturnType().getName().equals( pT );
    Class[] vP = pM.getParameterTypes();
    vR = vR && (vP.length == pP.length);
    for ( int vI=0; vI<vP.length; vI++ ) {
      vR = vR && vP[vI].getSimpleName().equals( pP[vI] );
    } // for
    return vR;
  } // isMethodP()

  public static boolean hasConstantInt( Class pC, String pL, String pT, String pN, int pV )
  { // pUblic prOtected pAckage prIvate ou anyProtection
    for ( Field vF : pC.getDeclaredFields() ) {
      if ( isConstantInt( vF, pL, pT, pN, pV ) )
        return true;
    } // for
    return false;
  } // hasConstant()

  public static boolean hasField( Class pC, String pL, String pT, String pN )
  { // pUblic prOtected pAckage prIvate ou anyProtection
    for ( Field vF : pC.getDeclaredFields() ) {
      if ( isField( vF, pL, pT, pN ) )
        return true;
    } // for
    return false;
  } // hasField()

  public static boolean hasConstructor( Class pC, String pL, int pN )
  { // pUblic prOtected pAckage prIvate ou anyProtection
    for ( Constructor vC : pC.getDeclaredConstructors() ) {
      if ( isConstructor( vC, pL, pN ) )
        return true;
    } // for
    return false;
  } // hasConstructor()

  public static boolean hasMethod( Class pC, String pL, String pN, int pP )
  { // pUblic prOtected pAckage prIvate ou anyProtection
    for ( Method vM : pC.getDeclaredMethods() ) {
      if ( isMethod( vM, pL, pN, pP ) )
        return true;
    } // for
    return false;
  } // hasMethod()

  public static boolean hasMethodP( Class pC, String pL, String pT, String pN, String[] pP )
  { // pUblic prOtected pAckage prIvate ou anyProtection
    for ( Method vM : pC.getDeclaredMethods() ) {
      if ( isMethodP( vM, pL, pT, pN, pP ) )
        return true;
    } // for
    return false;
  } // hasMethodP()

  public static boolean hasModifiers( Field pF, String pL )
  { // pUblic prOtected pAckage prIvate ou anyProtection
    boolean vR= true;
    int vM= pF.getModifiers();
    if ( !pL.contains( "p" ) ) {
      if ( Modifier.isPublic( vM ) )
        vR= vR && pL.contains( "u" );
      if ( Modifier.isProtected( vM ) )
        vR= vR && pL.contains( "o" );
      if ( Modifier.isPrivate( vM ) )
        vR= vR && pL.contains( "i" );
      if ( !Modifier.isPublic( vM ) && !Modifier.isProtected( vM )
          && !Modifier.isPrivate( vM ) )
        vR= vR && pL.contains( "a" );
    } //if
    if ( pL.contains( "f" ) )
      vR= vR && Modifier.isFinal( vM );
    if ( pL.contains( "s" ) )
      vR= vR && Modifier.isStatic( vM );
    return vR;
  } // hasModifiers()

  public static boolean hasModifiers( Constructor pC, String pL )
  { // pUblic prOtected pAckage prIvate ou anyProtection
    boolean vR= true;
    int vM= pC.getModifiers();
    if ( !pL.contains( "p" ) ) {
      if ( Modifier.isPublic( vM ) )
        vR= vR && pL.contains( "u" );
      if ( Modifier.isProtected( vM ) )
        vR= vR && pL.contains( "o" );
      if ( Modifier.isPrivate( vM ) )
        vR= vR && pL.contains( "i" );
      if ( !Modifier.isPublic( vM ) && !Modifier.isProtected( vM )
          && !Modifier.isPrivate( vM ) )
        vR= vR && pL.contains( "a" );
    } //if
    return vR;
  } // hasModifiers()

  public static boolean hasModifiers( Method pM, String pL )
  { // pUblic prOtected pAckage prIvate ou anyProtection
    boolean vR= true;
    int vM= pM.getModifiers();
    if ( !pL.contains( "p" ) ) {
      if ( Modifier.isPublic( vM ) )
        vR= vR && pL.contains( "u" );
      if ( Modifier.isProtected( vM ) )
        vR= vR && pL.contains( "o" );
      if ( Modifier.isPrivate( vM ) )
        vR= vR && pL.contains( "i" );
      if ( !Modifier.isPublic( vM ) && !Modifier.isProtected( vM )
          && !Modifier.isPrivate( vM ) )
        vR= vR && pL.contains( "a" );
    } //if
    if ( pL.contains( "f" ) )
      vR= vR && Modifier.isFinal( vM );
    if ( pL.contains( "s" ) )
      vR= vR && Modifier.isStatic( vM );
    return vR;
  } // hasModifiers()

  public static boolean hasMethodOver( Class pC, String pN, int pP )
  {
      String vName= pC.getSimpleName() + ".java";
      
      for ( Method vM : pC.getDeclaredMethods() ) {
        if ( isMethod( vM, "p", pN, pP ) ) {
          boolean vR =false;
          Scanner vSc= null;
          try {
            vSc= new Scanner( new File( "pkg_graphique/" + vName ) );
            while ( vSc.hasNext() && !vR ) {
              String vWord= vSc.next();
              if ( vWord.equals( "@Override" ) ) {
                vWord= vSc.next(); // access
                vWord= vSc.next(); // return type
                vWord= vSc.next(); // method name
                int vI = vWord.indexOf( "(" );
                if ( vI > 0 ) {
                  vWord= vWord.substring( 0, vI );
                } // if
                if ( vWord.equals( pN ) )   return true;
                //return true;
              } // if @Override
            } // while
          }
          catch ( FileNotFoundException fnfe ) {
            System.err.println( "hasMethodOver: " + vName + " not found !?" );
          }
          catch ( Exception e ) {
            System.err.println( "hasMethodOver: syntaxe incorrecte !" );
          }
          finally {
            if ( vSc != null )   vSc.close();
          } // finally
        } // if
      } // for

      return false;
  } // hasMethodOver()
} // TestUtil