package fr.imag.reflect ;

import java.util.* ;
import java.lang.reflect.* ;
import java.io.File;

/**
 * Classe utilitaire fournissant des fonctions utiles pour manipuler la notion
 * de paquetage. Cette classe permet de palier les manques de la classe 
 * java.lang.Package. Les paquetages accessibles sont ceux accessibles a partir
 * du classpath. ATTENTION: dans l'implementation actuelle seuls les noms de
 * repertoires sont pris en compte dans le classpath ; les archives .jar et .zip
 * sont ignores.
**/
public class Package {

    /**
     * La liste des repertoires correspondant au classpath.
     **/
    private static List/*<String!>!*/ rootDirectories ;
	
    public static void setClassPath( String/*!*/ path )  {
        // Initialise la liste des répertoires à partir du path donné en paramètre
        // en ne prenant en compte que les éléments correspondant à des
        // répertoires (les fichiers .jar ou .zip sont ignorés).
        rootDirectories = new ArrayList() ;
        StringTokenizer tok = new  StringTokenizer(path,""+File.pathSeparatorChar) ;
        while (tok.hasMoreTokens()) {
            String pathElement = tok.nextToken()  ;
            File file = new File(pathElement) ;
            if (file.isDirectory())  {
                rootDirectories.add(pathElement) ;
            } else  {
                System.err.println("WARNING: "+pathElement+" is not a directory: ignored" ) ;
            }
        }
    }

    static {
        // Par default initialise le path a partir du classpath
        setClassPath( System.getProperty("java.class.path")) ;
    }
	
    /**
     * Indique si le repertoire specifie correspond a un paquetage java.
     * C'est le cas si est seulement si il contient au moins une classe
     * java.
     * @param directory le repertoire a analyser
     * @return vrai si le repertoire existe et contient au moins un fichier
     * correspondant a une classe java.
     **/
    private static boolean isPackageDirectory( File/*!*/ directory )  {
        // A COMPLETER
        return false ;
    }
	
    /**
     * Retourne les repertoires racines contenant un nom de paquetage donne.
     * Le resultat est une liste dans la mesure ou un meme paquetage peut
     * apparaitre dans plusieurs repertoires racines differents. L'ordre
     * correspond a l'ordre du classpath.
     * @param packagename le nom du paquetage recherche
     * @result les repertoire racines contenant ce paquetage dans le meme
     * ordre que celui specifie dans le classpath
     **/
    private static List/*<File!>!*/ getPackageRootDirectories( String/*!*/ packagename )  {
        // A COMPLETER
	
        // Recherche dans la liste  de repertoire "rootDirectories"
        // les differents repertoires racines contenant le paquetage correspondant.
        // Il s'agit de convertir le nom de paquetage en nom de fichier et
        // d'essayer, pour chaque repertoire racine, de voir si le paquetage
        // est present. On pourra utiliser la methode isPackageDirectory.
        // Pour constituer un nom de fichier independant de la plateforme utilise
        // on utilisera la constante  File.separatorChar.
		 
        return null ; 
    }
	
	
    /**
     * Retourne, pour un nom de paquetage donne, l'ensemble des classes definies
     * dans ce paquetage ou l'ensemble vide si le nom specifie ne correspond pas
     * a un paquetage existant.
     * @param packagename le nom du paquetage a analyser
     * @return l'ensemble des classes definies dans le paquetage specifie
    **/
    public static Set/*<java.lang.Class!>!*/ getClasses( String/*!*/ packagename ) {
        // A COMPLETER
		
        // Utiliser la methode getPackageRootDirectories
        // Se baser sur le code developpe dans le cadre de CLASSVIEW pour
        // determiner les classes se trouvant dans le paquetage specifie.
        return null ;
    }
	
    /**
     * Retourne, pour un nom de paquetage donne, l'ensemble des classes references
     * par ce paquetage ou l'ensemble vide si le nom specifie ne correspond pas
     * a un paquetage existant.
     * @param packagename le nom du paquetage a analyser
     * @return l'ensemble des classes definies dans le paquetage specifie
    **/
    public static Set/*<java.lang.Class!>!*/ getReferencedClasses( String/*!*/ packagename )  {
        // A COMPLETER
        // Utiliser la methode Class.getReferencedClasses
        return null ;
    }
	
    public static Set/*<String!>!*/ getReferencedPackages( String/*!*/ packagename )
	                         throws  IllegalArgumentException  {
        // A COMPLETER
        // Utiliser la methode getReferencedClasses definies ci-dessus
        return null ;
    }
	
    /**
     * Retourne la liste des noms de paquetages connus (accessibles dans le classpath).
    **/
    public static Set/*<String!>!*/ getPackages()  {
        // A COMPLETER
	
        // Explore de maniere recursive chaque repertoire racine et verifie
        // a chaque fois s'il s'agit d'un repertoire correspondant a un paquetage
        // (utiliser isPackageDirectory)
        return null ;
    }
	
}