////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 1996-2022 The Octave Project Developers
//
// See the file COPYRIGHT.md in the top-level directory of this
// distribution or <https://octave.org/copyright/>.
//
// This file is part of Octave.
//
// Octave is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Octave is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Octave; see the file COPYING.  If not, see
// <https://www.gnu.org/licenses/>.
//
////////////////////////////////////////////////////////////////////////

#if defined (HAVE_CONFIG_H)
#  include "config.h"
#endif

#include "Cell.h"
#include "error.h"
#include "interpreter-private.h"
#include "oct-map.h"
#include "ovl.h"
#include "oct-lvalue.h"
#include "ov.h"
#include "pt-arg-list.h"
#include "pt-eval.h"
#include "pt-id.h"
#include "pt-idx.h"
#include "utils.h"
#include "variables.h"
#include "errwarn.h"

namespace octave
{
  // Index expressions.

  tree_index_expression::tree_index_expression (int l, int c)
    : tree_expression (l, c), m_expr (nullptr), m_args (0), m_type (),
      m_arg_nm (), m_dyn_field (), m_word_list_cmd (false) { }

  tree_index_expression::tree_index_expression (tree_expression *e,
                                                tree_argument_list *lst,
                                                int l, int c, char t)
    : tree_expression (l, c), m_expr (e), m_args (0), m_type (),
      m_arg_nm (), m_dyn_field (), m_word_list_cmd (false)
  {
    append (lst, t);
  }

  tree_index_expression::tree_index_expression (tree_expression *e,
                                                const std::string& n,
                                                int l, int c)
    : tree_expression (l, c), m_expr (e), m_args (0), m_type (),
      m_arg_nm (), m_dyn_field (), m_word_list_cmd (false)
  {
    append (n);
  }

  tree_index_expression::tree_index_expression (tree_expression *e,
                                                tree_expression *df,
                                                int l, int c)
    : tree_expression (l, c), m_expr (e), m_args (0), m_type (),
      m_arg_nm (), m_dyn_field (), m_word_list_cmd (false)
  {
    append (df);
  }

  tree_index_expression *
  tree_index_expression::append (tree_argument_list *lst, char t)
  {
    m_args.push_back (lst);
    m_type.append (1, t);
    m_arg_nm.push_back (lst ? lst->get_arg_names () : string_vector ());
    m_dyn_field.push_back (static_cast<tree_expression *> (nullptr));

    if (lst && lst->has_magic_tilde ())
      error ("invalid use of empty argument (~) in index expression");

    return this;
  }

  tree_index_expression *
  tree_index_expression::append (const std::string& n)
  {
    m_args.push_back (static_cast<tree_argument_list *> (nullptr));
    m_type += '.';
    m_arg_nm.push_back (n);
    m_dyn_field.push_back (static_cast<tree_expression *> (nullptr));

    return this;
  }

  tree_index_expression *
  tree_index_expression::append (tree_expression *df)
  {
    m_args.push_back (static_cast<tree_argument_list *> (nullptr));
    m_type += '.';
    m_arg_nm.push_back ("");
    m_dyn_field.push_back (df);

    return this;
  }

  tree_index_expression::~tree_index_expression (void)
  {
    delete m_expr;

    while (! m_args.empty ())
      {
        auto p = m_args.begin ();
        delete *p;
        m_args.erase (p);
      }

    while (! m_dyn_field.empty ())
      {
        auto p = m_dyn_field.begin ();
        delete *p;
        m_dyn_field.erase (p);
      }
  }

  // This is useful for printing the name of the variable in an indexed
  // assignment.

  std::string
  tree_index_expression::name (void) const
  {
    return m_expr->name ();
  }

  std::string
  tree_index_expression::get_struct_index
  (tree_evaluator& tw,
   std::list<string_vector>::const_iterator p_arg_nm,
   std::list<tree_expression *>::const_iterator p_dyn_field) const
  {
    std::string fn = (*p_arg_nm)(0);

    if (fn.empty ())
      {
        tree_expression *df = *p_dyn_field;

        if (df)
          {
            octave_value t = df->evaluate (tw);

            fn = t.xstring_value ("dynamic structure field names must be strings");
          }
        else
          panic_impossible ();
      }

    return fn;
  }

  octave_lvalue
  tree_index_expression::lvalue (tree_evaluator& tw)
  {
    std::list<octave_value_list> idx;

    int n = m_args.size ();

    auto p_args = m_args.begin ();
    auto p_arg_nm = m_arg_nm.begin ();
    auto p_dyn_field = m_dyn_field.begin ();

    octave_lvalue retval = m_expr->lvalue (tw);

    unwind_action
      act ([&tw] (const octave_value& val,
                  const std::string& index_type,
                  const std::list<octave_value_list>& index_list)
           {
             tw.set_indexed_object (val);
             tw.set_index_list (index_type, index_list);
           }, tw.indexed_object (), tw.index_type (), tw.index_list ());

    tw.set_indexed_object (retval.value ());
    tw.clear_index_list ();

    for (int i = 0; i < n; i++)
      {
        switch (m_type[i])
          {
          case '(':
            {
              octave_value_list tidx = tw.make_value_list (*p_args, *p_arg_nm);

              tw.append_index_list ('(', tidx);
              idx.push_back (tidx);
            }
            break;

          case '{':
            {
              octave_value_list tidx = tw.make_value_list (*p_args, *p_arg_nm);

              tw.append_index_list ('{', tidx);
              idx.push_back (tidx);
            }
            break;

          case '.':
            {
              octave_value tidx = get_struct_index (tw, p_arg_nm, p_dyn_field);

              tw.append_index_list ('.', tidx);
              idx.push_back (tidx);
            }
            break;

          default:
            panic_impossible ();
          }

        if (idx.back ().empty ())
          error ("invalid empty index list");

        p_args++;
        p_arg_nm++;
        p_dyn_field++;
      }

    retval.set_index (m_type, idx);

    return retval;
  }

  tree_index_expression *
  tree_index_expression::dup (symbol_scope& scope) const
  {
    tree_index_expression *new_idx_expr
      = new tree_index_expression (line (), column ());

    new_idx_expr->m_expr = (m_expr ? m_expr->dup (scope) : nullptr);

    std::list<tree_argument_list *> new_args;

    for (const tree_argument_list *elt : m_args)
      new_args.push_back (elt ? elt->dup (scope) : nullptr);

    new_idx_expr->m_args = new_args;

    new_idx_expr->m_type = m_type;

    new_idx_expr->m_arg_nm = m_arg_nm;

    std::list<tree_expression *> new_dyn_field;

    for (const tree_expression *elt : m_dyn_field)
      new_dyn_field.push_back (elt ? elt->dup (scope) : nullptr);

    new_idx_expr->m_dyn_field = new_dyn_field;

    new_idx_expr->copy_base (*this);

    return new_idx_expr;
  }

  // Unlike Matlab, which does not allow the result of a function call
  // or array indexing expression to be further indexed, Octave attempts
  // to handle arbitrary index expressions.  For example, Octave allows
  // expressions like
  //
  //   svd (rand (10))(1:5)
  //
  // Although octave_value objects may contain function objects, no
  // indexing operation or function call is supposed to return them
  // directly.  Instead, the language is supposed to only allow function
  // objects to be stored as function handles (named or anonymous) or as
  // inline functions.  The only place a function object should appear
  // directly is if the symbol stored in a tree_identifier object
  // resolves to a function.  This means that the only place we need to
  // look for functions is in the first element of the index
  // expression.
  //
  // Steps:
  //
  //  * Obtain the initial value from the expression component of the
  //    tree_index_expression object.  If it is a tree_identifier object
  //    indexed by '(args)' and the identifier is not a variable, then
  //    perform a function call.  Use the (optional) arguments to perform
  //    the function lookup so we choose the correct function or class
  //    method to call.  Otherwise, evaluate the first expression
  //    without any additional arguments.
  //
  //  * Iterate over the remaining elements of the index expression and
  //    call the octave_value::subsref method.  If indexing a class or
  //    classdef object, build up a list of indices for a call to the
  //    subsref method for the object.  Otherwise, use the result of
  //    each temporary evaluation for the next index element.
  //
  //  * If not indexing a class or classdef object and any partial
  //    expression evaluation produces a class or classdef object, then
  //    build up a complete argument list from that point on for a final
  //    subsref call for that object.
  //
  //    Multiple partial evaluations may be required.  For example,
  //    given a class or classdef object X, then for the expression
  //
  //      x.a{end}(2:end).b
  //
  //    we must evaluate x.a to obtain the size for the first {end}
  //    expression, then we must evaluate x.a{end} to obtain the size
  //    for the second (2:end) expression.  Finally, the complete
  //    expression may be evaluated.
  //
  //    If X is a cell array in the above expression, and none of the
  //    intermediate evaluations produces a class or classdef object,
  //    then the evaluation is performed as the following series of
  //    steps
  //
  //      tmp = x.a
  //      tmp = tmp{end}
  //      tmp = tmp(2:end)
  //      result = tmp.b
  //
  //    If any of the partial evaluations produces a class or classdef
  //    object, then the subsref method for that object is called as
  //    described above.  For example, suppose x.a produces a classdef
  //    object.  Then the evaluation is performed as the following
  //    series of steps
  //
  //      base_expr = tmp = x.a
  //      tmp = base_expr{end}
  //      base_expr{end}(2:end).b
  //
  //    In the last two steps, the partial value computed in the
  //    previous step is used to determine the value of END.

  octave_value_list
  tree_index_expression::evaluate_n (tree_evaluator& tw, int nargout)
  {
    octave_value_list retval;

    assert (! m_args.empty ());

    auto p_args = m_args.begin ();
    auto p_arg_nm = m_arg_nm.begin ();
    auto p_dyn_field = m_dyn_field.begin ();

    int n = m_args.size ();
    int beg = 0;

    octave_value base_expr_val;

    if (m_expr->is_identifier () && m_type[beg] == '(')
      {
        tree_identifier *id = dynamic_cast<tree_identifier *> (m_expr);

        bool is_var = tw.is_variable (m_expr);

        std::string nm =  id->name ();

        if (is_var && is_word_list_cmd ())
          error ("%s used as variable and later as function", nm.c_str ());

        if (! is_var)
          {
            octave_value_list first_args;

            tree_argument_list *al = *p_args;

            if (al && al->length () > 0)
              {
                unwind_action act ([&tw] (const std::list<octave_lvalue> *lvl)
                                   {
                                     tw.set_lvalue_list (lvl);
                                   }, tw.lvalue_list ());

                tw.set_lvalue_list (nullptr);

                string_vector anm = *p_arg_nm;

                first_args = tw.convert_to_const_vector (al);

                first_args.stash_name_tags (anm);
              }

            interpreter& interp = tw.get_interpreter ();

            symbol_table& symtab = interp.get_symbol_table ();

            octave_value val = symtab.find_function (nm, first_args);

            octave_function *fcn = nullptr;

            if (val.is_function ())
              fcn = val.function_value (true);

            if (fcn)
              {
                try
                  {
                    retval = fcn->call (tw, nargout, first_args);
                  }
                catch (index_exception& ie)
                  {
                    tw.final_index_error (ie, m_expr);
                  }

                beg++;
                p_args++;
                p_arg_nm++;
                p_dyn_field++;

                if (n > beg)
                  {
                    // More indices to follow.  Silently ignore
                    // extra output values.

                    if (retval.length () == 0)
                      error ("indexing undefined value");
                    else
                      base_expr_val = retval(0);
                  }
                else
                  {
                    // No more indices, so we are done.

                    // See note at end of function about deleting
                    // temporaries prior to pushing result.

                    base_expr_val = octave_value ();
                    first_args = octave_value_list ();

                    return retval;
                  }
              }
          }
      }

    if (base_expr_val.is_undefined ())
      base_expr_val = m_expr->evaluate (tw);

    // If we are indexing an object or looking at something like
    //
    //   classname.static_function (args, ...);
    //
    // then we'll just build a complete index list for one big subsref
    // call.  If the expression we are indexing is a classname then
    // base_expr_val will be an octave_classdef_meta object.  If we have
    // files in a +packagename folder, they will also be an
    // octave_classdef_meta object, but we don't want to index them.

    std::list<octave_value_list> idx_list;

    {
      // Note: need new scope so that the following unwind action will
      // happen before we perform the final indexing for objects (for
      // example).

      unwind_action
        act ([&tw] (const octave_value& val,
                    const std::string& index_type,
                    const std::list<octave_value_list>& index_list)
             {
               tw.set_indexed_object (val);
               tw.set_index_list (index_type, index_list);
             },
             tw.indexed_object (),
             tw.index_type (), tw.index_list ());

      tw.set_indexed_object ();
      tw.clear_index_list ();

      bool indexing_object = (base_expr_val.isobject ()
                              || base_expr_val.isjava ()
                              || (base_expr_val.is_classdef_meta ()
                                  && ! base_expr_val.is_package ()));

      octave_value partial_expr_val = base_expr_val;

      for (int i = beg; i < n; i++)
        {
          if (i > beg)
            {
              if (! indexing_object)
                {
                  // Evaluate what we have so far.

                  try
                    {
                      // Silently ignore extra output values.

                      octave_value_list tmp_list
                        = base_expr_val.subsref (m_type.substr (beg, i-beg),
                                                 idx_list, nargout);

                      partial_expr_val
                        = tmp_list.length () ? tmp_list(0) : octave_value ();

                      base_expr_val = partial_expr_val;

                      if (partial_expr_val.is_cs_list ())
                        err_indexed_cs_list ();

                      retval = partial_expr_val;

                      beg = i;
                      idx_list.clear ();
                      tw.clear_index_list ();

                      if (partial_expr_val.isobject ()
                          || partial_expr_val.isjava ()
                          || (partial_expr_val.is_classdef_meta ()
                              && ! partial_expr_val.is_package ()))
                        {
                          // Found an object, so now we'll build up
                          // complete index list for one big subsref
                          // call from this point on.

                          // FIXME: is is also possible to have a
                          // static method call buried somewhere in
                          // the depths of a complex indexing
                          // expression so that we would also need to
                          // check for an octave_classdef_meta object
                          // here?

                          indexing_object = true;
                        }
                    }
                  catch (index_exception& ie)
                    {
                      tw.final_index_error (ie, m_expr);
                    }
                }
            }

          tw.set_indexed_object (partial_expr_val);

          switch (m_type[i])
            {
            case '(':
              {
                octave_value_list tmp = tw.make_value_list (*p_args, *p_arg_nm);
                tw.append_index_list ('(', tmp);
                idx_list.push_back (tmp);
              }
              break;

            case '{':
              {
                octave_value_list tmp = tw.make_value_list (*p_args, *p_arg_nm);
                tw.append_index_list ('{', tmp);
                idx_list.push_back (tmp);
              }
              break;

            case '.':
              {
                octave_value tmp = get_struct_index (tw, p_arg_nm, p_dyn_field);
                tw.append_index_list ('.', tmp);
                idx_list.push_back (tmp);
              }
              break;

            default:
              panic_impossible ();
            }

          p_args++;
          p_arg_nm++;
          p_dyn_field++;
        }
    }

    // If ! idx_list.empty () that means we still have stuff to index
    // otherwise they would have been dealt with and idx_list would have
    // been emptied.
    if (! idx_list.empty ())
      {
        // This is for +package and other classdef_meta objects
        if (! base_expr_val.is_function ()
            || base_expr_val.is_classdef_meta ())
          {
            try
              {
                retval = base_expr_val.subsref (m_type.substr (beg, n-beg),
                                                idx_list, nargout);
                beg = n;
                idx_list.clear ();
              }
            catch (index_exception& ie)
              {
                tw.final_index_error (ie, m_expr);
              }
          }
        else
          {
            // FIXME: we want this to only be a superclass constructor
            // call Should we actually make a check for this or are all
            // other types of calls already dealt with?

            octave_function *fcn = base_expr_val.function_value ();

            if (fcn)
              {
                try
                  {
                    // FIXME: is it possible for the IDX_LIST to have
                    // more than one element here?  Do we need to check?

                    octave_value_list final_args;

                    if (idx_list.size () != 1)
                      error ("unexpected extra index at end of expression");

                    if (m_type[beg] != '(')
                      error ("invalid index type '%c' for function call",
                             m_type[beg]);

                    final_args = idx_list.front ();

                    // FIXME: Do we ever need the names of the arguments
                    // passed to FCN here?

                    retval = fcn->call (tw, nargout, final_args);
                  }
                catch (index_exception& ie)
                  {
                    tw.final_index_error (ie, m_expr);
                  }
              }
          }
      }

    // FIXME: when can the following happen?  In what case does indexing
    // result in a value that is a function?  Classdef method calls?
    // Something else?

    octave_value val = (retval.length () ? retval(0) : octave_value ());

    if (val.is_function ())
      {
        octave_function *fcn = val.function_value (true);

        if (fcn)
          {
            octave_value_list final_args;

            if (! idx_list.empty ())
              {
                if (n - beg != 1)
                  error ("unexpected extra index at end of expression");

                if (m_type[beg] != '(')
                  error ("invalid index type '%c' for function call",
                         m_type[beg]);

                final_args = idx_list.front ();
              }

            retval = fcn->call (tw, nargout, final_args);
          }
      }

    // Delete any temporary values prior to returning so that
    // destructors for any temporary classdef handle objects will be
    // called before we return.

    idx_list.clear ();
    base_expr_val = octave_value ();
    val = octave_value ();

    return retval;
  }
}

/*
%!test
%! clear x;
%! clear y;
%! y = 3;
%! x(y(end)) = 1;
%! assert (x, [0, 0, 1]);
%! clear x;
%! clear y;
%! y = {3};
%! x(y{end}) = 1;
%! assert (x, [0, 0, 1]);

%!test
%! x = {1, 2, 3};
%! [x{:}] = deal (4, 5, 6);
%! assert (x, {4, 5, 6});

%!test
%! [x.a, x.b.c] = deal (1, 2);
%! assert (x.a == 1 && x.b.c == 2);

%!test
%! [x.a, x(2).b] = deal (1, 2);
%! assert (x(1).a == 1 && isempty (x(2).a) && isempty (x(1).b) && x(2).b == 2);

%!test
%! x = struct (zeros (0, 1), {"a", "b"});
%! x(2).b = 1;
%! assert (x(2).b == 1);

%!test
%! x = struct (zeros (0, 1), {"a", "b"});
%! x(2).b = 1;
%! assert (x(2).b == 1);
*/