package fr.lifl.stc.stan.tools;


	import java.io.IOException;

	import org.apache.bcel.classfile.Attribute;
	import org.apache.bcel.classfile.ClassParser;
	import org.apache.bcel.classfile.EscapeAttribute;
	import org.apache.bcel.classfile.JavaClass;
	import org.apache.bcel.classfile.Method;
	import org.apache.bcel.generic.ConstantPoolGen;
	
	import fr.lifl.stc.stan.samples.escape.EscapeAnnotation;
	import fr.lifl.stc.stan.samples.escape.EscapePartialSignature;
	import fr.lifl.stc.stan.samples.escape.EscapePartialSignatureData;
	import fr.lifl.stc.stan.signature.Signature;
	import fr.lifl.stc.stan.signature.SignatureDictionary;

	import gnu.getopt.Getopt;
	import gnu.getopt.LongOpt;

	/**
	 * @author yann
	 */
	public class EA_Annoter {

	    private static String classfile = null;
	    
	    private static JavaClass cl = null;

	    private static SignatureDictionary dict = null;

	    private static ConstantPoolGen cpg = null;
	    
	    private static int escape_index;
	    
//	    private static int fresh_index;
	    
	    private static String output = null;
	    
	    private static boolean fresh = true;
	    
	    private static void prepareConstantPool() {
	        cpg = new ConstantPoolGen(cl.getConstantPool());

	        escape_index = cpg.addUtf8("EscapeMap");
	        
	        if(fresh)
	        	//fresh_index = 
	        		cpg.addUtf8("FreshMap");
	        
	        cl.setConstantPool(cpg.getFinalConstantPool());
	    }

	    private static void annotateEscape(Method meth, Signature sign) {
	        EscapePartialSignature esc = (EscapePartialSignature)sign.getPartialSignature(EscapeAnnotation.class.getName());
	        
	        if (esc == null) {
	            System.err.println("Unsigned escape method in " + cl.getClassName() + ": " + meth);
	            return;
	        }
	        
	        short[] offsets = ((EscapePartialSignatureData)esc.getComponent()).getData();
	        if (offsets == null) {
	            System.err.println("No escape offsets in " + meth);
	            return;
	        }
	        
	        Attribute[] orig = meth.getCode().getAttributes();
	        
	        if (offsets.length > 0) {

	            EscapeAttribute ea = new EscapeAttribute(escape_index,2*offsets.length,offsets,cl.getConstantPool());
	        
	            int j = 0;
	            while(j < orig.length) {
	                if (orig[j] instanceof EscapeAttribute)
	                    break;
	                j++;
	            }
	            if(j < orig.length) {
	                orig[j] = ea;
	                meth.getCode().setAttributes(orig);
	            } else {
	                Attribute[] new_attr = new Attribute[orig.length + 1];
	                new_attr[0] = ea;
	                System.arraycopy(orig,0,new_attr,1,orig.length);
	                meth.getCode().setAttributes(new_attr);
	            }
	        } else {
//	          maybe suppress the attribute
	            int j = 0;
	            while(j < orig.length) {
	                if (orig[j] instanceof EscapeAttribute) {
	                    break;
	                }
	                j++;
	            }
	            if(j < orig.length) {
	                Attribute[] new_attr = new Attribute[orig.length - 1];
	                if(j>0)
	                    System.arraycopy(orig,0,new_attr,0,j);
	                if(j<orig.length-1)
	                    System.arraycopy(orig,j+1,new_attr,j,orig.length-j-1);
	                meth.getCode().setAttributes(new_attr);
	            }
	        }
	    }  
	   
	    /*
	    private static void annotateFresh(Method meth, Signature sign) {
	        FreshPartialSignature fresh = (FreshPartialSignature)sign.getPartialSignature(EAFactoryAnnotation.class.getName());
	        
	        if(fresh == null)
	            fresh = (FreshPartialSignature)sign.getPartialSignature(FreshAnnotation.class.getName());
	        
	        if (fresh == null) {
	            System.err.println("Unsigned fresh method in " + cl.getClassName() + ": " + meth);
	            return;
	        }
	        
	        short[][] offsets = ((FreshPartialSignatureData)fresh.getComponent()).getData();
	        if (offsets == null) {
	            System.err.println("No fresh offsets in " + meth);
	            return;
	        }
	        
	        Attribute[] orig = meth.getCode().getAttributes();
	        
	        if (offsets.length > 0) {

	        	int l = 0;
	        	for(int i = 0; i< offsets.length; i++) {
	        		for(int j = 0; j < offsets[i].length; j++)
	        			l++;
	        	}
	            FreshAttribute fr = new FreshAttribute(fresh_index,FreshAttribute.cellSize*l,offsets,cl.getConstantPool());
	        
	            int j = 0;
	            while(j < orig.length) {
	                if (orig[j] instanceof FreshAttribute)
	                    break;
	                j++;
	            }
	            if(j < orig.length) {
	                orig[j] = fr;
	                meth.getCode().setAttributes(orig);
	            } else {
	                Attribute[] new_attr = new Attribute[orig.length + 1];
	                new_attr[0] = fr;
	                System.arraycopy(orig,0,new_attr,1,orig.length);
	                meth.getCode().setAttributes(new_attr);
	            }
	        } else {
//	          maybe suppress the attribute
	            int j = 0;
	            while(j < orig.length) {
	                if (orig[j] instanceof FreshAttribute) {
	                    break;
	                }
	                j++;
	            }
	            if(j < orig.length) {
	                Attribute[] new_attr = new Attribute[orig.length - 1];
	                if(j>0)
	                    System.arraycopy(orig,0,new_attr,0,j);
	                if(j<orig.length-1)
	                    System.arraycopy(orig,j+1,new_attr,j,orig.length-j-1);
	                meth.getCode().setAttributes(new_attr);
	            }
	        }
	    }  
	    */
	    private static void annotate() throws IOException {
	        Method[] methods = cl.getMethods();
	        for(int i = 0; i < methods.length; i++) {
	        	if(methods[i].isAbstract() || methods[i].isNative())
	        		continue;
	        	
	            Signature sign = dict.findSignature(SignatureDictionary.key(cl,methods[i]),true);
	            
	            if (sign == null) {
	                System.err.println("Unknown method in " + cl.getClassName() + ": " + methods[i]);
	                continue;
	            }
	            
	            annotateEscape(methods[i],sign);
	            //if(fresh)
	            //	annotateFresh(methods[i],sign);
	        }
	        
	        String newname = (output == null)?classfile:output;
	        cl.dump(newname);
	    }
	    
	    public static void main(String[] args) {
	        int c;
	        LongOpt[] longopts = new LongOpt[5];

	        longopts[0] = new LongOpt("help", LongOpt.NO_ARGUMENT, null, 'h');
	        longopts[1] = new LongOpt("dictionary", LongOpt.REQUIRED_ARGUMENT, null, 'd');
	        longopts[2] = new LongOpt("class", LongOpt.REQUIRED_ARGUMENT, null, 'c');
	        longopts[3] = new LongOpt("output", LongOpt.REQUIRED_ARGUMENT, null, 'o');
	        longopts[4] = new LongOpt("without-fresh", LongOpt.NO_ARGUMENT, null, 'f');
	        
	        Getopt g = new Getopt("Annoter", args, "hfd:c:o:W;", longopts);

	        try {
	            while ((c = g.getopt()) != -1)
	                switch (c) {
	                    case 'h':
//	                        printHelp();
	                        System.exit(0);
	                        break;
	                    case 'd':
	                        dict = new SignatureDictionary(g.getOptarg());
	                        break;
	                    case 'c':
	                        classfile = g.getOptarg();
	                        cl = (new ClassParser(classfile)).parse();
	                        break;
	                    case 'o':
	                        output = g.getOptarg();
	                        break;
	                    case 'f':
	                    	fresh=false;
	                    	break;
	                    case 'W':
	                        System.out.println("You tried a -W with an incorrect long option name");
	                        break;
	                    case ':':
	                        System.out.println("You need an argument for option " + (char) g.getOptopt());
	                        break;
	                    case '?':
	                        System.out.println("The option '" + (char) g.getOptopt() + "' is not valid");
	                        break;
	                    default:
	                        System.out.println("getopt(): unknown option " + c);
	                        break;
	                }

	            if (dict == null) {
	                System.err.println("You must provide a dictionary");
	                System.exit(1);
	            }

	            if (classfile == null) {
	                System.err.println("You must provide a class");
	                System.exit(1);
	            }

	            prepareConstantPool();
	            annotate();            
	            
	        } catch (ClassNotFoundException e) {
	            System.err.println("Error: Dictionary contains unknown classes");
	            System.exit(1);
	        } catch (IOException e) {
	            System.err.println("Error: Dictionary file does not exist or you don't have sufficient permission on it.");
	            System.exit(1);
	        }
	    }
	}