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

#include "Job.h"
#include "StatusLine.h"
#include "FileCopy.h"

class CopyJob : public Job
{
protected:
   SMTaskRef<FileCopy> c;
   bool done;
   xstring_c name; // file name
   xstring_c dispname; // displayed file name
   xstring_c op;   // command name
   bool no_status;
   bool no_status_on_write;
   bool clear_status_on_write;
   bool quiet;

   void SetDispName();

   void PrepareToDie();

public:
   CopyJob(FileCopy *c1,const char *n,const char *op1);
   ~CopyJob();

   void NoStatus(bool t=true) { no_status=t; }
   void NoStatusOnWrite() { no_status_on_write=true; }
   void ClearStatusOnWrite() { clear_status_on_write=true; }
   bool HasStatus() const { return !no_status; }
   void Quiet(bool q) { quiet=q; }

   int Do();
   int Done() { return done; }
   int ExitCode();

   void SuspendInternal() { c->SuspendSlave(); }
   void ResumeInternal()  { c->ResumeSlave(); }
   void Fg() { if(c) c->Fg(); Job::Fg(); }
   void Bg() { Job::Bg(); if(c) c->Bg(); }

   int AcceptSig(int sig);
   pid_t GetProcGroup() { return c?c->GetProcGroup():0; }

   bool Error() { return c->Error(); }
   const char *ErrorText() { return c->ErrorText(); }
   double GetTimeSpent() { return c->GetTimeSpent(); }
   off_t GetBytesCount() { return c->GetBytesCount(); }
   double GetTransferRate() { return c->GetTransferRate(); }
   off_t GetSize() { return c->GetSize(); }
   off_t GetPos()  { return c->GetPos(); }
   float GetRate() { return c->GetRate(); }
   long GetETA() { return c->GetETA(); }
   long GetETA(off_t rem) { return c->GetETA(rem); }
   const char *GetETAStrSFromTime(time_t t) { return c->GetETAStrSFromTime(t); }
   void SetRange(off_t s,off_t lim) { c->SetRange(s,lim); }
   void SetRangeLimit(off_t lim) { return c->SetRangeLimit(lim); }
   void SetDate(const FileTimestamp& d) { c->SetDate(d); }
   void SetSize(off_t s)   { c->SetSize(s); }
   const SMTaskRef<FileCopy>& GetCopy() const { return c; }
   const SMTaskRef<FileCopyPeer>& GetPut() const { return c->put; }
   const SMTaskRef<FileCopyPeer>& GetGet() const { return c->get; }

   const Ref<FDStream>& GetLocal() const { return GetPut()->GetLocal(); }

   const char *Status(const StatusLine *s,bool base=false);
   void ShowRunStatus(const SMTaskRef<StatusLine>&);
   xstring& FormatStatus(xstring&,int,const char *);

   const char *GetName() const { return name; }
   const char *GetDispName() const { return dispname; }
   const char *SqueezeName(int w, bool base=false);

   static CopyJob *NewGet(FileAccess *f,const char *src,const char *dst);
   static CopyJob *NewPut(FileAccess *f,const char *src,const char *dst);

   static const char *FormatBytesTimeRate(off_t bytes,double time);
};
class CopyJobCreator
{
public:
   virtual CopyJob *New(FileCopy *c,const char *n,const char *o) const = 0;
   virtual ~CopyJobCreator() {}
};

class ArgV;
class CopyJobEnv : public SessionJob
{
protected:
   CopyJob *cp;
   bool done;
   int errors;
   int count;
   int parallel;
   off_t bytes;
   TimeDate transfer_start_ts;
   double time_spent;
   const char *op;
   bool no_status;
   xstring_c cwd;
   bool cont;
   bool ascii;
   bool quiet;
   Ref<ArgV> args;

   virtual void NextFile() = 0;

   void SetCopier(FileCopy *c,const char *n);
   void AddCopier(FileCopy *c,const char *n);

   Ref<CopyJobCreator> cj_new;

public:
   int Do();
   int Done();
   virtual int ExitCode() { return errors!=0; }

   int AcceptSig(int sig);

   CopyJobEnv(FileAccess *s,ArgV *a,bool c=false);
   ~CopyJobEnv();

   void SetCopyJobCreator(CopyJobCreator *c) { cj_new=c; }

   void SayFinal();
   xstring& FormatFinalWithPrefix(xstring&,const char *);
   xstring& FormatStatus(xstring&,int,const char *);

   void Ascii() { ascii=true; }

   double GetTimeSpent() { return time_spent+(waiting.count()>0?now-transfer_start_ts:0.); }
   off_t GetBytesCount() { return bytes+Job::GetBytesCount(); }

   void Quiet(bool q) { quiet=q; }

   void SetParallel(int n) { parallel=n; }
};

#endif // COPYJOB_H