/*
 * 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 SMTASK_H
#define SMTASK_H

#include "PollVec.h"
#include "TimeDate.h"
#include "Ref.h"
#include "xarray.h"
#include "xlist.h"
#include "misc.h"
#include "Error.h"
#include <errno.h>

class SMTask
{
   virtual int Do() = 0;

   // all tasks list
   static xlist_head<SMTask> all_tasks;
   xlist<SMTask> all_tasks_node;

   // ready (not suspended) tasks list
   static xlist_head<SMTask> ready_tasks;
   xlist<SMTask> ready_tasks_node;

   // just created or resumed tasks
   static xlist_head<SMTask> new_tasks;
   xlist<SMTask> new_tasks_node;

   // deleted and going to be destroyed tasks
   static xlist_head<SMTask> deleted_tasks;
   xlist<SMTask> deleted_tasks_node;

   static PollVec block;
   enum { SMTASK_MAX_DEPTH=64 };
   static SMTask *stack[SMTASK_MAX_DEPTH];
   static int stack_ptr;

   bool	 suspended;
   bool	 suspended_slave;

   int	 running;
   int	 ref_count;
   bool	 deleting;

   int ScheduleThis();
   static int ScheduleNew();

protected:
   enum
   {
      STALL=0,
      MOVED=1,	  // STALL|MOVED==MOVED.
      WANTDIE=2	  // for AcceptSig
   };

   // SuspendInternal and ResumeInternal usually suspend and resume slave tasks
   virtual void SuspendInternal() {}
   virtual void ResumeInternal();
   virtual void PrepareToDie() {}  // it is called from Delete no matter of running and ref_count

   bool Deleted() const { return deleting; }
   virtual ~SMTask();

public:
   static void Block(int fd,int mask) { block.AddFD(fd,mask); }
   static void TimeoutU(int us) { block.AddTimeoutU(us); }
   static void Timeout(int ms) { TimeoutU(1000*ms); }
   static void TimeoutS(int s) { TimeoutU(1000000*s); }
   static bool Ready(int fd,int mask) { return block.FDReady(fd,mask); }
   static void SetNotReady(int fd,int mask) { block.FDSetNotReady(fd,mask); }

   static TimeDate now;
   static void UpdateNow() { now.SetToCurrentTime(); }

   static void Schedule();
   static int CollectGarbage();
   static void Block();
   static time_t last_block;

   void Suspend();
   void Resume();

   // SuspendSlave and ResumeSlave are used in SuspendInternal/ResumeInternal
   // to suspend/resume slave tasks
   void SuspendSlave();
   void ResumeSlave();

   bool IsSuspended() { return suspended|suspended_slave; }

   virtual const char *GetLogContext() { return 0; }
   static const char *GetCurrentLogContext() { return current->GetLogContext(); }

   SMTask();

   void DeleteLater();
   static void Delete(SMTask *);
   void IncRefCount() { ref_count++; }
   void DecRefCount() { if(ref_count>0) ref_count--; }
   static SMTask *_MakeRef(SMTask *task) { if(task) task->IncRefCount(); return task; }
   static void _DeleteRef(SMTask *task)  { if(task) { task->DecRefCount(); Delete(task); } }
   static SMTask *_SetRef(SMTask *task,SMTask *new_task);
   template<typename T> static T *MakeRef(T *task) { _MakeRef(task); return task; }
   static int Roll(SMTask *);
   int Roll() { return Roll(this); }
   static void RollAll(const TimeInterval &max_time);

   static SMTask *current;

   static void Enter(SMTask *task);
   static void Leave(SMTask *task);
   void Enter() { Enter(this); }
   void Leave() { Leave(this); }

   static int TaskCount();
   static void PrintTasks();
   static bool NonFatalError(int err);
   static bool TemporaryNetworkError(int err) { return temporary_network_error(err); }
   static Error *SysError(int e=errno) { return new Error(e,strerror(e),!NonFatalError(e)); }

   static void Cleanup();
};

class SMTaskInit : public SMTask
{
   int Do();
public:
   SMTaskInit();
   ~SMTaskInit();
};

template<class T> class SMTaskRef
{
   SMTaskRef<T>(const SMTaskRef<T>&);  // disable cloning
   void operator=(const SMTaskRef<T>&);   // and assignment

protected:
   T *ptr;

public:
   SMTaskRef() { ptr=0; }
   SMTaskRef<T>(T *p) : ptr(SMTask::MakeRef(p)) {}
   ~SMTaskRef<T>() { SMTask::_DeleteRef(ptr); ptr=0; }
   void operator=(T *p) { ptr=static_cast<T*>(SMTask::_SetRef(ptr,p)); }
   operator const T*() const { return ptr; }
   T *operator->() const { return ptr; }
   T *borrow() { if(ptr) ptr->DecRefCount(); return replace_value(ptr,(T*)0); }
   const T *get() const { return ptr; }
   T *get_non_const() const { return ptr; }

   template<class C> const SMTaskRef<C>& Cast() const
      { void(static_cast<C*>(ptr)); return *(const SMTaskRef<C>*)this; }

   static const SMTaskRef<T> null;

   void _set(T *p) { ptr=p; }
   void _clear() { ptr=0; }
   void unset() { *this=0; }
};

template<typename T>
class TaskRefArray : public _RefArray< T,SMTaskRef<T> > {
   TaskRefArray& operator=(const TaskRefArray&); // make assignment fail
   TaskRefArray(const TaskRefArray&);	       // disable cloning
public:
   TaskRefArray() : _RefArray< T,SMTaskRef<T> >() {}
};

#endif /* SMTASK_H */