/*
 * Copyright (c) 2010 Google 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 com.google.api.client.json;

import com.google.api.client.util.ClassInfo;
import com.google.api.client.util.Data;
import com.google.api.client.util.DateTime;
import com.google.api.client.util.FieldInfo;
import com.google.api.client.util.GenericData;
import com.google.api.client.util.Preconditions;
import com.google.api.client.util.Types;
import java.io.Closeable;
import java.io.Flushable;
import java.io.IOException;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Map;

/**
 * Abstract low-level JSON serializer.
 *
 * <p>Implementation has no fields and therefore thread-safe, but sub-classes are not necessarily
 * thread-safe.
 *
 * @since 1.3
 * @author Yaniv Inbar
 */
public abstract class JsonGenerator implements Closeable, Flushable {

  /** Returns the JSON factory from which this generator was created. */
  public abstract JsonFactory getFactory();

  /** Flushes any buffered content to the underlying output stream or writer. */
  public abstract void flush() throws IOException;

  /**
   * Closes the serializer and the underlying output stream or writer, and releases any memory
   * associated with it.
   */
  public abstract void close() throws IOException;

  /** Writes a JSON start array character '['. */
  public abstract void writeStartArray() throws IOException;

  /** Writes a JSON end array character ']'. */
  public abstract void writeEndArray() throws IOException;

  /** Writes a JSON start object character '{'. */
  public abstract void writeStartObject() throws IOException;

  /** Writes a JSON end object character '}'. */
  public abstract void writeEndObject() throws IOException;

  /** Writes a JSON quoted field name. */
  public abstract void writeFieldName(String name) throws IOException;

  /** Writes a literal JSON null value. */
  public abstract void writeNull() throws IOException;

  /** Writes a JSON quoted string value. */
  public abstract void writeString(String value) throws IOException;

  /** Writes a literal JSON boolean value ('true' or 'false'). */
  public abstract void writeBoolean(boolean state) throws IOException;

  /** Writes a JSON int value. */
  public abstract void writeNumber(int v) throws IOException;

  /** Writes a JSON long value. */
  public abstract void writeNumber(long v) throws IOException;

  /** Writes a JSON big integer value. */
  public abstract void writeNumber(BigInteger v) throws IOException;

  /** Writes a JSON float value. */
  public abstract void writeNumber(float v) throws IOException;

  /** Writes a JSON double value. */
  public abstract void writeNumber(double v) throws IOException;

  /** Writes a JSON big decimal value. */
  public abstract void writeNumber(BigDecimal v) throws IOException;

  /** Writes a JSON numeric value that has already been encoded properly. */
  public abstract void writeNumber(String encodedValue) throws IOException;

  /**
   * Serializes the given JSON value object, or if {@code value} is {@code null} it does no
   * serialization.
   */
  public final void serialize(Object value) throws IOException {
    serialize(false, value);
  }

  private void serialize(boolean isJsonString, Object value) throws IOException {
    if (value == null) {
      return;
    }
    Class<?> valueClass = value.getClass();
    if (Data.isNull(value)) {
      writeNull();
    } else if (value instanceof String) {
      writeString((String) value);
    } else if (value instanceof Number) {
      if (isJsonString) {
        writeString(value.toString());
      } else if (value instanceof BigDecimal) {
        writeNumber((BigDecimal) value);
      } else if (value instanceof BigInteger) {
        writeNumber((BigInteger) value);
      } else if (value instanceof Long) {
        writeNumber((Long) value);
      } else if (value instanceof Float) {
        float floatValue = ((Number) value).floatValue();
        Preconditions.checkArgument(!Float.isInfinite(floatValue) && !Float.isNaN(floatValue));
        writeNumber(floatValue);
      } else if (value instanceof Integer || value instanceof Short || value instanceof Byte) {
        writeNumber(((Number) value).intValue());
      } else {
        double doubleValue = ((Number) value).doubleValue();
        Preconditions.checkArgument(!Double.isInfinite(doubleValue) && !Double.isNaN(doubleValue));
        writeNumber(doubleValue);
      }
    } else if (value instanceof Boolean) {
      writeBoolean((Boolean) value);
    } else if (value instanceof DateTime) {
      writeString(((DateTime) value).toStringRfc3339());
    } else if ((value instanceof Iterable<?> || valueClass.isArray())
        && !(value instanceof Map<?, ?>)
        && !(value instanceof GenericData)) {
      writeStartArray();
      for (Object o : Types.iterableOf(value)) {
        serialize(isJsonString, o);
      }
      writeEndArray();
    } else if (valueClass.isEnum()) {
      String name = FieldInfo.of((Enum<?>) value).getName();
      if (name == null) {
        writeNull();
      } else {
        writeString(name);
      }
    } else {
      writeStartObject();
      // only inspect fields of POJO (possibly extends GenericData) but not generic Map
      boolean isMapNotGenericData = value instanceof Map<?, ?> && !(value instanceof GenericData);
      ClassInfo classInfo = isMapNotGenericData ? null : ClassInfo.of(valueClass);
      for (Map.Entry<String, Object> entry : Data.mapOf(value).entrySet()) {
        Object fieldValue = entry.getValue();
        if (fieldValue != null) {
          String fieldName = entry.getKey();
          boolean isJsonStringForField;
          if (isMapNotGenericData) {
            isJsonStringForField = isJsonString;
          } else {
            Field field = classInfo.getField(fieldName);
            isJsonStringForField = field != null && field.getAnnotation(JsonString.class) != null;
          }
          writeFieldName(fieldName);
          serialize(isJsonStringForField, fieldValue);
        }
      }
      writeEndObject();
    }
  }

  /**
   * Requests that the output be pretty printed (by default it is not).
   *
   * <p>Default implementation does nothing, but implementations may override to provide actual
   * pretty printing.
   *
   * @throws IOException possible I/O exception (unused in default implementation)
   * @since 1.6
   */
  public void enablePrettyPrint() throws IOException {}
}
