/*
 *  This file is part of the Jikes RVM project (http://jikesrvm.org).
 *
 *  This file is licensed to You under the Eclipse Public License (EPL);
 *  You may not use this file except in compliance with the License. You
 *  may obtain a copy of the License at
 *
 *      http://www.opensource.org/licenses/eclipse-1.0.php
 *
 *  See the COPYRIGHT.txt file distributed with this work for information
 *  regarding copyright ownership.
 */
package org.mmtk.utility;

import org.mmtk.vm.VM;

import org.vmmagic.unboxed.*;
import org.vmmagic.pragma.*;

/**
 * Error and trace logging.
 */
@Uninterruptible
public class Log implements Constants {

  /****************************************************************************
   *
   * Class variables
   */

  /**
   * characters in the write buffer for the caller's message.  This
   * does not include characters reserved for the overflow message.
   *
   * This needs to be large because Jikes RVM's implementation of Lock.java
   * logs a lot of information when there is potential GC deadlock.
   */
  private static final int MESSAGE_BUFFER_SIZE = 3000;

  /** message added when the write buffer has overflown */
  private static final String OVERFLOW_MESSAGE = "... WARNING: Text truncated.\n";

  private static final char OVERFLOW_MESSAGE_FIRST_CHAR = OVERFLOW_MESSAGE.charAt(0);

  /** characters in the overflow message, including the (optional) final
   * newline  */
  private static final int OVERFLOW_SIZE = OVERFLOW_MESSAGE.length();

  /**
   * characters in buffer for building string representations of
   * longs.  A long is a signed 64-bit integer in the range -2^63 to
   * 2^63+1.  The number of digits in the decimal representation of
   * 2^63 is ceiling(log10(2^63)) == ceiling(63 * log10(2)) == 19.  An
   * extra character may be required for a minus sign (-).  So the
   * maximum number of characters is 20.
   */
  private static final int TEMP_BUFFER_SIZE = 20;

  /** string that prefixes numbers logged in hexadecimal */
  private static final String HEX_PREFIX = "0x";

  /**
   * log2 of number of bits represented by a single hexidemimal digit
   */
  private static final int LOG_BITS_IN_HEX_DIGIT = 2;

  /**
   * log2 of number of digits in the unsigned hexadecimal
   * representation of a byte
   */
  private static final int LOG_HEX_DIGITS_IN_BYTE = LOG_BITS_IN_BYTE - LOG_BITS_IN_HEX_DIGIT;

  /**
   * map of hexadecimal digit values to their character representations
   */
  private static final char [] hexDigitCharacter =
  { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

  /** new line character. Emitted by writeln methods. */
  private static final char NEW_LINE_CHAR = '\n';

  /** log instance used at build time. */
  private static Log log = new Log();

  /****************************************************************************
   *
   * Instance variables
   */

  /** buffer to store written message until flushing */
  private char [] buffer = new char[MESSAGE_BUFFER_SIZE + OVERFLOW_SIZE];

  /** location of next character to be written */
  private int bufferIndex = 0;

  /** <code>true</code> if the buffer has overflown */
  private boolean overflow = false;

  /** The last character that was written by #addToBuffer(char).  This is
      used to check whether we want to newline-terminate the text. */
  private char overflowLastChar = '\0';

  /** <code>true</code> if a thread id will be prepended */
  private boolean threadIdFlag = false;

  /** buffer for building string representations of longs */
  private char[] tempBuffer = new char[TEMP_BUFFER_SIZE];

  /** constructor */
  public Log() {
    for (int i = 0; i < OVERFLOW_SIZE; i++) {
      buffer[MESSAGE_BUFFER_SIZE + i] = OVERFLOW_MESSAGE.charAt(i);
    }
  }

  /**
   * writes a boolean. Either "true" or "false" is logged.
   *
   * @param b boolean value to be logged.
   */
  public static void write(boolean b) {
    write(b ? "true" : "false");
  }

  /**
   * writes a character
   *
   * @param c character to be logged
   */
  public static void write(char c) {
    add(c);
  }

  /**
   * writes a long, in decimal.  The value is not padded and no
   * thousands seperator is logged.  If the value is negative a
   * leading minus sign (-) is logged.
   *
   *
   * @param l long value to be logged
   */
  public static void write(long l) {
    boolean negative = l < 0;
    int nextDigit;
    char nextChar;
    int index = TEMP_BUFFER_SIZE - 1;
    char[] intBuffer = getIntBuffer();

    nextDigit = (int) (l % 10);
    nextChar = hexDigitCharacter[negative ? - nextDigit : nextDigit];
    intBuffer[index--] = nextChar;
    l = l / 10;

    while (l != 0) {
      nextDigit = (int) (l % 10);
      nextChar = hexDigitCharacter[negative ? - nextDigit : nextDigit];
      intBuffer[index--] = nextChar;
      l = l / 10;
    }

    if (negative) {
      intBuffer[index--] = '-';
    }

    for (index++; index < TEMP_BUFFER_SIZE; index++) {
      add(intBuffer[index]);
    }
  }

  /**
   * writes a <code>double</code>.  Two digits after the decimal point
   * are always logged.  The value is not padded and no thousands
   * seperator is used.  If the value is negative a leading
   * hyphen-minus (-) is logged.  The decimal point is a full stop
   * (.).
   *
   * @param d the double to be logged
   */
  public static void write(double d) { write(d, 2); }

  /**
   * writes a <code>double</code>.  The number of digits after the
   * decimal point is determined by <code>postDecimalDigits</code>.
   * The value is not padded and not thousands seperator is used. If
   * the value is negative a leading hyphen-minus (-) is logged.  The
   * decimal point is a full stop (.) and is logged even if
   * <postDecimcalDigits</code> is zero. If <code>d</code> is greater
   * than the largest representable value of type <code>int</code>, it
   * is logged as "TooBig".  Similarly, if it is less than
   * the negative of the largest representable value, it is logged as
   * "TooSmall".  If <code>d</code> is NaN is is logged as "NaN".
   *
   * @param d the double to be logged
   * @param postDecimalDigits the number of digits to be logged after
   * the decimal point.  If less than or equal to zero no digits are
   * logged, but the decimal point is.
   */
  public static void write(double d, int postDecimalDigits) {
    if (d != d) {
      write("NaN");
      return;
    }
    if (d > Integer.MAX_VALUE) {
      write("TooBig");
      return;
    }
    if (d < -Integer.MAX_VALUE) {
      write("TooSmall");
      return;
    }

    boolean negative = (d < 0.0);
    d = negative ? (-d) : d;       // Take absolute value
    int ones = (int) d;
    int multiplier = 1;
    while (postDecimalDigits-- > 0)
      multiplier *= 10;
    int remainder = (int) (multiplier * (d - ones));
    if (remainder < 0) remainder = 0;
    if (negative) write('-');
    write(ones);
    write('.');
    while (multiplier > 1) {
      multiplier /= 10;
      write(remainder / multiplier);
      remainder %= multiplier;
    }
  }

  /**
   * writes an array of characters
   *
   * @param c the array of characters to be logged
   */
  public static void write(char[] c) {
    write(c, c.length);
  }

  /**
   * writes the start of an array of characters
   *
   * @param c the array of characters
   * @param len the number of characters to be logged, starting with
   * the first character
   */
  public static void write(char[] c, int len) {
    if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(len <= c.length);
    for (int i = 0; i < len; i++) {
      add(c[i]);
    }
  }

  /**
   * writes an array of bytes.  The bytes are interpretted
   * as characters.
   *
   * @param b the array of bytes to be logged
   */
  public static void write(byte[] b) {
    for (int i = 0; i < b.length; i++) {
      add((char)b[i]);
    }
  }

  /**
   * writes a string
   *
   * @param s the string to be logged
   */
  public static void write(String s) {
    add(s);
  }

  /**
   * writes a word, in hexadecimal.  It is zero-padded to the size of
   * an address.
   *
   * @param w the word to be logged
   */
  public static void write(Word w) {
    writeHex(w, BYTES_IN_ADDRESS);
  }

  /**
   * writes a word, in decimal.
   *
   * @param w the word to be logged
   */
  public static void writeDec(Word w) {
    if (BYTES_IN_ADDRESS == 4) {
      write(w.toInt());
    } else {
      write(w.toLong());
    }
  }

  /**
   * writes an address, in hexademical. It is zero-padded.
   *
   * @param a the address to be logged
   */
  public static void write(Address a) {
    writeHex(a.toWord(), BYTES_IN_ADDRESS);
  }

  /**
   * writes a string followed by an address, in hexademical.
   * @see #write(String)
   * @see #write(Address)
   *
   * @param s the string to be logged
   * @param a the address to be logged
   */
  public static void write(String s, Address a) {
    write(s);
    write(a);
  }

  /**
   * Write a string followed by a long
   * @see #write(String)
   * @see #write(long)
   *
   * @param s the string to be logged
   * @param l the long to be logged
   */
  public static void write(String s, long l) {
    write(s);
    write(l);
  }

  /**
   * writes an object reference, in hexademical. It is zero-padded.
   *
   * @param o the object reference to be logged
   */
  public static void write(ObjectReference o) {
    writeHex(o.toAddress().toWord(), BYTES_IN_ADDRESS);
  }

  /**
   * writes an offset, in hexademical. It is zero-padded.
   *
   * @param o the offset to be logged
   */
  public static void write(Offset o) {
    writeHex(o.toWord(), BYTES_IN_ADDRESS);
  }

  /**
   * writes an extent, in hexademical. It is zero-padded.
   *
   * @param e the extent to be logged
   */
  public static void write(Extent e) {
    writeHex(e.toWord(), BYTES_IN_ADDRESS);
  }

  /**
   * write a new-line and flushes the buffer
   */
  public static void writeln() {
    writelnWithFlush(true);
  }

  /**
   * writes a boolean and a new-line, then flushes the buffer.
   * @see #write(boolean)
   *
   * @param b boolean value to be logged.
   */
  public static void writeln(boolean b) { writeln(b, true); }

  /**
   * writes a character and a new-line, then flushes the buffer.
   * @see #write(char)
   *
   * @param c character to be logged
   */
  public static void writeln(char c)    { writeln(c, true); }

  /**
   * writes a long, in decimal, and a new-line, then flushes the buffer.
   * @see #write(long)
   *
   * @param l long value to be logged
   */
  public static void writeln(long l)    { writeln(l, true); }

  /**
   * writes a <code>double</code> and a new-line, then flushes the buffer.
   * @see #write(double)
   *
   * @param d the double to be logged
   */
  public static void writeln(double d)  { writeln(d, true); }

  /**
   * writes a <code>double</code> and a new-line, then flushes the buffer.
   * @see #write(double, int)
   *
   * @param d the double to be logged
   */
  public static void writeln(double d, int postDecimalDigits) {
    writeln(d, postDecimalDigits, true); }

  /**
   * writes an array of characters and a new-line, then flushes the buffer.
   * @see #write(char [])
   *
   * @param ca the array of characters to be logged
   */
  public static void writeln(char [] ca) { writeln(ca, true); }

  /**
   * writes the start of an array of characters and a new-line, then
   * flushes the buffer.
   * @see #write(char[], int)
   *
   * @param ca the array of characters
   * @param len the number of characters to be logged, starting with
   * the first character
   */
  public static void writeln(char [] ca, int len) { writeln(ca, len, true); }

  /**
   * writes an array of bytes and a new-line, then
   * flushes the buffer.
   * @see #write(byte[])
   *
   * @param b the array of bytes to be logged
   */
  public static void writeln(byte [] b) { writeln(b, true); }

  /**
   * writes a string and a new-line, then flushes the buffer.
   *
   * @param s the string to be logged
   */
  public static void writeln(String s)  { writeln(s, true); }

  /**
   * writes a word, in hexadecimal, and a new-line, then flushes the buffer.
   * @see #write(Word)
   *
   * @param w the word to be logged
   */
  public static void writeln(Word w) { writeln(w, true); }

  /**
   * writes an address, in hexademical, and a new-line, then flushes
   * the buffer.
   * @see #write(Address)
   *
   * @param a the address to be logged
   */
  public static void writeln(Address a) { writeln(a, true); }

  /**
   * writes an object reference, in hexademical, and a new-line, then
   * flushes the buffer.
   * @see #write(ObjectReference)
   *
   * @param o the object reference to be logged
   */
  public static void writeln(ObjectReference o) { writeln(o, true); }

  /**
   * writes an offset, in hexademical, and a new-line, then flushes the buffer.
   * @see #write(Offset)
   *
   * @param o the offset to be logged
   */
  public static void writeln(Offset o) { writeln(o, true); }

  /**
   * writes an extent, in hexademical, and a new-line, then flushes the buffer.
   * @see #write(Extent)
   *
   * @param e the extent to be logged
   */
  public static void writeln(Extent e) { writeln(e, true); }

  /**
   * writes a new-line without flushing the buffer
   */
  public static void writelnNoFlush() {
    writelnWithFlush(false);
  }

  /**
   * writes a boolean and a new-line, then optionally flushes the buffer.
   * @see #write(boolean)
   *
   * @param b boolean value to be logged.
   * @param flush if <code>true</code> then flushes the buffer
   */
  public static void writeln(boolean b, boolean flush) {
    write(b);
    writelnWithFlush(flush);
  }

  /**
   * writes a character and a new-line, then optionally flushes the
   * buffer.
   * @see #write(char)
   *
   * @param c character to be logged
   * @param flush if <code>true</code> then flushes the buffer
   */
  public static void writeln(char c, boolean flush) {
    write(c);
    writelnWithFlush(flush);
  }

  /**
   * writes a long, in decimal, and a new-line, then optionally flushes
   * the buffer.
   * @see #write(long)
   *
   * @param l long value to be logged
   * @param flush if <code>true</code> then flushes the buffer
   */
  public static void writeln(long l, boolean flush) {
    write(l);
    writelnWithFlush(flush);
  }

  /**
   * writes a <code>double</code> and a new-line, then optionally flushes
   * the buffer.
   * @see #write(double)
   *
   * @param d the double to be logged
   * @param flush if <code>true</code> then flush the buffer
   */
  public static void writeln(double d, boolean flush) {
    write(d);
    writelnWithFlush(flush);
  }

  /**
   * writes a <code>double</code> and a new-line, then optionally flushes
   * the buffer.
   * @see #write(double, int)
   *
   * @param d the double to be logged
   * @param flush if <code>true</code> then flushes the buffer
   */
  public static void writeln(double d, int postDecimalDigits, boolean flush) {
    write(d, postDecimalDigits);
    writelnWithFlush(flush);
  }


  /**
   * writes an array of characters and a new-line, then optionally
   * flushes the buffer.
   * @see #write(char [])
   *
   * @param ca the array of characters to be logged
   * @param flush if <code>true</code> then flushes the buffer
   */
  public static void writeln(char[] ca, boolean flush) {
    write(ca);
    writelnWithFlush(flush);
  }

  /**
   * writes the start of an array of characters and a new-line, then
   * optionally flushes the buffer.
   * @see #write(char[], int)
   *
   * @param ca the array of characters
   * @param len the number of characters to be logged, starting with
   * the first character
   * @param flush if <code>true</code> then flushes the buffer
   */
  public static void writeln(char[] ca, int len, boolean flush) {
    write(ca, len);
    writelnWithFlush(flush);
  }

  /**
   * writes an array of bytes and a new-line, then optionally flushes the
   * buffer.
   * @see #write(byte[])
   *
   * @param b the array of bytes to be logged
   * @param flush if <code>true</code> then flushes the buffer
   */
  public static void writeln(byte[] b, boolean flush) {
    write(b);
    writelnWithFlush(flush);
  }

  /**
   * writes a string and a new-line, then optionally flushes the buffer.
   *
   * @param s the string to be logged
   * @param flush if <code>true</code> then flushes the buffer
   */
  public static void writeln(String s, boolean flush) {
    write(s);
    writelnWithFlush(flush);
  }

  public static void writeln(String s, long l) {
    write(s);
    writeln(l);
  }


  /**
   * writes a word, in hexadecimal, and a new-line, then optionally
   * flushes the buffer.
   * @see #write(Word)
   *
   * @param w the word to be logged
   * @param flush if <code>true</code> then flushes the buffer
   */
  public static void writeln(Word w, boolean flush) {
    write(w);
    writelnWithFlush(flush);
  }


  /**
   * writes an address, in hexademical, and a new-line, then optionally
   * flushes the buffer.
   * @see #write(Address)
   *
   * @param a the address to be logged
   * @param flush if <code>true</code> then flushes the buffer
   */
  public static void writeln(Address a, boolean flush) {
    write(a);
    writelnWithFlush(flush);
  }

  /**
   * writes an object reference, in hexademical, and a new-line, then
   * optionally flushes the buffer.
   * @see #write(ObjectReference)
   *
   * @param o the object reference to be logged
   * @param flush if <code>true</code> then flushes the buffer
   */
  public static void writeln(ObjectReference o, boolean flush) {
    write(o);
    writelnWithFlush(flush);
  }

  /**
   * writes an offset, in hexademical, and a new-line, then optionally
   * flushes the buffer.
   * @see #write(Offset)
   *
   * @param o the offset to be logged
   * @param flush if <code>true</code> then flushes the buffer
   */
  public static void writeln(Offset o, boolean flush) {
    write(o);
    writelnWithFlush(flush);
  }

  /**
   * writes an extent, in hexademical, and a new-line, then optionally
   * flushes the buffer.
   * @see #write(Extent)
   *
   * @param e the extent to be logged
   * @param flush if <code>true</code> then flushes the buffer
   */
  public static void writeln(Extent e, boolean flush) {
    write(e);
    writelnWithFlush(flush);
  }

  /**
   * writes a string followed by a Address
   * @see #write(String)
   * @see #write(Address)
   *
   * @param s the string to be logged
   * @param a the Address to be logged
   */
  public static void writeln(String s, Address a) {
    write(s);
    writeln(a);
  }

  /**
   * Log a thread identifier at the start of the next message flushed.
   */
  public static void prependThreadId() {
    getLog().setThreadIdFlag();
  }

  /**
   * flushes the buffer.  The buffered effected of writes since the last
   * flush will be logged in one block without output from other
   * thread's logging interleaving.
   */
  public static void flush() {
    getLog().flushBuffer();
  }

  /**
   * writes a new-line and optionally flushes the buffer
   *
   * @param flush if <code>true</code> the buffer is flushed
   */
  private static void writelnWithFlush(boolean flush) {
    add(NEW_LINE_CHAR);
    if (flush) {
      flush();
    }
  }

  /**
   * writes a <code>long</code> in hexadecimal
   *
   * @param w the Word to be logged
   * @param bytes the number of bytes from the long to be logged.  If
   * less than 8 then the least significant bytes are logged and some
   * of the most significant bytes are ignored.
   */
  private static void writeHex(Word w, int bytes) {
    int hexDigits = bytes * (1 << LOG_HEX_DIGITS_IN_BYTE);
    int nextDigit;

    write(HEX_PREFIX);

    for (int digitNumber = hexDigits - 1; digitNumber >= 0; digitNumber--) {
      nextDigit = w.rshl(digitNumber << LOG_BITS_IN_HEX_DIGIT).toInt() & 0xf;
      char nextChar = hexDigitCharacter[nextDigit];
      add(nextChar);
    }
  }

  /**
   * adds a character to the buffer
   *
   * @param c the character to add
   */
  private static void add(char c) {
    getLog().addToBuffer(c);
  }

  /**
   * adds a string to the buffer
   *
   * @param s the string to add
   */
  private static void add(String s) {
    getLog().addToBuffer(s);
  }

  private static Log getLog() {
    if (VM.assertions.runningVM()) {
      return VM.activePlan.log();
    } else {
      return log;
    }
  }

  /**
   * adds a character to the buffer
   *
   * @param c the character to add
   */
  private void addToBuffer(char c) {
    if (bufferIndex < MESSAGE_BUFFER_SIZE) {
      buffer[bufferIndex++] = c;
    } else {
      overflow = true;
      overflowLastChar = c;
    }
  }

  /**
   * adds a string to the buffer
   *
   * @param s the string to add
   */
  private void addToBuffer(String s) {
    if (bufferIndex < MESSAGE_BUFFER_SIZE) {
      bufferIndex += VM.strings.copyStringToChars(s, buffer, bufferIndex, MESSAGE_BUFFER_SIZE + 1);
      if (bufferIndex == MESSAGE_BUFFER_SIZE + 1) {
        overflow = true;
        // We don't bother setting OVERFLOW_LAST_CHAR, since we don't have an
        // MMTk method that lets us peek into a string. Anyway, it's just a
        // convenience to get the newline right.
        buffer[MESSAGE_BUFFER_SIZE] = OVERFLOW_MESSAGE_FIRST_CHAR;
        bufferIndex--;
      }
    } else {
      overflow = true;
    }
  }

  /**
   * flushes the buffer
   */
  private void flushBuffer() {
    int newlineAdjust = overflowLastChar == NEW_LINE_CHAR ? 0 : -1;
    int totalMessageSize = overflow ? (MESSAGE_BUFFER_SIZE + OVERFLOW_SIZE + newlineAdjust) : bufferIndex;
    if (threadIdFlag) {
      VM.strings.writeThreadId(buffer, totalMessageSize);
    } else {
      VM.strings.write(buffer, totalMessageSize);
    }
    threadIdFlag = false;
    overflow = false;
    overflowLastChar = '\0';
    bufferIndex = 0;
  }

  /**
   * sets the flag so that a thread identifier will be included before
   * the logged message
   */
  private void setThreadIdFlag() {
    threadIdFlag = true;
  }

  /**
   * gets the buffer for building string representations of integers.
   * There is one of these buffers for each Log instance.
   */
  private static char[] getIntBuffer() {
    return getLog().getTempBuffer();
  }

  /**
   * gets the buffer for building string representations of integers.
   */
  private char[] getTempBuffer() {
    return tempBuffer;
  }
}