// Copyright (C) 2004, 2010 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// $Id$
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13

#ifndef __IPIPOPTAPPLICATION_HPP__
#define __IPIPOPTAPPLICATION_HPP__

#ifndef IPOPT_EXPORT
#ifdef _MSC_VER
#ifdef IPOPT_DLL
#define IPOPT_EXPORT(type) __declspec(dllexport) type __cdecl
#else
#define IPOPT_EXPORT(type) type __cdecl
#endif
#else
#define IPOPT_EXPORT(type) type
#endif
#endif

#include <iostream>

#include "IpJournalist.hpp"
#include "IpTNLP.hpp"
#include "IpNLP.hpp"
/* Return codes for the Optimize call for an application */
#include "IpReturnCodes.hpp"

namespace Ipopt
{
  DECLARE_STD_EXCEPTION(IPOPT_APPLICATION_ERROR);

  /* forward declarations */
  class IpoptAlgorithm;
  class IpoptNLP;
  class IpoptData;
  class IpoptCalculatedQuantities;
  class AlgorithmBuilder;
  class RegisteredOptions;
  class OptionsList;
  class SolveStatistics;

  /** This is the main application class for making calls to Ipopt. */
  class IpoptApplication : public ReferencedObject
  {
  public:
    IpoptApplication(bool create_console_out = true,
                     bool create_empty = false);

    /** Another constructor that assumes that the code in the
     *  (default) constructor has already been executed */
    IpoptApplication(SmartPtr<RegisteredOptions> reg_options,
                     SmartPtr<OptionsList> options,
                     SmartPtr<Journalist> jnlst);

    virtual ~IpoptApplication();

    /** Method for creating a new IpoptApplication that uses the same
     *  journalist and registered options, and a copy of the options
    list. */
    virtual SmartPtr<IpoptApplication> clone();

    /** Initialization method. This method reads options from the
     *  input stream and initializes the journalists. It returns
     *  something other than Solve_Succeeded if there was a
     *  problem in the initialization (such as an invalid option).
     *  You should call one of the initialization methods at some
     *  point before the first optimize call.
     */
    virtual ApplicationReturnStatus Initialize(std::istream& is);
    /** Initialization method. This method reads options from the
     *  params file and initializes the journalists. It returns
     *  something other than Solve_Succeeded if there was a
     *  problem in the initialization (such as an invalid option).
     *  You should call one of the initialization methods at some
     *  point before the first optimize call.
     *  Note: You can skip the processing of a params file by
     *  setting params_file to "".
     */
    virtual ApplicationReturnStatus Initialize(std::string params_file);
    /** Initialize method. This method reads the options file specified
     *  by the option_file_name option and initializes the journalists.
     *  You should call this method at some point before the first optimize
     *  call.
     *  It returns something other than Solve_Succeeded if there was a
     *  problem in the initialization (such as an invalid option).
     */
    virtual ApplicationReturnStatus Initialize();

    /**@name Solve methods */
    //@{
    /** Solve a problem that inherits from TNLP */
    virtual ApplicationReturnStatus OptimizeTNLP(const SmartPtr<TNLP>& tnlp);

    /** Solve a problem that inherits from NLP */
    virtual ApplicationReturnStatus OptimizeNLP(const SmartPtr<NLP>& nlp);

    /** Solve a problem that inherits from NLP */
    virtual ApplicationReturnStatus OptimizeNLP(const SmartPtr<NLP>& nlp, SmartPtr<AlgorithmBuilder>& alg_builder);

    /** Solve a problem (that inherits from TNLP) for a repeated time.
     *  The OptimizeTNLP method must have been called before.  The
     *  TNLP must be the same object, and the structure (number of
     *  variables and constraints and position of nonzeros in Jacobian
     *  and Hessian must be the same). */
    virtual ApplicationReturnStatus ReOptimizeTNLP(const SmartPtr<TNLP>& tnlp);

    /** Solve a problem (that inherits from NLP) for a repeated time.
     *  The OptimizeNLP method must have been called before.  The
     *  NLP must be the same object, and the structure (number of
     *  variables and constraints and position of nonzeros in Jacobian
     *  and Hessian must be the same). */
    virtual ApplicationReturnStatus ReOptimizeNLP(const SmartPtr<NLP>& nlp);
    //@}

    /** Method for opening an output file with given print_level.
     *  Returns false if there was a problem. */
    virtual bool OpenOutputFile(std::string file_name, EJournalLevel print_level);

    /**@name Accessor methods */
    //@{
    /** Get the Journalist for printing output */
    virtual SmartPtr<Journalist> Jnlst()
    {
      return jnlst_;
    }

    /** Get a pointer to RegisteredOptions object to
     *  add new options */
    virtual SmartPtr<RegisteredOptions> RegOptions()
    {
      return reg_options_;
    }

    /** Get the options list for setting options */
    virtual SmartPtr<OptionsList> Options()
    {
      return options_;
    }

    /** Get the options list for setting options (const version) */
    virtual SmartPtr<const OptionsList> Options() const
    {
      return ConstPtr(options_);
    }

    /** Get the object with the statistics about the most recent
     *  optimization run. */
    virtual SmartPtr<SolveStatistics> Statistics();

    /** Get the IpoptNLP Object */
    virtual SmartPtr<IpoptNLP> IpoptNLPObject();

    /** Get the IpoptData Object */
    SmartPtr<IpoptData> IpoptDataObject();

    /** Get the IpoptCQ Object */
    virtual SmartPtr<IpoptCalculatedQuantities> IpoptCQObject();

    /** Get the Algorithm Object */
    SmartPtr<IpoptAlgorithm> AlgorithmObject();
    //@}

    /** Method for printing Ipopt copyright message now instead of
     *  just before the optimization.  If you want to have the copy
     *  right message printed earlier than by default, call this
     *  method at the convenient time.  */
    void PrintCopyrightMessage();

    /** Method to set whether non-ipopt non-bad_alloc exceptions
     * are rethrown by Ipopt.
     * By default, non-Ipopt and non-std::bad_alloc exceptions are
     * caught by Ipopts initialization and optimization methods
     * and the status NonIpopt_Exception_Thrown is returned.
     * This function allows to enable rethrowing of such exceptions.
     */
    void RethrowNonIpoptException(bool dorethrow)
    {
       rethrow_nonipoptexception_ = dorethrow;
    }

    /** @name Methods for IpoptTypeInfo */
    //@{
    static void RegisterOptions(SmartPtr<RegisteredOptions> roptions);
    //@}

    /** Method to registering all Ipopt options. */
    static void
    RegisterAllIpoptOptions(const SmartPtr<RegisteredOptions>& roptions);

  private:
    /**@name Default Compiler Generated Methods
     * (Hidden to avoid implicit creation/calling).
     * These methods are not implemented and 
     * we do not want the compiler to implement
     * them for us, so we declare them private
     * and do not define them. This ensures that
     * they will not be implicitly created/called. */
    //@{
    /** Default Constructor */
    // IpoptApplication();

    /** Copy Constructor */
    IpoptApplication(const IpoptApplication&);

    /** Overloaded Equals Operator */
    void operator=(const IpoptApplication&);
    //@}

    /** Method for the actual optimize call of the Ipopt algorithm.
     *  This is used both for Optimize and ReOptimize */
    ApplicationReturnStatus call_optimize();

    /**@name Variables that customize the application behavior */
    //@{
    /** Decide whether or not the ipopt.opt file should be read */
    bool read_params_dat_;

    /** Decide whether non-ipopt non-bad_alloc exceptions should be rethrown */
    bool rethrow_nonipoptexception_;
    //@}

    /** Journalist for reporting output */
    SmartPtr<Journalist> jnlst_;

    /** RegisteredOptions */
    SmartPtr<RegisteredOptions> reg_options_;

    /** OptionsList used for the application */
    SmartPtr<OptionsList> options_;

    /** Object for storing statistics about the most recent
     *  optimization run. */
    SmartPtr<SolveStatistics> statistics_;

    /** Object with the algorithm sceleton.
     */
    SmartPtr<IpoptAlgorithm> alg_;

    /** IpoptNLP Object for the NLP.  We keep this around for a
     *  ReOptimize warm start. */
    SmartPtr<IpoptNLP> ip_nlp_;

    /** IpoptData Object for the NLP.  We keep this around for a
     *  ReOptimize warm start.
     */
    SmartPtr<IpoptData> ip_data_;

    /** IpoptCalculatedQuantities Object for the NLP.  We keep this
     *  around for a ReOptimize warm start.
     */
    SmartPtr<IpoptCalculatedQuantities> ip_cq_;

    /** Pointer to the TNLPAdapter used to convert the TNLP to an NLP.
     *  We keep this around for the ReOptimizerTNLP call. */
    SmartPtr<NLP> nlp_adapter_;

    /** @name Algorithmic parameters */
    //@{
    /** Flag indicating if we are to use the inexact linear solver option */
    bool inexact_algorithm_;
    /** Flag indicating if all bounds should be replaced by inequality
     *  constraints.  This is necessary for the inexact algorithm. */
    bool replace_bounds_;
    //@}
  };

} // namespace Ipopt

extern "C" IPOPT_EXPORT(class Ipopt::IpoptApplication *) IpoptApplicationFactory();

#endif
