/*
      Copyright 2008 Ramon Servadei
   
      Licensed 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 fulmine.rpc;
  
  import java.util.List;
  
  import fulmine.model.field.FieldUtils;
  import fulmine.model.field.IField;
  import fulmine.protocol.specification.ByteReader;
  import fulmine.protocol.specification.ByteWriter;
  import fulmine.util.Utils;
  import fulmine.util.collection.CollectionFactory;
  import fulmine.util.reference.QuadValue;
  
  /**
   * Standard implementation of an {@link IRpcCodec}. The encoding format in ABNF
   * is as follows:
   * 
   * <pre>
   * ENCODED      = MARKER &quot;|&quot; KEY ARGS
   * MARKER       = 1*DIGIT ; the RPC marker ID
   * KEY          = &quot;RpcKey&quot; (1*DIGIT) ; this is the RPC key
   * ARGS         = 0*(&quot;|&quot; ARG)
   * ARG          = 1*(ALPHA / DIGIT) ; argument values sent as their string value
   * </pre>
   * 
   * The character '|' is special, so the arguments are further encoded/decoded to
   * capture any '|' characters and replace them with '&&#124;' (i.e. & + the HTML
   * escape sequence for '|')
   * 
   * @author Ramon Servadei
   */
  public class RpcCodec implements IRpcCodec
  {
      /**
       * The name to give each re-constructed field during {@link #decode(byte[])}
       * . Field names are not part of the {@link IRpcDefinition} and don't really
       * mean much anyway so we use a single name each time with a number to
       * signify the argument's position.
       */
      static final String FIELD_NAME = "field#";
  
      /** The delimiter for the encoding format */
      private static final String DELIMITER = "|";
  
      /** The string for the escape code for the {@link #DELIMITER} */
      final static String DELIMITER_ESCAPE_CODE = "&&#124;";
  
      /** The indexes for the various parts of the encoded string for the RPC */
      private enum EncodingKeys
      {
          MARKER, RPC_KEY, REMOTE_CONTEXT, ARGS
      }
  
      /** The registry, used to find the {@link IRpcDefinition} from the RPC key */
      private final IRpcRegistry registry;
  
      /**
       * Reference to the tokens extracted from the RPC data to use for
       * {@link #getRpcKey()} and {@link #getArgs(byte[])}
       */
      private String[] rpcTokens;
  
      /**
       * This is the count of non-argument value fields (e.g. RPC name, remote
       * context, RPC marker)
       */
      private final static int META_PART_COUNT = 3;
  
      /**
       * Construct the codec with the registry.
       * 
       * @param registry
       *            the RPC definition registry
       */
      public RpcCodec(IRpcRegistry registry)
      {
          super();
          this.registry = registry;
      }
  
      public QuadValue<IRpcMarker, String, String, IField[]> decode(byte[] rpcData)
      {
          String data = ByteReader.fromBytes(rpcData);
          final String[] tokens = getTokens(data);
          IRpcMarker marker =
             new RpcMarker(
                 Integer.parseInt(tokens[EncodingKeys.MARKER.ordinal()]));
         String remoteContextIdentity =
             tokens[EncodingKeys.REMOTE_CONTEXT.ordinal()];
         final String rpcKey = tokens[EncodingKeys.RPC_KEY.ordinal()];
         IRpcDefinition definition = getRegistry().getDefinition(rpcKey);
         if (definition == null)
         {
             throw new IllegalArgumentException(
                 "No RPC definition, cannot decode '" + data + "', registry is "
                     + getRegistry());
         }
         final Class<? extends IField>[] argumentTypes =
             definition.getArgumentTypes();
 
         if (argumentTypes.length + META_PART_COUNT != tokens.length)
         {
             throw new IllegalArgumentException(
                 "Invalid argument count, expected " + argumentTypes.length
                     + " but got " + (tokens.length - META_PART_COUNT)
                     + ", cannot decode '" + data + "'");
         }
         int length = tokens.length - META_PART_COUNT;
         List<IField> argValues = CollectionFactory.newList(length);
         for (int j = 0; j < length; j++)
         {
             Class<? extends IField> argType = argumentTypes[j];
             final String fieldValue = tokens[j + META_PART_COUNT];
             // decode the '|' special char from fieldValue
             decodeSpecialChars(fieldValue);
             argValues.add(FieldUtils.createFromString(argType, FIELD_NAME + j,
                 fieldValue));
         }
         return new QuadValue<IRpcMarker, String, String, IField[]>(marker,
             rpcKey, remoteContextIdentity,
             argValues.toArray(new IField[argValues.size()]));
     }
 
     public byte[] encode(IRpcMarker rpcMarker, String rpcKey,
         String contextIdentity, IField[] args)
     {
         StringBuilder sb = new StringBuilder();
         sb.append(rpcMarker.getId());
         sb.append(DELIMITER);
         sb.append(rpcKey);
         sb.append(DELIMITER);
         sb.append(contextIdentity);
         for (IField field : args)
         {
             sb.append(DELIMITER);
             sb.append(encodeSpecialChars(field.getValueAsString()));
         }
         return ByteWriter.getBytes(sb.toString());
     }
 
     /**
      * Get the RPC key from the RPC data. The RPC data is set using
      * {@link #setData(byte[])}
      * 
      * @return the RPC key
      */
     public String getRpcKey()
     {
         Utils.nullCheck(this.rpcTokens, "no RPC tokens");
         return this.rpcTokens[EncodingKeys.RPC_KEY.ordinal()];
     }
 
     /**
      * Get the RPC arguments from the RPC data. The RPC data is set using
      * {@link #setData(byte[])}
      * 
      * @return the RPC arguments
      */
     public String[] getArgs()
     {
         Utils.nullCheck(this.rpcTokens, "no RPC tokens");
         final int length = this.rpcTokens.length - META_PART_COUNT;
         String[] args = new String[length];
         if (length > 0)
         {
             // copy only the args from the tokens, the first 3 tokens are the
             // RPC 'meta parts'
             System.arraycopy(this.rpcTokens, META_PART_COUNT, args, 0,
                 args.length);
         }
         return args;
     }
 
     /**
      * Set the RPC data to use for the {@link #getRpcKey()} and
      * {@link #getArgs()}
      * 
      * @param rpcData
      *            the RPC data in its byte form
      */
     public void setData(byte[] rpcData)
     {
         this.rpcTokens = getTokens(ByteReader.fromBytes(rpcData));
     }
 
     /**
      * Helper method to split the data into its constituent parts
      * 
      * @param data
      *            the RPC data as a string
      * @return the parts making up the RPC
      */
     private String[] getTokens(String data)
     {
         final String[] tokens = data.split("\\" + DELIMITER);
         return tokens;
     }
 
     private IRpcRegistry getRegistry()
     {
         return this.registry;
     }
 
     String decodeSpecialChars(final String value)
     {
         return value.replaceAll(DELIMITER_ESCAPE_CODE, DELIMITER);
     }
 
     String encodeSpecialChars(final String value)
     {
         return value.replaceAll("\\|", DELIMITER_ESCAPE_CODE);
     }
 
 }