/*
 * Protocol Buffers - Google's data interchange format
 * Copyright 2014 Google Inc.  All rights reserved.
 * https://developers.google.com/protocol-buffers/
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package com.google.protobuf.jruby;

import com.google.protobuf.ByteString;
import com.google.protobuf.DescriptorProtos.FieldDescriptorProto;
import com.google.protobuf.Descriptors.FieldDescriptor;
import java.math.BigInteger;
import org.jcodings.specific.ASCIIEncoding;
import org.jruby.*;
import org.jruby.exceptions.RaiseException;
import org.jruby.ext.bigdecimal.RubyBigDecimal;
import org.jruby.runtime.Block;
import org.jruby.runtime.Helpers;
import org.jruby.runtime.ThreadContext;
import org.jruby.runtime.builtin.IRubyObject;

public class Utils {
  public static FieldDescriptor.Type rubyToFieldType(IRubyObject typeClass) {
    return FieldDescriptor.Type.valueOf(typeClass.asJavaString().toUpperCase());
  }

  public static IRubyObject fieldTypeToRuby(ThreadContext context, FieldDescriptor.Type type) {
    return fieldTypeToRuby(context, type.name());
  }

  public static IRubyObject fieldTypeToRuby(ThreadContext context, FieldDescriptorProto.Type type) {
    return fieldTypeToRuby(context, type.name());
  }

  private static IRubyObject fieldTypeToRuby(ThreadContext context, String typeName) {

    return context.runtime.newSymbol(typeName.replace("TYPE_", "").toLowerCase());
  }

  public static IRubyObject checkType(
      ThreadContext context,
      FieldDescriptor.Type fieldType,
      String fieldName,
      IRubyObject value,
      RubyModule typeClass) {
    Ruby runtime = context.runtime;

    switch (fieldType) {
      case SFIXED32:
      case SFIXED64:
      case FIXED64:
      case SINT64:
      case SINT32:
      case FIXED32:
      case INT32:
      case INT64:
      case UINT32:
      case UINT64:
        if (!isRubyNum(value))
          throw createExpectedTypeError(context, "number", "integral", fieldName, value);

        if (value instanceof RubyFloat) {
          double doubleVal = RubyNumeric.num2dbl(value);
          if (Math.floor(doubleVal) != doubleVal) {
            throw runtime.newRangeError(
                "Non-integral floating point value assigned to integer field '"
                    + fieldName
                    + "' (given "
                    + value.getMetaClass()
                    + ").");
          }
        }
        if (fieldType == FieldDescriptor.Type.UINT32
            || fieldType == FieldDescriptor.Type.UINT64
            || fieldType == FieldDescriptor.Type.FIXED32
            || fieldType == FieldDescriptor.Type.FIXED64) {
          if (((RubyNumeric) value).isNegative()) {
            throw runtime.newRangeError(
                "Assigning negative value to unsigned integer field '"
                    + fieldName
                    + "' (given "
                    + value.getMetaClass()
                    + ").");
          }
        }

        switch (fieldType) {
          case INT32:
            RubyNumeric.num2int(value);
            break;
          case UINT32:
          case FIXED32:
            num2uint(value);
            break;
          case UINT64:
          case FIXED64:
            num2ulong(context.runtime, value);
            break;
          default:
            RubyNumeric.num2long(value);
            break;
        }
        break;
      case FLOAT:
        if (!isRubyNum(value))
          throw createExpectedTypeError(context, "number", "float", fieldName, value);
        break;
      case DOUBLE:
        if (!isRubyNum(value))
          throw createExpectedTypeError(context, "number", "double", fieldName, value);
        break;
      case BOOL:
        if (!(value instanceof RubyBoolean))
          throw createInvalidTypeError(context, "boolean", fieldName, value);
        break;
      case BYTES:
        value = validateAndEncodeString(context, "bytes", fieldName, value, "Encoding::ASCII_8BIT");
        break;
      case STRING:
        value =
            validateAndEncodeString(
                context, "string", fieldName, symToString(value), "Encoding::UTF_8");
        break;
      case MESSAGE:
        if (value.getMetaClass() != typeClass) {
          // See if we can convert the value before flagging it as invalid
          String className = typeClass.getName();

          if (className.equals("Google::Protobuf::Timestamp") && value instanceof RubyTime) {
            RubyTime rt = (RubyTime) value;
            RubyHash timestampArgs =
                Helpers.constructHash(
                    runtime,
                    runtime.newString("nanos"),
                    rt.nsec(),
                    false,
                    runtime.newString("seconds"),
                    rt.to_i(),
                    false);
            return ((RubyClass) typeClass).newInstance(context, timestampArgs, Block.NULL_BLOCK);

          } else if (className.equals("Google::Protobuf::Duration")
              && value instanceof RubyNumeric) {
            IRubyObject seconds;
            if (value instanceof RubyFloat) {
              seconds = ((RubyFloat) value).truncate(context);
            } else if (value instanceof RubyRational) {
              seconds = ((RubyRational) value).to_i(context);
            } else if (value instanceof RubyBigDecimal) {
              seconds = ((RubyBigDecimal) value).to_int(context);
            } else {
              seconds = ((RubyInteger) value).to_i();
            }

            IRubyObject nanos = ((RubyNumeric) value).remainder(context, RubyFixnum.one(runtime));
            if (nanos instanceof RubyFloat) {
              nanos = ((RubyFloat) nanos).op_mul(context, 1000000000);
            } else if (nanos instanceof RubyRational) {
              nanos = ((RubyRational) nanos).op_mul(context, runtime.newFixnum(1000000000));
            } else if (nanos instanceof RubyBigDecimal) {
              nanos = ((RubyBigDecimal) nanos).op_mul(context, runtime.newFixnum(1000000000));
            } else {
              nanos = ((RubyInteger) nanos).op_mul(context, 1000000000);
            }

            RubyHash durationArgs =
                Helpers.constructHash(
                    runtime,
                    runtime.newString("nanos"),
                    ((RubyNumeric) nanos).round(context),
                    false,
                    runtime.newString("seconds"),
                    seconds,
                    false);
            return ((RubyClass) typeClass).newInstance(context, durationArgs, Block.NULL_BLOCK);
          }

          // Not able to convert so flag as invalid
          throw createTypeError(
              context,
              "Invalid type "
                  + value.getMetaClass()
                  + " to assign to submessage field '"
                  + fieldName
                  + "'.");
        }

        break;
      case ENUM:
        boolean isValid =
            ((RubyEnumDescriptor) typeClass.getInstanceVariable(DESCRIPTOR_INSTANCE_VAR))
                .isValidValue(context, value);
        if (!isValid) {
          throw runtime.newRangeError("Unknown symbol value for enum field '" + fieldName + "'.");
        }
        break;
      default:
        break;
    }
    return value;
  }

  public static IRubyObject wrapPrimaryValue(
      ThreadContext context, FieldDescriptor.Type fieldType, Object value) {
    return wrapPrimaryValue(context, fieldType, value, false);
  }

  public static IRubyObject wrapPrimaryValue(
      ThreadContext context, FieldDescriptor.Type fieldType, Object value, boolean encodeBytes) {
    Ruby runtime = context.runtime;
    switch (fieldType) {
      case INT32:
      case SFIXED32:
      case SINT32:
        return runtime.newFixnum((Integer) value);
      case SFIXED64:
      case SINT64:
      case INT64:
        return runtime.newFixnum((Long) value);
      case FIXED32:
      case UINT32:
        return runtime.newFixnum(((Integer) value) & (-1l >>> 32));
      case FIXED64:
      case UINT64:
        long ret = (Long) value;
        return ret >= 0
            ? runtime.newFixnum(ret)
            : RubyBignum.newBignum(runtime, UINT64_COMPLEMENTARY.add(new BigInteger(ret + "")));
      case FLOAT:
        return runtime.newFloat((Float) value);
      case DOUBLE:
        return runtime.newFloat((Double) value);
      case BOOL:
        return (Boolean) value ? runtime.getTrue() : runtime.getFalse();
      case BYTES:
        {
          IRubyObject wrapped =
              encodeBytes
                  ? RubyString.newString(
                      runtime, ((ByteString) value).toStringUtf8(), ASCIIEncoding.INSTANCE)
                  : RubyString.newString(runtime, ((ByteString) value).toByteArray());
          wrapped.setFrozen(true);
          return wrapped;
        }
      case STRING:
        {
          IRubyObject wrapped = runtime.newString(value.toString());
          wrapped.setFrozen(true);
          return wrapped;
        }
      default:
        return runtime.getNil();
    }
  }

  public static int num2uint(IRubyObject value) {
    long longVal = RubyNumeric.num2long(value);
    if (longVal > UINT_MAX)
      throw value
          .getRuntime()
          .newRangeError("Integer " + longVal + " too big to convert to 'unsigned int'");
    long num = longVal;
    if (num > Integer.MAX_VALUE || num < Integer.MIN_VALUE)
      // encode to UINT32
      num = (-longVal ^ (-1l >>> 32)) + 1;
    RubyNumeric.checkInt(value, num);
    return (int) num;
  }

  public static long num2ulong(Ruby runtime, IRubyObject value) {
    if (value instanceof RubyFloat) {
      RubyBignum bignum = RubyBignum.newBignum(runtime, ((RubyFloat) value).getDoubleValue());
      return RubyBignum.big2ulong(bignum);
    } else if (value instanceof RubyBignum) {
      return RubyBignum.big2ulong((RubyBignum) value);
    } else {
      return RubyNumeric.num2long(value);
    }
  }

  /*
   * Helper to make it easier to support symbols being passed instead of strings
   */
  public static IRubyObject symToString(IRubyObject sym) {
    if (sym instanceof RubySymbol) {
      return ((RubySymbol) sym).id2name();
    }
    return sym;
  }

  public static void checkNameAvailability(ThreadContext context, String name) {
    if (context.runtime.getObject().getConstantAt(name) != null)
      throw context.runtime.newNameError(name + " is already defined", name);
  }

  public static boolean isMapEntry(FieldDescriptor fieldDescriptor) {
    return fieldDescriptor.getType() == FieldDescriptor.Type.MESSAGE
        && fieldDescriptor.isRepeated()
        && fieldDescriptor.getMessageType().getOptions().getMapEntry();
  }

  public static RaiseException createTypeError(ThreadContext context, String message) {
    if (cTypeError == null) {
      cTypeError = (RubyClass) context.runtime.getClassFromPath("Google::Protobuf::TypeError");
    }
    return RaiseException.from(context.runtime, cTypeError, message);
  }

  public static RaiseException createExpectedTypeError(
      ThreadContext context, String type, String fieldType, String fieldName, IRubyObject value) {
    return createTypeError(
        context,
        String.format(
            EXPECTED_TYPE_ERROR_FORMAT, type, fieldType, fieldName, value.getMetaClass()));
  }

  public static RaiseException createInvalidTypeError(
      ThreadContext context, String fieldType, String fieldName, IRubyObject value) {
    return createTypeError(
        context,
        String.format(INVALID_TYPE_ERROR_FORMAT, fieldType, fieldName, value.getMetaClass()));
  }

  protected static boolean isRubyNum(Object value) {
    return value instanceof RubyFixnum || value instanceof RubyFloat || value instanceof RubyBignum;
  }

  protected static void validateTypeClass(
      ThreadContext context, FieldDescriptor.Type type, IRubyObject value) {
    Ruby runtime = context.runtime;
    if (!(value instanceof RubyModule)) {
      throw runtime.newArgumentError("TypeClass has incorrect type");
    }
    RubyModule klass = (RubyModule) value;
    IRubyObject descriptor = klass.getInstanceVariable(DESCRIPTOR_INSTANCE_VAR);
    if (descriptor.isNil()) {
      throw runtime.newArgumentError(
          "Type class has no descriptor. Please pass a "
              + "class or enum as returned by the DescriptorPool.");
    }
    if (type == FieldDescriptor.Type.MESSAGE) {
      if (!(descriptor instanceof RubyDescriptor)) {
        throw runtime.newArgumentError("Descriptor has an incorrect type");
      }
    } else if (type == FieldDescriptor.Type.ENUM) {
      if (!(descriptor instanceof RubyEnumDescriptor)) {
        throw runtime.newArgumentError("Descriptor has an incorrect type");
      }
    }
  }

  private static IRubyObject validateAndEncodeString(
      ThreadContext context,
      String fieldType,
      String fieldName,
      IRubyObject value,
      String encoding) {
    if (!(value instanceof RubyString))
      throw createInvalidTypeError(context, fieldType, fieldName, value);

    value = ((RubyString) value).encode(context, context.runtime.evalScriptlet(encoding));
    value.setFrozen(true);
    return value;
  }

  public static final String DESCRIPTOR_INSTANCE_VAR = "@descriptor";

  public static final String EQUAL_SIGN = "=";

  private static final BigInteger UINT64_COMPLEMENTARY =
      new BigInteger("18446744073709551616"); // Math.pow(2, 64)

  private static final String EXPECTED_TYPE_ERROR_FORMAT =
      "Expected %s type for %s field '%s' (given %s).";
  private static final String INVALID_TYPE_ERROR_FORMAT =
      "Invalid argument for %s field '%s' (given %s).";

  private static final long UINT_MAX = 0xffffffffl;

  private static RubyClass cTypeError;
}
