/*
 * lftp - file transfer program
 *
 * Copyright (c) 1996-2015 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 FILTER_H
#define FILTER_H

#include "ProcWait.h"
#include "ArgV.h"

struct FileTimestamp;

class FDStream
{
   bool close_when_done;

protected:
   bool closed;

   void DoCloseFD();
   void SetFD(int new_fd,bool c);

public:
   int fd;
   xstring_c name;
   xstring_c full_name;
   xstring_c cwd;
   xstring error_text;
   const char *status;

   bool	 error() { return error_text!=0; }

   virtual int getfd() { return fd; }
   bool is_closed() const { return closed; }

   FDStream();
   FDStream(int new_fd,const char *new_name);
   virtual ~FDStream();

   void MakeErrorText(int e=0);
   bool NonFatalError(int err);
   void set_status(const char *str) { status=str; }
   void clear_status() { status=0; }
   void CloseWhenDone() { close_when_done=true; }

   void SetCwd(const char *);
   const char *GetCwd() const { return cwd; }

   virtual off_t get_size() { return -1; }
   virtual void setmtime(const FileTimestamp &) {}
   virtual bool can_setmtime() { return false; }
   virtual void remove_if_empty() {}
   virtual void remove() {}
   virtual bool Done();
   virtual bool usesfd(int n_fd) { return fd==n_fd; }
   virtual void Kill(int=SIGTERM) {}
   virtual pid_t GetProcGroup() const { return 0; }
   virtual bool broken() { return false; }
   virtual bool can_seek() { return false; }
   virtual void revert_backup() {}
   virtual void remove_backup() {}
};

class OutputFilter : public FDStream
{
   Ref<ArgV> a;
   ProcWait *w;
   pid_t pg;

   Ref<FDStream> my_second;
   const Ref<FDStream>& second;

   bool stderr_to_stdout;
   bool stdout_to_null;

   void Init();

   virtual void Parent(int *p);	 // what to do with pipe if parent
   virtual void Child (int *p);	 // same for child

protected:
   int second_fd;

public:
   OutputFilter(const char *filter,int second_fd=-1);
   OutputFilter(const char *filter,FDStream *second);
   OutputFilter(const char *filter,const Ref<FDStream>& second);
   OutputFilter(ArgV *a,int second_fd=-1);
   OutputFilter(ArgV *a,FDStream *second);
   OutputFilter(ArgV *a,const Ref<FDStream>& second);
   virtual ~OutputFilter();

   void StderrToStdout() { stderr_to_stdout=true; }
   void StdoutToNull() { stdout_to_null=true; }

   int getfd();
   bool Done();

   bool usesfd(int n_fd);
   void Kill(int sig=SIGTERM);
   pid_t GetProcGroup() const { return pg; }
   void SetProcGroup(pid_t new_pg) { pg=new_pg; }
   ProcWait::State GetProcState() { return w->GetState(); }
   int GetProcExitCode() { return w->GetInfo()>>8; }

   bool broken();
};

class InputFilter : public OutputFilter
{
   virtual void Parent(int *p);
   virtual void Child (int *p);
public:
   InputFilter(const char *filter,int second_fd=-1)
      : OutputFilter(filter,second_fd) {}
   InputFilter(const char *filter,FDStream *second)
      : OutputFilter(filter,second) {}
   InputFilter(ArgV *a,int second_fd=-1)
      : OutputFilter(a,second_fd) {}
   InputFilter(ArgV *a,FDStream *second)
      : OutputFilter(a,second) {}
};

class FileStream : public FDStream
{
   int mode;
   mode_t create_mode;
   bool do_lock;
   bool no_keep_backup;

   xstring_c backup_file;
   mode_t old_file_mode;
public:
   FileStream(const char *fname,int open_mode);
   ~FileStream();

   void setmtime(const FileTimestamp &);
   bool can_setmtime() { return true; }
   void remove_if_empty();
   void remove();
   int getfd();
   bool can_seek();
   off_t get_size();
   void set_lock(bool flag=true) { do_lock=flag; }
   void set_create_mode(mode_t m) { create_mode=m; }
   void revert_backup();
   void remove_backup();
   void dont_keep_backup() { no_keep_backup=true; }
};

#endif /* FILTER_H */