/* Copyright 2014 Samsung Electronics Co., Ltd.
 *
 * 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.
 */

#include "globals.h"
#ifdef JERRY_ENABLE_PP
#include "pretty-printer.h"
#include "jerry-libc.h"
#include "lexer.h"
#include "deserializer.h"
#include "opcodes-native-call.h"
#include <stdarg.h>

#define NAME_TO_ID(op) (__op__idx_##op)

#define FIELD(op, field) (opcode.data.op.field)

#define __OPCODE_STR(name, arg1, arg2, arg3) \
  #name,

#define __OPCODE_SIZE(name, arg1, arg2, arg3) \
  sizeof (__op_##name) + 1,

static char* opcode_names[] =
{
  OP_LIST (OPCODE_STR)
  ""
};

static uint8_t opcode_sizes[] =
{
  OP_LIST (OPCODE_SIZE)
  0
};

static void
dump_lp (lp_string lp)
{
  for (ecma_length_t i = 0; i < lp.length; i++)
  {
    __putchar (lp.str[i]);
  }
}

void
pp_strings (const lp_string strings[], uint8_t size)
{
  __printf ("STRINGS %d:\n", size);
  for (uint8_t i = 0; i < size; i++)
  {
    __printf ("%3d ", i);
    dump_lp (strings[i]);
    __putchar ('\n');
  }
}

void
pp_nums (const ecma_number_t nums[], uint8_t size, uint8_t strings_num)
{
  uint8_t i;

  __printf ("NUMS %d:\n", size);
  for (i = 0; i < size; i++)
  {
    __printf ("%3d %7d\n", i + strings_num, (int) nums[i]);
  }
  __printf ("\n");
}

static const char *
var_id_to_string (char *res, idx_t id)
{
  if (id >= lexer_get_reserved_ids_count ())
  {
    __strncpy (res, "tmp", 3);
    if (id / 100 != 0)
    {
      res[3] = (char) (id / 100 + '0');
      res[4] = (char) ((id % 100) / 10 + '0');
      res[5] = (char) (id % 10 + '0');
      return res;
    }
    else if (id / 10 != 0)
    {
      res[3] = (char) (id / 10 + '0');
      res[4] = (char) (id % 10 + '0');
      return res;
    }
    else
    {
      res[3] = (char) (id + '0');
      return res;
    }
  }
  else if (id < lexer_get_strings_count ())
  {
    lp_string str = lexer_get_string_by_id (id);
    __strncpy (res, (char *) str.str, str.length);
    return res;
  }
  else
  {
    int i = 0;
    int num = (int) lexer_get_num_by_id (id);
    int temp = num;
    for (; temp != 0; i++)
    {
      temp /= 10;
    }
    do
    {
      res[i--] = (char) (num % 10 + '0');
      num /= 10;
    }
    while (i >= 0);
    return res;
  }
}

static void
pp_printf (const char *format, ...)
{
  va_list args;
  va_start (args, format);
  while (*format)
  {
    if (*format != '%')
    {
      __putchar (*format);
      format++;
      continue;
    }

    format++;
    switch (*format)
    {
      case 'd':
      {
        __printf ("%d", va_arg (args, int));
        break;
      }
      case 's':
      {
        char res[32] = {'\0'};
        __printf ("%s", var_id_to_string (res, (idx_t) va_arg (args, int)));
        break;
      }
      case '%':
      {
        __printf ("%%");
        break;
      }
      default:
      {
        JERRY_UNREACHABLE ();
      }
    }
    format++;
  }
  va_end (args);
}

#define PP_OP_0(op, format) \
  case NAME_TO_ID(op): pp_printf (format); break;

#define PP_OP_1(op, format, field1) \
  case NAME_TO_ID(op): pp_printf (format, opcode.data.op.field1); break;

#define PP_OP_2(op, format, field1, field2) \
  case NAME_TO_ID(op): pp_printf (format, opcode.data.op.field1, opcode.data.op.field2); break;

#define PP_OP_3(op, format, field1, field2, field3) \
  case NAME_TO_ID(op): pp_printf (format, opcode.data.op.field1, opcode.data.op.field2, opcode.data.op.field3); break;

static int vargs_num = 0;
static int seen_vargs = 0;

void
pp_opcode (opcode_counter_t oc, opcode_t opcode, bool is_rewrite)
{
  uint8_t i = 1;
  uint8_t opcode_id = opcode.op_idx;

  __printf ("%3d: %20s ", oc, opcode_names[opcode_id]);
  if (opcode_id != NAME_TO_ID (nop) && opcode_id != NAME_TO_ID (ret))
  {
    for (i = 1; i < opcode_sizes[opcode_id]; i++)
    {
      __printf ("%4d ", ((uint8_t*) & opcode)[i]);
    }
  }

  for (; i < 4; i++)
  {
    __printf ("     ");
  }

  __printf ("    // ");

  switch (opcode_id)
  {
    PP_OP_3 (addition, "%s = %s + %s;", dst, var_left, var_right);
    PP_OP_3 (substraction, "%s = %s - %s;", dst, var_left, var_right);
    PP_OP_3 (division, "%s = %s - %s;", dst, var_left, var_right);
    PP_OP_3 (multiplication, "%s = %s * %s;", dst, var_left, var_right);
    PP_OP_3 (remainder, "%s = %s %% %s;", dst, var_left, var_right);
    PP_OP_2 (unary_minus, "%s = -%s;", dst, var);
    PP_OP_2 (unary_plus, "%s = +%s;", dst, var);
    PP_OP_3 (b_shift_left, "%s = %s << %s;", dst, var_left, var_right);
    PP_OP_3 (b_shift_right, "%s = %s >> %s;", dst, var_left, var_right);
    PP_OP_3 (b_shift_uright, "%s = %s >>> %s;", dst, var_left, var_right);
    PP_OP_3 (b_and, "%s = %s & %s;", dst, var_left, var_right);
    PP_OP_3 (b_or, "%s = %s | %s;", dst, var_left, var_right);
    PP_OP_3 (b_xor, "%s = %s ^ %s;", dst, var_left, var_right);
    PP_OP_2 (b_not, "%s = ~ %s;", dst, var_right);
    PP_OP_3 (logical_and, "%s = %s && %s;", dst, var_left, var_right);
    PP_OP_3 (logical_or, "%s = %s || %s;", dst, var_left, var_right);
    PP_OP_2 (logical_not, "%s = ! %s;", dst, var_right);
    PP_OP_3 (equal_value, "%s = %s == %s;", dst, var_left, var_right);
    PP_OP_3 (not_equal_value, "%s = %s != %s;", dst, var_left, var_right);
    PP_OP_3 (equal_value_type, "%s = %s === %s;", dst, var_left, var_right);
    PP_OP_3 (not_equal_value_type, "%s = %s !== %s;", dst, var_left, var_right);
    PP_OP_3 (less_than, "%s = %s < %s;", dst, var_left, var_right);
    PP_OP_3 (greater_than, "%s = %s > %s;", dst, var_left, var_right);
    PP_OP_3 (less_or_equal_than, "%s = %s <= %s;", dst, var_left, var_right);
    PP_OP_3 (greater_or_equal_than, "%s = %s >= %s;", dst, var_left, var_right);
    PP_OP_3 (instanceof, "%s = %s instanceof %s;", dst, var_left, var_right);
    PP_OP_3 (in, "%s = %s in %s;", dst, var_left, var_right);
    PP_OP_2 (post_incr, "%s = %s++;", dst, var_right);
    PP_OP_2 (post_decr, "%s = %s--;", dst, var_right);
    PP_OP_2 (pre_incr, "%s = ++%s;", dst, var_right);
    PP_OP_2 (pre_decr, "%s = --%s;", dst, var_right);
    PP_OP_1 (throw, "throw %s;", var);
    PP_OP_2 (reg_var_decl, "var %s .. %s;", min, max);
    PP_OP_1 (var_decl, "var %s;", variable_name);
    PP_OP_0 (nop, ";");
    PP_OP_1 (exitval, "exit %d;", status_code);
    PP_OP_1 (retval, "return %s;", ret_value);
    PP_OP_0 (ret, "ret;");
    PP_OP_3 (prop_getter, "%s = %s[%s];", lhs, obj, prop);
    PP_OP_3 (prop_setter, "%s[%s] = %s;", obj, prop, rhs);
    PP_OP_1 (this, "%s = this;", lhs);
    PP_OP_2 (delete_var, "%s = delete %s;", lhs, name);
    PP_OP_3 (delete_prop, "%s = delete %s.%s;", lhs, base, name);
    PP_OP_2 (typeof, "%s = typeof %s;", lhs, obj);
    PP_OP_1 (with, "with (%s);", expr);
    case NAME_TO_ID (is_true_jmp_up):
    {
      pp_printf ("if (%s) goto %d;", opcode.data.is_true_jmp_up.value,
                 oc - calc_opcode_counter_from_idx_idx (opcode.data.is_true_jmp_up.opcode_1,
                                                        opcode.data.is_true_jmp_up.opcode_2));
      break;
    }
    case NAME_TO_ID (is_false_jmp_up):
    {
      pp_printf ("if (%s) goto %d;", opcode.data.is_false_jmp_up.value,
                 oc - calc_opcode_counter_from_idx_idx (opcode.data.is_false_jmp_up.opcode_1,
                                                        opcode.data.is_false_jmp_up.opcode_2));
      break;
    }
    case NAME_TO_ID (is_true_jmp_down):
    {
      pp_printf ("if (%s) goto %d;", opcode.data.is_true_jmp_down.value,
                 oc + calc_opcode_counter_from_idx_idx (opcode.data.is_true_jmp_down.opcode_1,
                                                        opcode.data.is_true_jmp_down.opcode_2));
      break;
    }
    case NAME_TO_ID (is_false_jmp_down):
    {
      pp_printf ("if (%s == false) goto %d;", opcode.data.is_false_jmp_down.value,
                 oc + calc_opcode_counter_from_idx_idx (opcode.data.is_false_jmp_down.opcode_1,
                                                        opcode.data.is_false_jmp_down.opcode_2));
      break;
    }
    case NAME_TO_ID (jmp_up):
    {
      pp_printf ("goto %d;",
                 oc - calc_opcode_counter_from_idx_idx (opcode.data.jmp_up.opcode_1,
                                                        opcode.data.jmp_up.opcode_2));
      break;
    }
    case NAME_TO_ID (jmp_down):
    {
      pp_printf ("goto %d;",
                 oc + calc_opcode_counter_from_idx_idx (opcode.data.jmp_down.opcode_1,
                                                        opcode.data.jmp_down.opcode_2));
      break;
    }
    case NAME_TO_ID (try):
    {
      pp_printf ("try (end: %d);", oc + calc_opcode_counter_from_idx_idx (opcode.data.try.oc_idx_1,
                                                                          opcode.data.try.oc_idx_2));
      break;
    }
    case NAME_TO_ID (assignment):
    {
      pp_printf ("%s = ", opcode.data.assignment.var_left);
      switch (opcode.data.assignment.type_value_right)
      {
        case OPCODE_ARG_TYPE_SIMPLE:
        {
          switch (opcode.data.assignment.value_right)
          {
            case ECMA_SIMPLE_VALUE_NULL: pp_printf ("null"); break;
            case ECMA_SIMPLE_VALUE_FALSE: pp_printf ("false"); break;
            case ECMA_SIMPLE_VALUE_TRUE: pp_printf ("true"); break;
            case ECMA_SIMPLE_VALUE_UNDEFINED: pp_printf ("undefined"); break;
            default: JERRY_UNREACHABLE ();
          }
          pp_printf (": SIMPLE;");
          break;
        }
        case OPCODE_ARG_TYPE_STRING:
        {
          pp_printf ("'%s': STRING;", opcode.data.assignment.value_right);
          break;
        }
        case OPCODE_ARG_TYPE_NUMBER:
        {
          pp_printf ("%s: NUMBER;", opcode.data.assignment.value_right);
          break;
        }
        case OPCODE_ARG_TYPE_SMALLINT:
        {
          pp_printf ("%d: SMALLINT;", opcode.data.assignment.value_right);
          break;
        }
        case OPCODE_ARG_TYPE_VARIABLE:
        {
          pp_printf ("%s : TYPEOF(%s);", opcode.data.assignment.value_right, opcode.data.assignment.value_right);
          break;
        }
        default:
        {
          JERRY_UNREACHABLE ();
        }
      }
      break;
    }
    case NAME_TO_ID (call_n):
    {
      if (opcode.data.call_n.arg_list == 0)
      {
        pp_printf ("%s = %s ();", opcode.data.call_n.lhs, opcode.data.call_n.name_lit_idx);
      }
      else
      {
        vargs_num = opcode.data.call_n.arg_list;
        seen_vargs = 0;
      }
      break;
    }
    case NAME_TO_ID (native_call):
    {
      if (opcode.data.native_call.arg_list == 0)
      {
        pp_printf ("%s = ", opcode.data.native_call.lhs);
        switch (opcode.data.native_call.name)
        {
          case OPCODE_NATIVE_CALL_LED_TOGGLE: pp_printf ("LEDToggle ();"); break;
          case OPCODE_NATIVE_CALL_LED_ON: pp_printf ("LEDOn ();"); break;
          case OPCODE_NATIVE_CALL_LED_OFF: pp_printf ("LEDOff ();"); break;
          case OPCODE_NATIVE_CALL_LED_ONCE: pp_printf ("LEDOnce ();"); break;
          case OPCODE_NATIVE_CALL_WAIT: pp_printf ("wait ();"); break;
          case OPCODE_NATIVE_CALL_PRINT: pp_printf ("print ();"); break;
          default: JERRY_UNREACHABLE ();
        }
      }
      else
      {
        vargs_num = opcode.data.native_call.arg_list;
        seen_vargs = 0;
      }
      break;
    }
    case NAME_TO_ID (construct_n):
    {
      if (opcode.data.construct_n.arg_list == 0)
      {
        pp_printf ("%s = new %s;", opcode.data.construct_n.lhs, opcode.data.construct_n.name_lit_idx);
      }
      else
      {
        vargs_num = opcode.data.construct_n.arg_list;
        seen_vargs = 0;
      }
      break;
    }
    case NAME_TO_ID (func_decl_n):
    {
      if (opcode.data.func_decl_n.arg_list == 0)
      {
        pp_printf ("function %s ();", opcode.data.func_decl_n.name_lit_idx);
      }
      else
      {
        vargs_num = opcode.data.func_decl_n.arg_list;
        seen_vargs = 0;
      }
      break;
    }
    case NAME_TO_ID (func_expr_n):
    {
      if (opcode.data.func_expr_n.arg_list == 0)
      {
        pp_printf ("%s = function %s ();", opcode.data.func_expr_n.lhs, opcode.data.func_expr_n.name_lit_idx);
      }
      else
      {
        vargs_num = opcode.data.func_expr_n.arg_list;
        seen_vargs = 0;
      }
      break;
    }
    case NAME_TO_ID (array_decl):
    {
      if (opcode.data.array_decl.list == 0)
      {
        pp_printf ("%s = [];", opcode.data.array_decl.lhs);
      }
      else
      {
        vargs_num = opcode.data.array_decl.list;
        seen_vargs = 0;
      }
      break;
    }
    case NAME_TO_ID (obj_decl):
    {
      if (opcode.data.obj_decl.list == 0)
      {
        pp_printf ("%s = {};", opcode.data.obj_decl.lhs);
      }
      else
      {
        vargs_num = opcode.data.obj_decl.list;
        seen_vargs = 0;
      }
      break;
    }
    case NAME_TO_ID (meta):
    {
      switch (opcode.data.meta.type)
      {
        case OPCODE_META_TYPE_UNDEFINED:
        {
          pp_printf ("unknown meta;");
          break;
        }
        case OPCODE_META_TYPE_THIS_ARG:
        case OPCODE_META_TYPE_VARG:
        case OPCODE_META_TYPE_VARG_PROP_DATA:
        case OPCODE_META_TYPE_VARG_PROP_GETTER:
        case OPCODE_META_TYPE_VARG_PROP_SETTER:
        {
          seen_vargs++;
          if (seen_vargs == vargs_num)
          {
            bool found = false;
            opcode_counter_t start = oc;
            while ((int16_t) start >= 0 && !found)
            {
              start--;
              switch (deserialize_opcode (start).op_idx)
              {
                case NAME_TO_ID (call_n):
                case NAME_TO_ID (native_call):
                case NAME_TO_ID (construct_n):
                case NAME_TO_ID (func_decl_n):
                case NAME_TO_ID (func_expr_n):
                case NAME_TO_ID (array_decl):
                case NAME_TO_ID (obj_decl):
                {
                  found = true;
                  break;
                }
              }
            }
            opcode_t start_op = deserialize_opcode (start);
            switch (start_op.op_idx)
            {
              case NAME_TO_ID (call_n):
              {
                pp_printf ("%s = %s (", start_op.data.call_n.lhs, start_op.data.call_n.name_lit_idx);
                break;
              }
              case NAME_TO_ID (native_call):
              {
                pp_printf ("%s = ", start_op.data.native_call.lhs);
                switch (start_op.data.native_call.name)
                {
                  case OPCODE_NATIVE_CALL_LED_TOGGLE: pp_printf ("LEDToggle ("); break;
                  case OPCODE_NATIVE_CALL_LED_ON: pp_printf ("LEDOn ("); break;
                  case OPCODE_NATIVE_CALL_LED_OFF: pp_printf ("LEDOff ("); break;
                  case OPCODE_NATIVE_CALL_LED_ONCE: pp_printf ("LEDOnce ("); break;
                  case OPCODE_NATIVE_CALL_WAIT: pp_printf ("wait ("); break;
                  case OPCODE_NATIVE_CALL_PRINT: pp_printf ("print ("); break;
                  default: JERRY_UNREACHABLE ();
                }
                break;
              }
              case NAME_TO_ID (construct_n):
              {
                pp_printf ("%s = new %s (", start_op.data.construct_n.lhs, start_op.data.construct_n.name_lit_idx);
                break;
              }
              case NAME_TO_ID (func_decl_n):
              {
                pp_printf ("function %s (", start_op.data.func_decl_n.name_lit_idx);
                break;
              }
              case NAME_TO_ID (func_expr_n):
              {
                pp_printf ("%s = function %s (", start_op.data.func_expr_n.lhs,
                           start_op.data.func_expr_n.name_lit_idx);
                break;
              }
              case NAME_TO_ID (array_decl):
              {
                pp_printf ("%s = [", start_op.data.array_decl.lhs);
                break;
              }
              case NAME_TO_ID (obj_decl):
              {
                pp_printf ("%s = {", start_op.data.obj_decl.lhs);
                break;
              }
              default:
              {
                JERRY_UNREACHABLE ();
              }
            }
            for (opcode_counter_t counter = start; counter <= oc; counter++)
            {
              opcode_t meta_op = deserialize_opcode (counter);
              switch (meta_op.op_idx)
              {
                case NAME_TO_ID (meta):
                {
                  switch (opcode.data.meta.type)
                  {
                    case OPCODE_META_TYPE_THIS_ARG:
                    {
                      pp_printf ("this_arg = %s", meta_op.data.meta.data_1);
                      break;
                    }
                    case OPCODE_META_TYPE_VARG:
                    {
                      pp_printf ("%s", meta_op.data.meta.data_1);
                      break;
                    }
                    case OPCODE_META_TYPE_VARG_PROP_DATA:
                    {
                      pp_printf ("%s:%s", meta_op.data.meta.data_1, meta_op.data.meta.data_2);
                      break;
                    }
                    case OPCODE_META_TYPE_VARG_PROP_GETTER:
                    {
                      pp_printf ("%s = get ();", meta_op.data.meta.data_1);
                      break;
                    }
                    case OPCODE_META_TYPE_VARG_PROP_SETTER:
                    {
                      pp_printf ("%s = set (%s);", meta_op.data.meta.data_1, meta_op.data.meta.data_2);
                      break;
                    }
                    default:
                    {
                      JERRY_UNREACHABLE ();
                    }
                  }
                  if (counter != oc)
                  {
                    pp_printf (", ");
                  }
                  break;
                }
              }
            }
            switch (start_op.op_idx)
            {
              case NAME_TO_ID (array_decl):
              {
                pp_printf ("];");
                break;
              }
              case NAME_TO_ID (obj_decl):
              {
                pp_printf ("};");
                break;
              }
              default:
              {
                pp_printf (");");
              }
            }
          }
          break;
        }
        case OPCODE_META_TYPE_END_WITH:
        {
          pp_printf ("end with;");
          break;
        }
        case OPCODE_META_TYPE_FUNCTION_END:
        {
          pp_printf ("function end: %d;", oc + calc_opcode_counter_from_idx_idx (opcode.data.meta.data_1,
                                                                                 opcode.data.meta.data_2));
          break;
        }
        case OPCODE_META_TYPE_CATCH:
        {
          pp_printf ("catch end: %d;", oc + calc_opcode_counter_from_idx_idx (opcode.data.meta.data_1,
                                                                              opcode.data.meta.data_2));
          break;
        }
        case OPCODE_META_TYPE_CATCH_EXCEPTION_IDENTIFIER:
        {
          pp_printf ("catch (%s);", opcode.data.meta.data_1);
          break;
        }
        case OPCODE_META_TYPE_FINALLY:
        {
          pp_printf ("finally end: %d;", oc + calc_opcode_counter_from_idx_idx (opcode.data.meta.data_1,
                                                                                opcode.data.meta.data_2));
          break;
        }
        case OPCODE_META_TYPE_END_TRY_CATCH_FINALLY:
        {
          pp_printf ("end try");
          break;
        }
        case OPCODE_META_TYPE_STRICT_CODE:
        {
          pp_printf ("use strict;");
          break;
        }
        default:
        {
          JERRY_UNREACHABLE ();
        }
      }
      break;
    }
    default:
    {
      JERRY_UNREACHABLE ();
    }
  }

  if (is_rewrite)
  {
    __printf (" // REWRITE");
  }

  __printf ("\n");
}
#endif /* JERRY_ENABLE_PP */