/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */


package org.apache.ode.jca.server.rmi;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.WeakHashMap;

import org.apache.ode.jca.server.Interaction;
import org.apache.ode.ra.transports.rmi.OdeTransportPipeRemote;
import org.apache.ode.utils.Reflect;


/**
 * Implementation of an RMI-based transport pipe.
 */
class RmiPipeServerImpl implements OdeTransportPipeRemote {

  private RmiTransportServerImpl _server;
  private String[] _connectionClass;
  private HashMap<String,Method> _methodMap = new HashMap<String,Method>();

  final long createTime = System.currentTimeMillis();
  long lastActivityTime = createTime;

  OdeTransportPipeRemote remote;
  Object target;
  private WeakHashMap<Object,RmiPipeServerImpl> _interactions = new WeakHashMap<Object,RmiPipeServerImpl>();

  /** Constructor. */
  public RmiPipeServerImpl(RmiTransportServerImpl server, Object target, String[] connectionClass) {
    _server = server;
    _connectionClass = connectionClass;
    
    ArrayList<String> connectionClassNames = new ArrayList<String>();
    for (String cn : connectionClass)
      connectionClassNames.add(cn);
    
    for (Class i : target.getClass().getInterfaces()) {
//      if (!connectionClassNames.contains(i.getName()))
//        continue;
      for (Method m : i.getMethods()) 
        _methodMap.put(Reflect.generateMethodSignature(m),m);
    }
    this.target = target;
  }

  public void close() {
    _server.pipeClosed(this);
    remote = null;
  }

  public String[] getConnectionClassNames() {
    return _connectionClass;
  }

  public Object invokeConnectionMethod(String name, Object[] args) throws RemoteException, InvocationTargetException {
    lastActivityTime = System.currentTimeMillis();
    Method m = _methodMap.get(name);

    if (m == null)
      throw new RemoteException("Unknown method: " + name);
    
    ClassLoader old = Thread.currentThread().getContextClassLoader();
    Thread.currentThread()
          .setContextClassLoader(getClass().getClassLoader());
    try {
      Object ret = m.invoke(target,args);
      if (ret != null && ret instanceof Interaction) {
        RmiPipeServerImpl remoteProxy = _interactions.get(ret);
        if (remoteProxy != null)
          return remoteProxy;
        Class[]interfaces = ret.getClass().getInterfaces();
        String inames[] = new String[interfaces.length];
        for (int i = 0; i < interfaces.length; ++i)
          inames[i] = interfaces[i].getName();
        remoteProxy = new RmiPipeServerImpl(_server,ret, inames);
        _interactions.put(ret,remoteProxy);
        return remoteProxy;
      }
      return ret;
    } catch (IllegalArgumentException e) {
      throw new RemoteException("Illegal Argument", e);
    } catch (IllegalAccessException e) {
      throw new RemoteException("Illegal Access", e);
    } catch (InvocationTargetException e) {
      throw e;
    } finally {
      Thread.currentThread().setContextClassLoader(old);
    }
  }
}