/* Copyright (c) Pigeonhole authors, see top-level COPYING file */

#include "lib.h"

#include "str.h"

#include "array.h"

#include "sieve-common.h"

#include "sieve-extensions.h"

#include "sieve-code.h"

#include "sieve-ast.h"

#include "sieve-commands.h"

#include "sieve-binary.h"

#include "sieve-message.h"

#include "sieve-validator.h"

#include "sieve-generator.h"

#include "sieve-interpreter.h"

#include "sieve-dump.h"

#include "sieve-ext-variables.h"

#include "ext-mime-common.h"

/*

 * Extracttext command

 *

 * Syntax:

 *    extracttext [MODIFIER] [":first" number] <varname: string>

 */

static bool

cmd_extracttext_registered(struct sieve_validator *valdtr,

         const struct sieve_extension *ext,

         struct sieve_command_registration *cmd_reg);

static bool

cmd_extracttext_validate(struct sieve_validator *valdtr,

       struct sieve_command *cmd);

static bool

cmd_extracttext_generate(const struct sieve_codegen_env *cgenv,

       struct sieve_command *ctx);

const struct sieve_command_def cmd_extracttext = {

  .identifier = "extracttext",

  .type = SCT_COMMAND,

  .positional_args = 1,

  .subtests = 0,

  .block_allowed = FALSE,

  .block_required = FALSE,

  .registered = cmd_extracttext_registered,

  .validate = cmd_extracttext_validate,

  .generate = cmd_extracttext_generate,

};

/*

 * Extracttext command tags

 */

enum cmd_extracttext_optional {

  CMD_EXTRACTTEXT_OPT_END,

  CMD_EXTRACTTEXT_OPT_FIRST

};

static bool

cmd_extracttext_validate_first_tag(struct sieve_validator *valdtr,

           struct sieve_ast_argument **arg,

           struct sieve_command *cmd);

static const struct sieve_argument_def extracttext_from_tag = {

  .identifier = "first",

  .validate = cmd_extracttext_validate_first_tag,

};

/*

 * Extracttext operation

 */

static bool

cmd_extracttext_operation_dump(const struct sieve_dumptime_env *denv,

             sieve_size_t *address);

static int

cmd_extracttext_operation_execute(const struct sieve_runtime_env *renv,

          sieve_size_t *address);

const struct sieve_operation_def extracttext_operation = {

  .mnemonic = "EXTRACTTEXT",

  .ext_def = &extracttext_extension,

  .dump = cmd_extracttext_operation_dump,

  .execute = cmd_extracttext_operation_execute,

};

/*

 * Compiler context

 */

struct cmd_extracttext_context {

  ARRAY_TYPE(sieve_variables_modifier) modifiers;

};

/*

 * Tag validation

 */

static bool

cmd_extracttext_validate_first_tag(struct sieve_validator *valdtr,

           struct sieve_ast_argument **arg,

           struct sieve_command *cmd)

{

  struct sieve_ast_argument *tag = *arg;

  /* Detach the tag itself */

  *arg = sieve_ast_arguments_detach(*arg,1);

  /* Check syntax:

   *   :first <number>

   */

  if (!sieve_validate_tag_parameter(valdtr, cmd, tag, *arg, NULL, 0,

            SAAT_NUMBER, FALSE) )

    return FALSE;

  /* Skip parameter */

  *arg = sieve_ast_argument_next(*arg);

  return TRUE;

}

/* Command registration */

static bool

cmd_extracttext_registered(struct sieve_validator *valdtr,

         const struct sieve_extension *ext,

         struct sieve_command_registration *cmd_reg)

{

  struct ext_extracttext_context *extctx = ext->context;

  sieve_validator_register_tag(valdtr, cmd_reg, ext,

             &extracttext_from_tag,

             CMD_EXTRACTTEXT_OPT_FIRST);

  sieve_variables_modifiers_link_tag(valdtr, extctx->var_ext, cmd_reg);

  return TRUE;

}

/*

 * Command validation

 */

static bool

cmd_extracttext_validate(struct sieve_validator *valdtr,

       struct sieve_command *cmd)

{

  const struct sieve_extension *this_ext = cmd->ext;

  struct ext_extracttext_context *extctx = this_ext->context;

  struct sieve_ast_node *node = cmd->ast_node;

  struct sieve_ast_argument *arg = cmd->first_positional;

  pool_t pool = sieve_command_pool(cmd);

  struct cmd_extracttext_context *sctx;

  /* Create command context */

  sctx = p_new(pool, struct cmd_extracttext_context, 1);

  p_array_init(&sctx->modifiers, pool, 4);

  cmd->data = sctx;

  /* Validate modifiers */

  if (!sieve_variables_modifiers_validate(valdtr, cmd, &sctx->modifiers))

    return FALSE;

  /* Validate varname argument */

  if (!sieve_validate_positional_argument(valdtr, cmd, arg, "varname", 1,

            SAAT_STRING))

    return FALSE;

  if (!sieve_variable_argument_activate(extctx->var_ext, extctx->var_ext,

                valdtr, cmd, arg, TRUE))

    return FALSE;

  /* Check foreverypart context */

  i_assert(node != NULL);

  while (node != NULL) {

    if (node->command != NULL &&

        sieve_command_is(node->command, cmd_foreverypart))

      break;

    node = sieve_ast_node_parent(node);

  }

  if (node == NULL) {

    sieve_command_validate_error(

      valdtr, cmd,

      "the extracttext command is not placed inside "

      "a foreverypart loop");

    return FALSE;

  }

  return TRUE;

}

/*

 * Code generation

 */

static bool

cmd_extracttext_generate(const struct sieve_codegen_env *cgenv,

       struct sieve_command *cmd)

{

  const struct sieve_extension *this_ext = cmd->ext;

  struct sieve_binary_block *sblock = cgenv->sblock;

  struct cmd_extracttext_context *sctx =

    (struct cmd_extracttext_context *) cmd->data;

  sieve_operation_emit(sblock, this_ext, &extracttext_operation);

  /* Generate arguments */

  if (!sieve_generate_arguments(cgenv, cmd, NULL))

    return FALSE;

  /* Generate modifiers */

  if (!sieve_variables_modifiers_generate(cgenv, &sctx->modifiers))

    return FALSE;

  return TRUE;

}

/*

 * Code dump

 */

static bool

cmd_extracttext_operation_dump(const struct sieve_dumptime_env *denv,

             sieve_size_t *address)

{

  int opt_code = 0;

  sieve_code_dumpf(denv, "EXTRACTTEXT");

  sieve_code_descend(denv);

  /* Dump optional operands */

  for (;;) {

    int opt;

    bool opok = TRUE;

    opt = sieve_opr_optional_dump(denv, address, &opt_code);

    if (opt < 0)

      return FALSE;

    if (opt == 0)

      break;

    switch (opt_code) {

    case CMD_EXTRACTTEXT_OPT_FIRST:

      opok = sieve_opr_number_dump(denv, address, "first");

      break;

    default:

      return FALSE;

    }

    if (!opok)

      return FALSE;

  }

  /* Print both variable name and string value */

  if (!sieve_opr_string_dump(denv, address, "varname"))

    return FALSE;

  return sieve_variables_modifiers_code_dump(denv, address);

}

/*

 * Code execution

 */

static int

cmd_extracttext_operation_execute(const struct sieve_runtime_env *renv,

          sieve_size_t *address)

{

  const struct sieve_extension *this_ext = renv->oprtn->ext;

  struct ext_extracttext_context *extctx = this_ext->context;

  struct sieve_variable_storage *storage;

  ARRAY_TYPE(sieve_variables_modifier) modifiers;

  struct ext_foreverypart_runtime_loop *sfploop;

  struct sieve_message_part *mpart;

  struct sieve_message_part_data mpart_data;

  int opt_code = 0;

  sieve_number_t first = 0;

  string_t *value;

  unsigned int var_index;

  bool have_first = FALSE;

  int ret = SIEVE_EXEC_OK;

  /*

   * Read the normal operands

   */

  /* Optional operands */

  for (;;) {

    int opt;

    opt = sieve_opr_optional_read(renv, address, &opt_code);

    if (opt < 0)

      return SIEVE_EXEC_BIN_CORRUPT;

    if (opt == 0)

      break;

    switch (opt_code) {

    case CMD_EXTRACTTEXT_OPT_FIRST:

      ret = sieve_opr_number_read(renv, address, "first",

                &first);

      have_first = TRUE;

      break;

    default:

      sieve_runtime_trace_error(

        renv, "unknown optional operand");

      return SIEVE_EXEC_BIN_CORRUPT;

    }

    if (ret <= 0)

      return ret;

  }

  /* Varname operand */

  ret = sieve_variable_operand_read(renv, address, "varname",

            &storage, &var_index);

  if (ret <= 0)

    return ret;

  /* Modifiers */

  ret = sieve_variables_modifiers_code_read(renv, extctx->var_ext,

              address, &modifiers);

  if (ret <= 0)

    return ret;

  /*

   * Determine and assign the value

   */

  sieve_runtime_trace(renv, SIEVE_TRLVL_COMMANDS, "extracttext command");

  sieve_runtime_trace_descend(renv);

  sfploop = ext_foreverypart_runtime_loop_get_current(renv);

  if (sfploop == NULL) {

    sieve_runtime_trace_error(renv, "outside foreverypart context");

    return SIEVE_EXEC_BIN_CORRUPT;

  }

  /* Get current message part */

  mpart = sieve_message_part_iter_current(&sfploop->part_iter);

  i_assert(mpart != NULL);

  /* Get message part content */

  sieve_message_part_get_data(mpart, &mpart_data, TRUE);

  /* Apply ":first" limit, if any */

  if (!have_first || (size_t)first > mpart_data.size) {

    value = t_str_new_const(mpart_data.content, mpart_data.size);

  } else {

    value = t_str_new((size_t)first);

    str_append_data(value, mpart_data.content, (size_t)first);

  }

  /* Apply modifiers */

  ret = sieve_variables_modifiers_apply(renv, extctx->var_ext,

                &modifiers, &value);

  if (ret <= 0)

    return ret;

  /* Actually assign the value if all is well */

  i_assert (value != NULL);

  if (!sieve_variable_assign(storage, var_index, value))

    return SIEVE_EXEC_BIN_CORRUPT;

  /* Trace */

  if (sieve_runtime_trace_active(renv, SIEVE_TRLVL_COMMANDS)) {

    const char *var_name, *var_id;

    (void)sieve_variable_get_identifier(storage, var_index,

                &var_name);

    var_id = sieve_variable_get_varid(storage, var_index);

    sieve_runtime_trace_here(renv, 0, "assign '%s' [%s] = \"%s\"",

           var_name, var_id, str_c(value));

  }

  return SIEVE_EXEC_OK;

}