/*
 * Copyright 2011 JBoss, by Red Hat, Inc
 *
 * 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 org.jboss.errai.enterprise.rebind;

import java.util.Map;

import org.jboss.errai.codegen.Parameter;
import org.jboss.errai.codegen.Statement;
import org.jboss.errai.codegen.TernaryStatement;
import org.jboss.errai.codegen.Variable;
import org.jboss.errai.codegen.builder.ContextualStatementBuilder;
import org.jboss.errai.codegen.meta.MetaClass;
import org.jboss.errai.codegen.meta.MetaClassFactory;
import org.jboss.errai.codegen.util.Bool;
import org.jboss.errai.codegen.util.Stmt;
import org.jboss.errai.enterprise.client.jaxrs.MarshallingWrapper;
import org.jboss.errai.marshalling.rebind.util.MarshallingGenUtil;

/**
 * Generates the required {@link Statement}s for type marshalling.
 * 
 * @author Christian Sadilek <csadilek@redhat.com>
 */
public class TypeMarshaller {

  public static Statement marshal(Statement statement) {
    return marshal(statement, "text/plain");
  }

  public static Statement marshal(Statement statement, String contentType) {
    if (statement instanceof Parameter) {
      Parameter param = (Parameter) statement;
      return marshal(param.getType(), Variable.get(param.getName()), contentType);
    }
    return marshal(statement.getType(), statement, contentType);
  }

  public static Statement marshal(MetaClass type, Statement statement, String contentType) {
    Statement marshallingStatement = null;
    if (PrimitiveTypeMarshaller.canHandle(type, contentType)) {
      marshallingStatement = PrimitiveTypeMarshaller.marshal(type, statement);
    }
    else {
      marshallingStatement = Stmt.invokeStatic(MarshallingWrapper.class, "toJSON", statement);
    }
    return marshallingStatement;
  }

  public static Statement demarshal(MetaClass type, Statement statement, String accepts) {
    Statement demarshallingStatement = null;
    if (PrimitiveTypeMarshaller.canHandle(type, accepts)) {
      demarshallingStatement = PrimitiveTypeMarshaller.demarshal(type, statement);
    }
    else {
      if (!type.equals(MetaClassFactory.get(void.class))) {
        if (type.isAssignableTo(Map.class)) {
          demarshallingStatement =
              Stmt.invokeStatic(MarshallingWrapper.class, "fromJSON", statement, type.asBoxed().asClass(),
                  MarshallingGenUtil.getConcreteMapKeyType(type.asBoxed()),
                  MarshallingGenUtil.getConcreteMapValueType(type.asBoxed()));
        }
        else {
          demarshallingStatement = Stmt.invokeStatic(MarshallingWrapper.class, "fromJSON", statement,
              type.asBoxed().asClass(), MarshallingGenUtil.getConcreteElementType(type.asBoxed()));
        }
      }
      else {
        demarshallingStatement = Stmt.invokeStatic(MarshallingWrapper.class, "fromJSON", statement);
      }
    }
    return demarshallingStatement;
  }

  /**
   * Works for all types that have a 'copy constructor', a toString() representation and a valueOf() method (all
   * primitive wrapper types and java.lang.String). Will only be used in case text/plain was specified as mime type.
   */
  private static class PrimitiveTypeMarshaller {

    private static boolean canHandle(MetaClass type, String mimeType) {
      boolean canHandle = false;
      if (("text/plain".equals(mimeType) && type.asUnboxed().isPrimitive())
          || type.equals(MetaClassFactory.get(String.class))) {
        canHandle = true;
      }
      return canHandle;
    }

    private static Statement marshal(MetaClass type, Statement statement) {
      if (type.equals(statement.getType())) {
        return statement;
      }
      ContextualStatementBuilder s = null;
      if (type.isPrimitive()) {
        s = Stmt.nestedCall(Stmt.newObject(type.asBoxed()).withParameters(statement)).invoke("toString");
      }
      else {
        s = Stmt.nestedCall(new TernaryStatement(Bool.isNull(statement), Stmt.load(""), Stmt.nestedCall(statement)));
        if (!type.equals(MetaClassFactory.get(String.class))) {
          s = s.invoke("toString");
        }
      }

      return s;
    }

    private static Statement demarshal(MetaClass type, Statement statement) {
      if (type.equals(statement.getType())) {
        return statement;
      }

      if (MetaClassFactory.get(void.class).equals(type)) {
        return Stmt.load(null);
      }

      return Stmt.invokeStatic(type.asBoxed(), "valueOf", statement);
    }
  }
}