/*

 * lftp - file transfer program

 *

 * Copyright (c) 1996-2016 by Alexander V. Lukyanov (lav@yars.free.net)

 *

 * This program 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.

 *

 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef CMDEXEC_H

#define CMDEXEC_H

#include <stdarg.h>

#include "Job.h"

#include "ArgV.h"

#include "Filter.h"

#include "alias.h"

#include "History.h"

#include "bookmark.h"

#include "FileGlob.h"

class QueueFeeder;

class LocalDirectory;

extern History cwd_history;

#define	CMD(name) Job *cmd_##name(CmdExec *parent)

typedef Job * (*cmd_creator_t)(class CmdExec *parent);

class CmdFeeder

{

public:

   xstring_c saved_buf;

   CmdFeeder *prev;

   virtual const char *NextCmd(class CmdExec *exec,const char *prompt) = 0;

   virtual ~CmdFeeder() {}

   virtual void clear() {}

   virtual bool RealEOF() { return true; }

   virtual void Fg() {}

   virtual void Bg() {}

   virtual bool IsInteractive() const { return false; }

};

extern CmdFeeder *lftp_feeder;	 // feeder to use after 'lftp' command

class CmdExec : public SessionJob, public ResClient

{

public:

// current command data

   Ref<ArgV> args;

   Ref<FDStream> output;

   bool background;

   int	 exit_code;

   int	 prev_exit_code;

private:

   CmdExec *parent_exec;

   Buffer cmd_buf;

   bool partial_cmd;

   int alias_field; // length of expanded alias (and ttl for used_aliases)

   int failed_exit_code;

   TouchedAlias *used_aliases;

   void free_used_aliases();

   void skip_cmd(int len);

   enum

   {

      COND_ANY,

      COND_AND,

      COND_OR

   }

      condition;

   struct cmd_rec

   {

      const char  *name;

      cmd_creator_t creator;

      const char  *short_desc;

      const char  *long_desc;

      static int cmp(const CmdExec::cmd_rec *a,const CmdExec::cmd_rec *b);

   };

   static const cmd_rec static_cmd_table[];

   static const int static_cmd_table_length;

   static xarray<cmd_rec> dyn_cmd_table;

   static int find_cmd(const char *cmd_name,const cmd_rec **ret);

   void exec_parsed_command();

   enum parse_result

   {

      PARSE_OK,

      PARSE_ERR,

      PARSE_AGAIN

   };

   parse_result parse_one_cmd();

   CmdFeeder *feeder;

   bool feeder_called;

   bool fed_at_finish;

   void AtFinish();

   enum builtins

   {

      BUILTIN_NONE=0,

      BUILTIN_OPEN,

      BUILTIN_CD,

      BUILTIN_EXEC_RESTART,

      BUILTIN_GLOB

   }

      builtin;

   FileAccess::Path old_cwd;

   xstring_c old_lcwd;

   xstring_c slot;

   Ref<GlobURL> glob;

   Ref<ArgV> args_glob;

   int redirections;

   static CmdExec *chain;

   CmdExec *next;

   QueueFeeder *queue_feeder;

   CmdExec *GetQueue(bool create = true);

   bool SameQueueParameters(CmdExec *,const char *);

   int max_waiting;

   FileAccessRef saved_session;

   void ReuseSavedSession();

   void RevertToSavedSession();

   void init(LocalDirectory *c);

public:

   void FeedCmd(const char *c);

   void FeedArgV(const ArgV *,int start=0);

   void PrependCmd(const char *c);

   void ExecParsed(ArgV *a,FDStream *o=0,bool b=false);

   static bool needs_quotation(const char *buf,int len);

   static bool needs_quotation(const char *buf) { return needs_quotation(buf,strlen(buf)); }

   static bool quotable(char c,char in_quotes);

   static bool is_space(char c) { return c==' ' || c=='\t'; }

   static bool is_quote(char c) { return c=='"' || c=='\''; }

   void FeedQuoted(const char *c);

   void Exit(int);

   void AtExit();

   void AtExitBg();

   void AtExitFg();

   void AtBackground();

   void AtTerminate();

   void EmptyCmds();

   bool WriteCmds(int fd) const;

   bool ReadCmds(int fd); // does not clear queue before reading (appends)

   void AddNewJob(Job *new_job);

   void SuspendJob(Job *j);

   CmdExec(FileAccess *s,LocalDirectory *c);

   CmdExec(CmdExec *parent);

   ~CmdExec();

   bool Idle();	// when we have no command running and command buffer is empty

   int Done();

   int ExitCode() { return failed_exit_code ? failed_exit_code : exit_code; }

   int Do();

   xstring& FormatStatus(xstring&,int,const char *prefix="\t");

   void ShowRunStatus(const SMTaskRef<StatusLine>& s);

   int AcceptSig(int sig);

   const char *FormatPrompt(const char *scan);

   const char *MakePrompt();

   bool interactive;

   bool show_status;

   bool top_level;

   bool verbose;

   bool auto_terminate_in_bg;

   SMTaskRef<StatusLine> status_line;

   void SetCmdFeeder(CmdFeeder *new_feeder);

   void	RemoveFeeder();

   friend char *command_generator(char *,int);	  // readline completor

   static const char *GetFullCommandName(const char *);

   bool	 remote_completion;

   int	 long_running;

   bool	 csh_history;

   bool	 verify_host;

   bool	 verify_path;

   bool	 verify_path_cached;

   void	 Reconfig(const char *name=0);

   void	 beep_if_long();

   time_t start_time;

   static CmdExec *cwd_owner;

   Ref<LocalDirectory> cwd;

   void	 SaveCWD();

   int	 RestoreCWD();

   FDStream *default_output;

   void top_vfprintf(FILE *file,const char *f,va_list v);

   void SetInteractive(bool i);

   void SetInteractive();

   void SetTopLevel()

      {

	 top_level=true;

	 Reconfig(0);

	 SetInteractive();

      }

   void SetStatusLine(StatusLine *s) { status_line=s; }

   void SetAutoTerminateInBackground(bool b) { auto_terminate_in_bg=b; }

   static void RegisterCommand(const char *name,cmd_creator_t creator,

      const char *short_name=0,const char *long_name=0);

   Job *builtin_lcd();

   Job *builtin_cd();

   Job *builtin_open();

   Job *builtin_exit();

   Job *builtin_lftp();

   Job *builtin_restart();

   Job *builtin_glob();

   Job *builtin_queue();

   Job *builtin_queue_edit();

   Job *builtin_local();

   bool load_cmd_module(const char *op);

   Job *default_cmd();

   void ChangeSession(FileAccess *new_session);

   bool print_cmd_help(const char *cmd);

   void print_cmd_index();

   static const char *CmdByIndex(int i);

   void enable_debug(const char *opt=0);

   int	 last_bg;

   bool	 wait_all;

   void pre_stdout();

   void ChangeSlot(const char *n);

   static JobRef<CmdExec> top;

};

extern const char * const bookmark_subcmd[];

extern const char * const cache_subcmd[];

#endif//CMDEXEC_H