class Message;
class MsgBase;
class SquishMsgBase;
class HudsonMsgBase;
class JamMsgBase;
class MsgArea;
class MessageIndex;

class HudsonMsgIdx;
class HudsonMsgHdr;
class HudsonMsgToIdx;
class HudsonMsgInfo;

class JamFileHeader;
class JamHeader;
class JamExtHeader;
class JamIndex;
class JamLastRead;

class MsgBase
  {
 public:
   MsgBase() {}
   virtual ~MsgBase() {}

   virtual bool open()   = 0;
   virtual void close()  = 0;

   virtual bool lock()   { return TRUE; }
   virtual bool unlock() { return TRUE; }

   virtual long readMsg(Message& msg , long num)                                = 0;
   virtual word readMsgText(Message& msg, char *text, long offset , word size)  = 0;
   virtual word scanMail(MessageIndex *mi,word maxmsgs)                         = 0;
   virtual long appendMsg(Message&)                                             = 0;
   virtual bool updateMsg(Message&)                                             = 0;

   virtual long highMsg(MsgArea&)                                               = 0;
   virtual long lowMsg (MsgArea&)                                               = 0;
   virtual long numMsgs(MsgArea&)                                               = 0;
   virtual long totalMsgs()                                                     = 0;

   virtual bool deleteMsg(Message&)                                             = 0;

   virtual long lastRead(MsgArea&,long rec)                                     = 0;
   virtual void setLastRead(MsgArea&,long rec,long num)                         = 0;

   virtual long msgNum(MsgArea&,long id)                                        = 0;
   virtual long msgId (MsgArea&,long num)                                       = 0;
  };

class SquishMsgBase : public MsgBase
  {
   MSG *lastarea;
   int lastareanum;

   MSG *readArea(MsgArea&);
 public:
   SquishMsgBase()   { open();  }
   ~SquishMsgBase()  { close(); }

   bool open();
   void close();

   bool lock()   { return TRUE; }
   bool unlock() { return TRUE; }

   long readMsg(Message& msg , long num);
   word readMsgText(Message& msg, char *text, long offset , word size);
   word scanMail(MessageIndex *mi,word maxmsgs);
   long appendMsg(Message&);
   bool updateMsg(Message&);

   long highMsg(MsgArea&);
   long lowMsg (MsgArea&);
   long numMsgs(MsgArea&);
   long totalMsgs() { return 0; }

   bool deleteMsg(Message&);

   long lastRead(MsgArea&,long rec);
   void setLastRead(MsgArea&,long rec,long num);

   long msgNum(MsgArea&,long id);
   long msgId (MsgArea&,long num);
  };

class HudsonMsgBase : public MsgBase
  {
   File f_msghdr;
   File f_msgtxt;
   File f_msgtoidx;
   File f_msgidx;
   File f_msginfo;

   HudsonMsgIdx *lastMsgIdx;
   int          *highArray;
   int          *lastReadArray;
   long lastIndex;
   long lastReadRecord;
   ///////////////////

   void flushCache();
   void readHighArray();
   void readLastRead(long record);

   void readInfo(HudsonMsgInfo&);
   void writeInfo(HudsonMsgInfo&);

   long findIdx(HudsonMsgIdx &mi,int num,int area,int order);

 public:
   HudsonMsgBase();
   ~HudsonMsgBase();

   bool open();
   void close();

   bool lock();
   bool unlock();

   long readMsg(Message& msg , long num);
   word readMsgText(Message& msg, char *text, long offset , word size);
   word scanMail(MessageIndex *mi,word maxmsgs);
   long appendMsg(Message&);
   bool updateMsg(Message&);

   long highMsg(MsgArea&);
   long lowMsg (MsgArea&);
   long numMsgs(MsgArea&);
   long totalMsgs();

   bool deleteMsg(Message&);

   long lastRead(MsgArea&,long rec);
   void setLastRead(MsgArea&,long rec,long num);

   long msgNum(MsgArea&,long id);
   long msgId(MsgArea& ma, long num);
  };

class JamMsgBase : public MsgBase
  {
   File f_jhr;
   File f_jdt;
   File f_jdx;
   File f_jlr;

   int            lastAreaNum;
   JamFileHeader *jamHeader;

   bool      openArea( MsgArea& );

   bool      jamLock();
   bool      jamUnLock();

   bool      readHeader();
   bool      writeHeader();

   long      findIdx( JamIndex &mi,long num,int order );

 public:
   JamMsgBase();
   ~JamMsgBase();

   bool open();
   void close();

   bool lock()    { return TRUE; }
   bool unlock()  { return TRUE; }

   long readMsg(Message& msg , long num);
   word readMsgText(Message& msg, char *text, long offset , word size);
   word scanMail(MessageIndex *mi,word maxmsgs);
   long appendMsg(Message&);
   bool updateMsg(Message&);

   long highMsg(MsgArea&);
   long lowMsg (MsgArea&);
   long numMsgs(MsgArea&);
   long totalMsgs()
      {
         return 0;
      }

   bool deleteMsg(Message&);

   long lastRead(MsgArea&,long rec);
   void setLastRead(MsgArea&,long rec,long num);

   long msgNum(MsgArea&,long id);
   long msgId (MsgArea&,long num);
  };


class MsgBaseList
  {
   MsgBase *mblist[5];
  public:
    MsgBaseList();
   ~MsgBaseList();

   void add(MsgBase *);

   void close();
   void open();
   bool lock();
   bool unlock();

   word scanMail(MessageIndex *,word maxmsgs);
   long totalMsgs();
  };

class MsgArea : public _MsgArea
  {
   static File f;
   static int lastAreaNum;
   static MsgArea *lastArea;
   static int numAreas;

   static void open();
 public:
   MsgBase *msgBase;

   bool read(int);
   bool sysopAccess();

   static void close();
   static int  highAreaNum();

   long numMsgs()
      {
         return (msgBase==NULL) ? 0L : msgBase->numMsgs(*this);
      }
   long lowMsg()
      {
         return (msgBase==NULL) ? 0L : msgBase->lowMsg (*this);
      }
   long highMsg()
      {
         return (msgBase==NULL) ? 0L : msgBase->highMsg(*this);
      }
   long lastRead(long rec)
      {
         return (msgBase==NULL) ? 0L : msgBase->lastRead(*this,rec);
      }
   void setLastRead(long rec,long num)
      {
         if(msgBase)
            msgBase->setLastRead(*this,rec,num);
      }
   long msgNum(long id)
      {
         return (msgBase==NULL) ? 0L : msgBase->msgNum(*this,id);
      }
   long msgId (long num)
      {
         return (msgBase==NULL) ? 0L : msgBase->msgId(*this,num);
      }
  };

const dword MSGATTR_PRIVATE     = 0x00000001L;
const dword MSGATTR_RECEIVED    = 0x00000002L;
const dword MSGATTR_DELETED     = 0x00000004L;
const dword MSGATTR_NETMAIL     = 0x00000008L;
const dword MSGATTR_UNSENT_ECHO = 0x00000010L;
const dword MSGATTR_UNSENT_NET  = 0x00000020L;
const dword MSGATTR_LOCAL       = 0x00000040L;
const dword MSGATTR_KILL        = 0x00000080L;
const dword MSGATTR_CRASH       = 0x00000100L;
const dword MSGATTR_SENT        = 0x00000200L;
const dword MSGATTR_FILE        = 0x00000400L;
const dword MSGATTR_FILEREQ     = 0x00000800L;
const dword MSGATTR_AUDITREQ    = 0x00001000L;
const dword MSGATTR_RECEIPTREQ  = 0x00002000L;
const dword MSGATTR_TRANSIT     = 0x00004000L;
const dword MSGATTR_HOLD        = 0x00008000L;
const dword MSGATTR_IMMEDIATE   = 0x00010000L;
const dword MSGATTR_DIRECT      = 0x00020000L;
const dword MSGATTR_TRUNCFILE   = 0x00040000L;
const dword MSGATTR_DELFILE     = 0x00080000L;
const dword MSGATTR_ORPHAN      = 0x00100000L;
const dword MSGATTR_ECHOMAIL    = 0x00200000L;
const dword MSGATTR_NODISP      = 0x00400000L;
const dword MSGATTR_LOCKED      = 0x00800000L;


struct Message
  {
   long  num;
   dword id;  // for Squish only, others -> == num

   char  from[36];
   char  to  [36];
   char  subj[66];

   dword attr;

   Date  postDate;
   Time  postTime;
   Date  recvDate;
   Time  recvTime;

   long  next;
   long  prev;

   int   origZone,
         origNet,
         origNode,
         origPoint;

   int   destZone,
         destNet,
         destNode,
         destPoint;

   int   cost;

   /************************************************************/

   static long lastIndex;

   union {
          MsgArea *msgArea;
          int area;
         };

   Message(int area = 0);
   Message(Message *, int area = 0);

   ~Message();

   int areaNum() ;

   MsgBase *msgBase()
     {
      return msgArea->msgBase;
     }

   void clear();

   bool setArea  (int num);
   bool read     (long num, int area = 0);
   bool readFirst(int method,int order,long first,char *data,int area = 0);
   bool readNext (int method,int order,char *data);
   bool readPrev (int method,int order,char *data);

   word readText(char *text,long offset,word size)
     {
      return msgBase()->readMsgText(*this, text, offset , size);
     }

   void createMsgTextFile(char *fname , bool append);
   void createMsgTextString(char *string , word maxsize);
   void export(char *fname);
   void forward();
   void move();

   void setFlag   (dword msgflag);
   void clearFlag (dword msgflag);
   void toggleFlag(dword msgflag);

   bool testFlag (dword msgflag) { return (attr & msgflag) ? TRUE:FALSE; }

   void operator=(HudsonMsgHdr&);

   void addReply(Message&);
   void delReply();
   void remove();

   byte show();
   void addOrigin();
   int  pointNum(int mode);
   long add();

   long msgNum() { return msgBase()->msgNum(*msgArea,id); }

   bool readAccess();
  };

struct MessageIndex
  {
   MessageIndex() {}
   MessageIndex(int a,long n) { area = a; num = n; }

   int  area;
   long num;
  };

class MarkedMsgList
  {
   MessageIndex *msgList;
   int n;
  public:
   MarkedMsgList();
   MarkedMsgList(const MarkedMsgList&);
   ~MarkedMsgList();

   void operator=(const MarkedMsgList&);

   bool add(MessageIndex&);
   bool add(Message&);
   void clear() { n = 0; }
   bool remove(MessageIndex&);
   void sort();
   int  numMarked() { return n; }
   bool isMarked(MessageIndex&);
   MessageIndex getMarked(int n)  { return msgList[n]; }
   MessageIndex operator[](int n) { return msgList[n]; }
  };

const int MAX_MARKED_MSGS = 500;

extern MsgBase       *squishMsgBase;
extern MsgBase       *hudsonMsgBase;
extern MsgBase       *jamMsgBase;
extern MsgBaseList    msgbase;
extern MarkedMsgList  markedmsglist;

void get_new_msgs(MarkedMsgList& marked,int area);


inline long
HudsonMsgBase::msgNum(MsgArea&,long id)
{
 return id;
}

inline long
HudsonMsgBase::msgId(MsgArea&, long num)
{
 return num;
}