package wrapper;

import java.rmi.*;
import java.rmi.server.*;
import java.util.*;
import cpam_rmi.*;
import convert.*;

public class RMI_CPAM_V2_0 extends CPAMInterface 
         implements ChaimsCompliantObject {

  HashMap clientIds = new HashMap(); //This HashMap is needed because
    // this wrapper provides itself the connection Ids, yet this CPAM protocol
    // also gives a client Id, so we have to map these Ids here. 
    // Keys: Strings from client, Values: Integers from Megamodule
    
  private int paramtype; // 1 for String, 2 for Gentype
    
  public RMI_CPAM_V2_0(String paramType, String megamodulename)  throws RemoteException {
    super(paramType, megamodulename);
    if (paramType.equals("String")) paramtype=1;
    else if (paramType.equals("Gentype")) paramtype=2;
    else throw new RuntimeException("Cannot handle parameters of type "+paramType);
  }

    //********************** start up server **********************

  public static void main(String[] args) {
  // do I really need one?  System.setSecurityManager(new RMISecurityManager());
    String registryname;
    try {
      if (args.length < 2) {
        System.out.println("Choose the parameter type for CPAM (String or Gentype) " +
           "and provide class name of megamodule (must be a subclass of CPAMMegamodule). "+
                "Optionally choose a registry name for the megamodule as third argument.");
        System.exit(0);
      }
      RMI_CPAM_V2_0 server = new RMI_CPAM_V2_0(args[0],args[1]); 
      System.out.println ("Megamodule instance for " + args[1] + " created");     
      if (args.length >=3) registryname=args[2]; else registryname=args[1]; 
      Naming.rebind(registryname, server);
      System.out.println ("Megamodule instance registered under the name "
            + registryname);
      server.test();
    }
    catch (Exception e) {System.out.println("I1: "+e.getMessage());
                  e.printStackTrace(); System.exit(0);}
  }
 
        
    //********************** testRMI**********************
 public String testRMI() {
   System.err.println("testRMI is not implemented");
   return "This is a string!";
 }
 
        
    //********************** SETUP **********************

  public void SETUP(String clientID)
       throws RemoteException {      
    // IN clientID: ID of the calling megaprogram
    try{
      Integer conid = m.createConnection();
      clientIds.put(clientID, conid);
      System.out.println("New connection with number "+conid.toString()+" created");
    } catch (Exception e) {System.err.println("I2: "+e.getMessage());e.printStackTrace();}
  }



  //********************** INVOKE *********************

  public long INVOKE(String clientID,
		     String methodName, 
                     ChaimsAttrValContainer attrValContainer)
       throws RemoteException{      
    // IN clientID : ID of the calling megaprogram 
    // IN methodName: name of the method to be invoked. Valid method names are given by
    //                the repository.
    // IN cont: list of name-value pairs that are the invocation-specific parameters for
    //          this invocation. Valid names are given by the repository.
    // OUT long: callID by which this invocation can be referenced later on until it
    //           gets terminated   
    try{
      ChaimsAttrValObject attrval;
      Object param;
      Invocation inv = m.getConnection((Integer)clientIds.get(clientID)).createInvocation(methodName);
      int num = attrValContainer.getNumAttrValObject();
      for (int i=0; i<num; i++) {
        attrval = attrValContainer.getAttrValObject(i);
        if (paramtype==1) param=new String(attrval.getVal());
        else param=Gentype.convertToGentype(attrval.getVal());
        inv.initParam(attrval.getName(), param);
      }
      inv.startExecution();
      return inv.getInvocationId().longValue();
    } catch (Exception e) {System.err.println("I3: "+e.getMessage()); 
             e.printStackTrace();return -1;}
  }  

 
  //********************** EXAMINE ******************** 

  public ChaimsInvokeStatus EXAMINE(long callID, String paramname)
       throws RemoteException{
    // IN callID: reference of the invocation to be investigated
    // IN paramname: name of the parameter for which status is asked for, if 
    //      the string is empty, the examine is done on the invocation
    // OUT ChaimsInvokeStatus: status and progress of this invocation
    ChaimsInvokeStatus returnstatus = new ChaimsInvokeStatus();
    try{
    Integer id= new Integer((int)callID);
    try {
      Invocation inv = m.getInvocation(id);
      if (paramname.equals("") ) {
        InvocationStatus invs = inv.status();
        returnstatus.progress = (int) invs.progress;
        if (invs.status.equals("NOT_DONE")) returnstatus.status = 1;
        else if (invs.status.equals("DONE")) returnstatus.status = 2;
        else if (invs.status.equals("PARTIAL")) returnstatus.status = 3;
        else returnstatus.status = 5;
      }
      else {
        ResultStatus ress = inv.getParamStatus (paramname);
        returnstatus.progress = (int) ress.accuracy;
        if (ress.status.equals("NOT_DONE")) returnstatus.status = 1;
        else if (ress.status.equals("DONE")) returnstatus.status = 2;
        else if (ress.status.equals("PARTIAL")) returnstatus.status = 3;
        else returnstatus.status = 5;
      }
    }
    catch (InvalidInvocationIdException ie) {returnstatus.status = 0;}
    } catch (Exception e) {System.err.println("I4: "+e.getMessage());e.printStackTrace();}
    finally {return returnstatus;}
  }
             
      
  //********************** ESTIMATE ******************* 
       
  public ChaimsAttrValContainer ESTIMATE(String clientID, String methodName,
          ChaimsAttrSequence seq ) throws RemoteException{ 
    // IN clientID: ID of the calling client
    // IN methodName: name of the method for which an estimate is asked for
    // IN seq: list of names of those attributes asked for; valid names are: "fee", "time", "datavolume"
    // OUT ChaimsAttrValContainer: list of (name, value) pairs, where the names correspond to those in >>seq<< and the values are
    //                             the corresponding computed ones or being
    //                             -1 for fee, -1 for time, and -1 for volume, if no estimate is possible.
    ChaimsAttrValContainer returnresults = new ChaimsAttrValContainer();
    try{
    Integer id= (Integer)clientIds.get(clientID);
    Estimates est = new Estimates(); //automatically sets defaultvalues
    est.timeRequired = seq.isIncluded("time");
    est.feeRequired = seq.isIncluded("fee");
    est.datavolumeRequired = seq.isIncluded("datavolume");
    m.getConnection(id).getEstimates(methodName, est);  
    if (paramtype==1) {
      if (est.timeRequired) returnresults.addAttrValObject(new ChaimsAttrValObject(
         "time", Integer.toString(est.timeValue).getBytes()));
      if (est.feeRequired) returnresults.addAttrValObject(new ChaimsAttrValObject( 
         "fee", Integer.toString(est.feeValue).getBytes()));
      if (est.datavolumeRequired) returnresults.addAttrValObject(new ChaimsAttrValObject( 
         "datavolume", Integer.toString(est.datavolumeValue).getBytes()));
    }
    else if (paramtype == 2) {  //we have to convert to gentype-blobs
      if (est.timeRequired) returnresults.addAttrValObject(new ChaimsAttrValObject(
         "time", SimpleConvert.intToBlob("Time for "+methodName, est.timeValue)));
      if (est.feeRequired) returnresults.addAttrValObject(new ChaimsAttrValObject( 
         "fee", SimpleConvert.intToBlob("Fee for "+methodName, est.feeValue)));
      if (est.datavolumeRequired) returnresults.addAttrValObject(new ChaimsAttrValObject( 
         "datavolume", SimpleConvert.intToBlob("Datavolume for "+methodName, est.datavolumeValue)));      
    }
    } catch (Exception e) {System.err.println("I5: "+e.getMessage());e.printStackTrace();}
    return returnresults;
  }


  
  
  //********************** EXTRACT ******************** 
  
  public ChaimsAttrValContainer EXTRACT(long callID, ChaimsAttrSequence seq )
       throws RemoteException{
    // IN callID: reference of the invocation from which we want the results
    // IN seq: list of names. The names tell the megamodule which results are requested.
    // OUT ChaimsAttrValContainer: list of (name, value) pairs, where the names correspond to those in >>seq<< and the values are
    //                             the corresponding result values
    //                             If a value is not yet available, an empty value is returned 
    ChaimsAttrValContainer cont = new ChaimsAttrValContainer();
    Object param;
    byte[] blob;
    try{
      Invocation inv = m.getInvocation(new Integer((int)callID));
      int num = seq.getNumAttr();
      for (int i=0; i<num; i++) {
        try { 
          param = inv.getParam(seq.getAttr(i));
          if (paramtype==1) blob = ((String)param).getBytes();
          else blob = ((Gentype)param).convertToBlob();
          cont.addAttrValObject(new ChaimsAttrValObject( seq.getAttr(i), blob));
        }
        catch (ParameterNameException e) {System.err.println("I6: "+seq.getAttr(i) +
           " is invalid parameter name.");}
      }
    } catch (Exception e) {System.err.println("I7: "+e.getMessage());e.printStackTrace();}
    return cont;
  }
    
    
  //********************** TERMINATE ******************** 

  public void TERMINATE(long callID)
       throws RemoteException{
    // IN callID: reference of the invocation that is no longer needed.
    try{
      m.getInvocation(new Integer((int)callID)).terminate();
    } catch (Exception e) {System.err.println("I8: "+e.getMessage());e.printStackTrace();}
  }
  

  //********************** TERMINATEALL ***************** 

  public void TERMINATEALL(String clientID)
       throws RemoteException{
    // IN clientID: ID of the calling megaprogram which is no more interested in
    //              this megamodule. All invocations belonging to this megaprogram are
    //              terminated
    try{
      m.getConnection((Integer)clientIds.get(clientID)).terminate();
      System.out.println("Connection with number " +
           ((Integer)clientIds.get(clientID)).toString() + " terminated");
      clientIds.remove(clientID);
    } catch (Exception e) {System.err.println("I9: "+e.getMessage());e.printStackTrace();}
  }
  
    
  //********************** GETPARAM ********************* 

  public ChaimsAttrValContainer GETPARAM(String clientID, ChaimsAttrSequence seq )
       throws RemoteException {
    // IN clientID: ID of the calling client
    // IN seq: list of name-value pairs. The names are a subset of the parameters and global variables
    //     available in this megamodule (for valid names see repository).
    // OUT ChaimsAttrValContainer:  list of (name, value) pairs, where the names correspond to those in >>seq<< and the values contain
    //                              the corresponding current
    //                              settings for the calling megaprogram. If no client-specific settings
    //                              have been made yet, default values (for the megamodule itself) are returned.
    ChaimsAttrValContainer cont = new ChaimsAttrValContainer();
    Object param;
    byte[] blob;
    try{
      Connection   con = m.getConnection((Integer)clientIds.get(clientID));
      int num = seq.getNumAttr();
      for (int i=0; i<num; i++) {
        try { 
          param = con.getParam(seq.getAttr(i));
          if (paramtype==1) blob = ((String)param).getBytes();
          else  blob = ((Gentype)param).convertToBlob();
          cont.addAttrValObject(new ChaimsAttrValObject( seq.getAttr(i), blob));
        }
        catch (ParameterNameException e) {System.err.println("I10: "+seq.getAttr(i) +
              " is invalid parameter name.");}
      }
    } catch (Exception e) {System.err.println("I11: "+e.getMessage());e.printStackTrace();}
    return cont;
  }  




  //********************** SETPARAM ******************** 

  public void SETPARAM( String clientID, ChaimsAttrValContainer cont )
       throws RemoteException {
    // IN clientID: ID of the calling megaprogram
    // IN cont: list of name-value pairs containing the parameters of global
    //          variables that should be specified megamodule-specific. This
    //          specification overrides general default-settings and will be
    //          used by INVOKE's whenever no invocation specific values are
    //          given.
    try{
      ChaimsAttrValObject attrval;
      Object param;
      Connection con = m.getConnection((Integer)clientIds.get(clientID));
      int num = cont.getNumAttrValObject();
      for (int i=0; i<num; i++) {
        attrval = cont.getAttrValObject(i);
        if (paramtype==1) param=new String(attrval.getVal());
        else  param = Gentype.convertToGentype(attrval.getVal());
        con.updateParam(attrval.getName(), param);
      }
    } catch (Exception e) {System.err.println("I12: "+e.getMessage());e.printStackTrace();}
  }         
         
         
}