content: /*
   * Copyright (C) 2013 4th Line GmbH, Switzerland
   *
   * The contents of this file are subject to the terms of either the GNU
   * Lesser General Public License Version 2 or later ("LGPL") or the
   * Common Development and Distribution License Version 1 or later
   * ("CDDL") (collectively, the "License"). You may not use this file
   * except in compliance with the License. See LICENSE.txt for more
   * information.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   */
  
  package org.fourthline.cling.model.action;
  
  import org.fourthline.cling.model.Command;
  import org.fourthline.cling.model.ServiceManager;
  import org.fourthline.cling.model.meta.Action;
  import org.fourthline.cling.model.meta.ActionArgument;
  import org.fourthline.cling.model.meta.LocalService;
  import org.fourthline.cling.model.state.StateVariableAccessor;
  import org.fourthline.cling.model.types.ErrorCode;
  import org.fourthline.cling.model.types.InvalidValueException;
  import org.seamless.util.Exceptions;
  
  import java.util.HashMap;
  import java.util.Map;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  /**
   * Shared procedures for action executors based on an actual service implementation instance.
   *
   * @author Christian Bauer
   */
  public abstract class AbstractActionExecutor implements ActionExecutor {
  
      private static Logger log = Logger.getLogger(AbstractActionExecutor.class.getName());
  
      protected Map<ActionArgument<LocalService>, StateVariableAccessor> outputArgumentAccessors =
          new HashMap<>();
  
      protected AbstractActionExecutor() {
      }
  
      protected AbstractActionExecutor(Map<ActionArgument<LocalService>, StateVariableAccessor> outputArgumentAccessors) {
          this.outputArgumentAccessors = outputArgumentAccessors;
      }
  
      public Map<ActionArgument<LocalService>, StateVariableAccessor> getOutputArgumentAccessors() {
          return outputArgumentAccessors;
      }
  
      /**
       * Obtains the service implementation instance from the {@link org.fourthline.cling.model.ServiceManager}, handles exceptions.
       */
      public void execute(final ActionInvocation<LocalService> actionInvocation) {
  
          log.fine("Invoking on local service: " + actionInvocation);
  
          final LocalService service = actionInvocation.getAction().getService();
  
          try {
  
              if (service.getManager() == null) {
                  throw new IllegalStateException("Service has no implementation factory, can't get service instance");
              }
  
              service.getManager().execute(new Command() {
                  public void execute(ServiceManager serviceManager) throws Exception {
                      AbstractActionExecutor.this.execute(
                              actionInvocation,
                              serviceManager.getImplementation()
                      );
                  }
  
                  @Override
                  public String toString() {
                      return "Action invocation: " + actionInvocation.getAction();
                  }
              });
  
          } catch (ActionException ex) {
              if (log.isLoggable(Level.FINE)) {
                  log.fine("ActionException thrown by service, wrapping in invocation and returning: " + ex);
                  log.log(Level.FINE, "Exception root cause: ", Exceptions.unwrap(ex));
              }
              actionInvocation.setFailure(ex);
          } catch (InterruptedException ex) {
              if (log.isLoggable(Level.FINE)) {
                  log.fine("InterruptedException thrown by service, wrapping in invocation and returning: " + ex);
                  log.log(Level.FINE, "Exception root cause: ", Exceptions.unwrap(ex));
              }
              actionInvocation.setFailure(new ActionCancelledException(ex));
          } catch (Throwable t) {
              Throwable rootCause = Exceptions.unwrap(t);
              if (log.isLoggable(Level.FINE)) {
                  log.fine("Execution has thrown, wrapping root cause in ActionException and returning: " + t);
                  log.log(Level.FINE, "Exception root cause: ", rootCause);
              }
              actionInvocation.setFailure(
                  new ActionException(
                      ErrorCode.ACTION_FAILED,
                      (rootCause.getMessage() != null ? rootCause.getMessage() : rootCause.toString()),
                      rootCause
                  )
              );
          }
      }
  
      protected abstract void execute(ActionInvocation<LocalService> actionInvocation, Object serviceImpl) throws Exception;
  
      /**
       * Reads the output arguments after an action execution using accessors.
       *
       * @param action The action of which the output arguments are read.
       * @param instance The instance on which the accessors will be invoked.
       * @return <code>null</code> if the action has no output arguments, a single instance if it has one, an
       *         <code>Object[]</code> otherwise.
       * @throws Exception
       */
      protected Object readOutputArgumentValues(Action<LocalService> action, Object instance) throws Exception {
          Object[] results = new Object[action.getOutputArguments().length];
          log.fine("Attempting to retrieve output argument values using accessor: " + results.length);
  
          int i = 0;
          for (ActionArgument outputArgument : action.getOutputArguments()) {
              log.finer("Calling acccessor method for: " + outputArgument);
  
              StateVariableAccessor accessor = getOutputArgumentAccessors().get(outputArgument);
              if (accessor != null) {
                  log.fine("Calling accessor to read output argument value: " + accessor);
                  results[i++] = accessor.read(instance);
              } else {
                  throw new IllegalStateException("No accessor bound for: " + outputArgument);
              }
          }
  
          if (results.length == 1) {
              return results[0];
          }
          return results.length > 0 ? results : null;
      }
  
      /**
       * Sets the output argument value on the {@link org.fourthline.cling.model.action.ActionInvocation}, considers string conversion.
       */
      protected void setOutputArgumentValue(ActionInvocation<LocalService> actionInvocation, ActionArgument<LocalService> argument, Object result)
              throws ActionException {
  
          LocalService service = actionInvocation.getAction().getService();
  
          if (result != null) {
              try {
                  if (service.isStringConvertibleType(result)) {
                      log.fine("Result of invocation matches convertible type, setting toString() single output argument value");
                      actionInvocation.setOutput(new ActionArgumentValue(argument, result.toString()));
                  } else {
                      log.fine("Result of invocation is Object, setting single output argument value");
                      actionInvocation.setOutput(new ActionArgumentValue(argument, result));
                  }
              } catch (InvalidValueException ex) {
                  throw new ActionException(
                          ErrorCode.ARGUMENT_VALUE_INVALID,
                          "Wrong type or invalid value for '" + argument.getName() + "': " + ex.getMessage(),
                          ex
                  );
              }
          } else {
  
              log.fine("Result of invocation is null, not setting any output argument value(s)");
          }
  
      }
  
  }
  