#include <stdio.h>
#include <string.h>
#include <qimage.h>
#include "decompress.h"
#include "Reb.h"
#include "my_list.h"
#include "Bkmks.h"
#include "Model.h"
/*
#ifdef offsetof
#define OffsetOf(type, field) ((int) offsetof(type, field))
#else
#define OffsetOf(type, field) ((int) ((char *) &((type *) 0)->field))
#endif

template<class T>
UInt32 binarychop(T* data, UInt32 n, T val)
{
  UInt32 jl = 0,jh = n-1,jm = (jl+jh)/2;
  while (jh > jl+1)
    {
      if (data[jm] > val)
	{
	  jh = jm;
	}
      else
	{
	  jl = jm;
	}
      jm = (jl+jh)/2;
    }
  return jl;
}

template<class T, class D>
UInt32 binarychop(D* data, UInt32 n, T val, UInt32 offset)
{
  UInt32 jl = 0,jh = n-1,jm = (jl+jh)/2;
  while (jh > jl+1)
    {
      T* d = reinterpret_cast<T*>(reinterpret_cast<char*>(data+jm)+offset);
      if (*d > val)
	{
	  jh = jm;
	}
      else
	{
	  jl = jm;
	}
      jm = (jl+jh)/2;
    }
  return jl;
}
*/

CReb::CReb()
:
  fin(NULL), m_indexpages(NULL), m_pagedetails(NULL),tagoffset(0),
  tags(NULL), paras(NULL), noparas(0), joins(NULL), nojoins(0)
{
}

CReb::~CReb()
{
  if (fin != NULL) fclose(fin);
  if (m_indexpages != NULL) delete [] m_indexpages;
  if (m_pagedetails != NULL) delete [] m_pagedetails;
  if (tags != NULL) delete [] tags;
  if (paras != NULL) delete [] paras;
  if (joins != NULL) delete [] joins;
}

unsigned int CReb::locate()
{
  return m_pagedetails[currentpage.pageno()].pagestart+currentpage.offset();
}

void CReb::locate(unsigned int n)
{
  /*
  UInt32 cp = nopages-1;
  for (int i = 0; i < nopages; ++i)
    {
      if (m_pagedetails[i].pagestart > n)
	{
	  cp = i-1;
	  break;
	}
    }
  qDebug("Requesting %u from page %u [%u]", n, cp, n - m_pagedetails[cp].pagestart);
  */
  //UInt32 jl = binarychop<UInt32, Page_detail>(m_pagedetails, nopages, n, OffsetOf(Page_detail, pagestart));
  
  UInt32 jl = 0,jh = nopages-1,jm = (jl+jh)/2;
  while (jh > jl+1)
    {
      if (m_pagedetails[jm].pagestart > n)
	{
	  jh = jm;
	}
      else
	{
	  jl = jm;
	}
      jm = (jl+jh)/2;
    }
  
  unsuspend();
  Page_detail rs = m_pagedetails[jl];
  UInt32 val = n - rs.pagestart;
  if (jl != currentpage.pageno()) readindex(jl);
  currentpage.setoffset(page2pos(jl), jl, ((rs.flags & 8) != 0), rs.len, val);
  if (noparas > 0)
    {
      //jl = binarychop<int, ParaRef>(paras, noparas, val, OffsetOf(ParaRef, pos));
      
      UInt32 jl = 0,jh = noparas-1,jm = (jl+jh)/2;
      while (jh > jl+1)
	{
	  if (paras[jm].pos > val)
	    {
	      jh = jm;
	    }
	  else
	    {
	      jl = jm;
	    }
	  jm = (jl+jh)/2;
	}
  
      qDebug("TAGS:%s", (const char*)tags[paras[jl].tag]);
      tagstring = tags[paras[jl].tag]+"<br>"; // Add br to set extra space to 0
      tagoffset = 0;
    }
  unsigned long current = locate();
  if (m_currentstart > current || current > m_currentend)
    {
      start2endSection();
    }
  if (current != n) qDebug("ERROR:Ended up at %u", current);
}

bool CReb::getFile(const QString& href, const QString& nm)
{
  qDebug("File:%s, Name:%s", (const char*)href, (const char*)nm);
  QMap<QString, UInt32>::Iterator iter = m_index.find(href);
  if (iter != m_index.end())
    {
      qDebug("REB:BEFORE:%u", locate());
      startpage(iter.data());
      qDebug("REB:AFTER:%u", locate());
      return true;
    }
  else
    {
      return false;
    }
}

QImage* CReb::getPicture(const QString& ref)
{
  QMap<QString, UInt32>::Iterator iter = m_index.find(ref);
  if (iter != m_index.end())
    {
      unsuspend();
      Page_detail rs = m_pagedetails[iter.data()];
      char* imgbuffer = new char[rs.len];
      fseek(fin, page2pos(iter.data()), SEEK_SET);
      fread(imgbuffer, rs.len, 1, fin);
      QByteArray arr;
      arr.assign((const char*)imgbuffer, rs.len);
      QImage* qimage = new QImage(arr);
      return qimage;
    }
  else
    {
      return NULL;
    }
}

CList<Bkmk>* CReb::getbkmklist() { return NULL; }

void CReb::home()
{
  startpage(m_homepage);
}

int CReb::OpenFile(const char *src)
{
  m_binary = false;
  if (fin != NULL) fclose(fin);
  fin = fopen(src, "r");
  if (fin == NULL)
    {
      return -1;
    }
  UInt32 type;
  fseek(fin, 6, SEEK_SET);
  fread(&type, 1, sizeof(type), fin);
  qDebug("CREB:Okay %x", type);
  
  if (type == 0x4f56554e || type == 0x574d4954 || type == 0x576d6954)
    {
      struct stat _stat;
      stat(src, &_stat);
      file_length = _stat.st_size;
      fread(&m_blocksize, 1, sizeof(m_blocksize), fin);
      if (type == 0x574d4954 || type == 0x576d6954)
	{
	  if (type == 0x576d6954) m_binary = true;
	  qDebug("Blocksize(1) %x", m_blocksize);
	  unsigned char ct = (m_blocksize >> 24) & 0xff;
	  qDebug("Compress type:%x", ct);
	  switch (ct)
	    {
	    case 0:
	      m_decompress = UnZip;
	      break;
	    case 3:
	      m_decompress = getdecompressor("PluckerDecompress3");
	      break;
	    case 4:
	      m_decompress = getdecompressor("PluckerDecompress4");
	      break;
	    }
	  if (m_decompress == NULL) return -1;
	  m_blocksize = 1024*(m_blocksize & 0xffffff);
	}
      else
	{
	  m_blocksize = 4096;
	  m_decompress = UnZip;
	}
      qDebug("Blocksize %u", m_blocksize);
      currentpage.init(fin, m_blocksize, m_decompress);
      qDebug("Its a REB!!!!");
      fseek(fin, 0x18, SEEK_SET);
      fread(&toc, 1, sizeof(toc), fin);
      qDebug("Expect this to be 128 or 20:%x", toc);
      fread(&type, 1, sizeof(type), fin);
      qDebug("File length:%u", type);
      fseek(fin, toc, SEEK_SET);
      fread(&nopages, 1, sizeof(nopages), fin);
      m_indexpages = new UInt32[nopages];
      m_pagedetails = new Page_detail[nopages];
      qDebug("There are %u pages", nopages);
      UInt32 loc = 0;
      UInt32 homeguess = nopages-1;
      QString homeurl;
      for (int i = 0; i < nopages; ++i)
	{
	  char name[32];
	  UInt32 len, pos, flags;
	  fread(name, 1, 32, fin);
	  fread(&len, 1, 4, fin);
	  fread(&pos, 1, 4, fin);
	  fread(&flags, 1, 4, fin);
	  //qDebug("Page %u (%s) is %u bytes at %u (%u) of type %u", i, name, len, pos, loc, flags);
	  m_index[name] = i;
	  m_pagedetails[i] = Page_detail(loc, len, flags);

	  if (QString(name).find(".htm", 0, false) >= 0)
	    {
	      if (homeguess > i) homeguess = i;
	      if ((flags & 8) != 0)
		{
		  UInt32 lastpos = ftell(fin);
		  loc += pagelength(i);
		  fseek(fin, lastpos, SEEK_SET);
		}
	      else
		{
		  loc += len;
		}
	    }
	  if ((flags & 2) != 0)
	    {
	      UInt32 lastpos = ftell(fin);
	      RBPage* idx = new RBPage();
	      idx->init(fin, m_blocksize, m_decompress);
	      idx->startpage(page2pos(i), i, ((flags & 8) != 0), len);
	      int c = 0;
	      while (c != EOF)
		{
		  QString s("");
		  while (1)
		    {
		      c = idx->getch(this);
		      if (c == 10 || c == EOF) break;
		      s += c;
		    }
		  if (s.left(5) == "BODY=")
		    {
		      homeurl = s.right(s.length()-5);
		      qDebug("Home:%s", (const char*)homeurl);
		    }
		  else
		    {
		      qDebug("Info:%s", (const char*)s);
		    }
		}
	      delete idx;
	      fseek(fin, lastpos, SEEK_SET);
	    }
	}
      text_length = loc;
      qDebug("Looking for homepage");
      if (homeurl.isEmpty())
	{
	  m_homepage = homeguess;
	}
      else
	{
	  QMap<QString, UInt32>::Iterator iter = m_index.find(homeurl);
	  if (iter != m_index.end())
	    {
	      m_homepage = iter.data();
	    }
	  else
	    {
	      m_homepage = homeguess;
	    }
	}
      m_homepos = m_pagedetails[m_homepage].pagestart;
      qDebug("Finding indices");
      for (QMap<QString, UInt32>::Iterator iter = m_index.begin(); iter != m_index.end(); ++iter)
	{
	  QString href = iter.key();
	  if (href.find(".htm", 0, false) >= 0)
	    {
	      QString hind = href.left(href.find(".htm", 0, false))+".hidx";
	      //qDebug("Index is %s", (const char*)hind);
	      QMap<QString, UInt32>::Iterator iter2 = m_index.find(hind);
	      if (iter2 != m_index.end())
		{
		  m_indexpages[iter.data()] = iter2.data();
		}
	    }
	}
      qDebug("Going home");
      home();
      return 0;
    }
  else
    {
      char * tmp = (char*)(&type);
      for (int i = 0; i < 4; ++i) qDebug("%d:%c", i, tmp[i]);
      return -1;
    }
}

UInt32 CReb::page2pos(UInt32 page)
{
  fseek(fin, toc+40+44*page, SEEK_SET);
  UInt32 pos;
  fread(&pos, 1, 4, fin);
  return pos;
}

UInt32 CReb::pagelength(UInt32 pagenum)
{
  fseek(fin, toc+40+44*pagenum, SEEK_SET);
  UInt32 pos;
  fread(&pos, 1, 4, fin);
  fseek(fin, pos+4, SEEK_SET);
  UInt32 len;
  fread(&len, 1, sizeof(len), fin);
  return len;
}

void CReb::readindex(UInt32 cp)
{
  if (joins != NULL)
    {
      delete [] joins;
      joins = NULL;
    }
  if (tags != NULL)
    {
      delete [] tags;
      tags = NULL;
    }
  if (paras != NULL)
    {
      delete [] paras;
      paras = NULL;
    }
  noparas = 0;
  nojoins = 0;
  names.clear();
  
  UInt32 rspage = m_indexpages[cp];
  if (rspage != 0)
    {
      Page_detail rs = m_pagedetails[rspage];
      int count = 0;
      RBPage* idx = new RBPage();
      idx->init(fin, m_blocksize, m_decompress);
      idx->startpage(page2pos(rspage), rspage, ((rs.flags & 8) != 0), rs.len);
      int c = 0;
      int phase = 0;
      int i;
      if (m_binary)
	{
	  count = idx->getuint(this);
	  qDebug("tag count:%d", count);
	  tags = new QString[count];
	  for (int i = 0; i < count; ++i)
	    {
	      QString s;
	      while (1)
		{
		  c = idx->getch(this);
		  if (c == 0 || c == EOF) break;
		  s += c;
		}
	      unsigned short val = idx->getuint(this);
	      if (val != 0xffff)
		{
		  tags[i] = tags[val]+s;
		}
	      else
		{
		  tags[i] = s;
		}
	      //qDebug("tags[%d](%d) = %s", i, val, (const char*)tags[i]);
	    }
	  noparas = idx->getint(this);
	  qDebug("Para count %d", noparas);
	  paras = new ParaRef[noparas];
	  for (int i = 0; i < noparas; ++i)
	    {
	      paras[i] = ParaRef(idx->getint(this), idx->getuint(this));
	    }
	  count = idx->getint(this);
	  qDebug("Name count %d", count);
	  for (int i = 0; i < count; ++i)
	    {
	      QString s;
	      while (1)
		{
		  c = idx->getch(this);
		  if (c == 0 || c == EOF) break;
		  s += c;
		}
	      int val = idx->getint(this);
	      names[s.mid(1,s.length()-2)] = val;
	      qDebug("names[%s] = %d", (const char*)s, val);
	    }
	  count = idx->getint(this);
	  qDebug("Join count %d", count);
	  if (count > 0)
	    {
	      nojoins = count+2;
	      joins = new UInt32[count+2];
	      joins[0] = 0;
	      joins[count+1] = currentpage.length();
	      for (int i = 1; i < count+1; ++i)
		{
		  joins[i] = idx->getint(this);
		}
	    }
	}
      else
	{
	  while (c != EOF)
	    {
	      QString s("");
	      while (1)
		{
		  c = idx->getch(this);
		  if (c == 10 || c == EOF) break;
		  s += c;
		}
	      //qDebug("%s", (const char*)s);
	      if (count > 0)
		{
		  --count;
		  int sp = s.findRev(' ');
		  QString l = s.left(sp);
		  int val = s.right(s.length()-sp).toInt();
		  switch (phase)
		    {
		    case 4:
		      //qDebug("Join %d is at offset %d", i, val);
		      joins[i++] = val;
		      break;
		    case 3:
		      //qDebug("Name %s is at offset %d", (const char*)l.mid(1,l.length()-2), val+m_pagedetails[cp].pagestart);
		      names[l.mid(1,l.length()-2)] = val;
		      break;
		    case 1:
		      //qDebug("%s:%d [%d]", (const char*)l, val, i);
		      if (val >= 0)
			{
			  tags[i++] = tags[val]+l;
			}
		      else
			{
			  tags[i++] = l;
			}
		      //qDebug("TAG:%s", (const char*)tags[i-1]);
		      break;
		    case 2:
		      paras[i++] = ParaRef(QString(l).toInt(), val);
		      //qDebug("Para:%u - %u (%s)", QString(l).toInt(), val, (const char*)s);
		      break;
		    default:
		      qDebug("%s:%d", (const char*)l, val);
		      break;
		    }
		}
	      else
		{
		  QString key = "[tags ";
		  if (s.left(key.length()) == key)
		    {
		      phase = 1;
		      i = 0;
		      count = s.mid(key.length(),s.length()-key.length()-1).toInt();
		      qDebug("%s:%s:%d", (const char*)key, (const char*)s, count);
		      tags = new QString[count];
		    }
		  key = "[paragraphs ";
		  if (s.left(key.length()) == key)
		    {
		      phase = 2;
		      i = 0;
		      count = s.mid(key.length(),s.length()-key.length()-1).toInt();
		      qDebug("%s:%s:%d", (const char*)key, (const char*)s, count);
		      paras = new ParaRef[count];
		      noparas = count;
		    }
		  key = "[names ";
		  if (s.left(key.length()) == key)
		    {
		      phase = 3;
		      count = s.mid(key.length(),s.length()-key.length()-1).toInt();
		      qDebug("%s:%s:%d", (const char*)key, (const char*)s, count);
		    }
		  key = "[joins ";
		  if (s.left(key.length()) == key)
		    {
		      phase = 4;
		      count = s.mid(key.length(),s.length()-key.length()-1).toInt();
		      qDebug("%s:%s:%d", (const char*)key, (const char*)s, count);
		      nojoins = count+2;
		      i = 1;
		      joins = new UInt32[count+2];
		      joins[0] = 0;
		      joins[count+1] = currentpage.length();
		      qDebug("%s:%s:%d", (const char*)key, (const char*)s, count);
		    }
		  qDebug("ZC:%s", (const char*)s);
		}
	    }
	}
      //      for (int i = 0; i < nojoins; ++i) qDebug("JOINS:%u %u", i, joins[i]);
      delete idx;
    }
}

bool CReb::findanchor(const QString& _info)
{
  QMap<QString, int>::Iterator iter = names.find(_info);
  if (iter != names.end())
    {
      locate(iter.data()+m_pagedetails[currentpage.pageno()].pagestart);
      return true;
    }
  return false;
}

#ifdef USEQPE
void CReb::suspend()
{
  CExpander::suspend(fin);
}
void CReb::unsuspend()
{
  CExpander::unsuspend(fin);
}
#endif

#ifndef __STATIC
extern "C"
{
  CExpander* newcodec() { return new CReb; }
}
#endif

void CReb::startpage(UInt32 pgno)
{
  Page_detail rs = m_pagedetails[pgno];
  unsuspend();
  readindex(pgno);
  currentpage.startpage(page2pos(pgno), pgno, ((rs.flags & 8) != 0), rs.len);
}

void CReb::startpage(UInt32 _cp, bool _isCompressed, UInt32 _len)
{
  unsuspend();
  readindex(_cp);
  currentpage.startpage(page2pos(_cp), _cp, _isCompressed, _len);
}

void RBPage::initpage(UInt32 pos, size_t _cp, bool _isCompressed, UInt32 _len)
{
  filepos = pos;
  m_pageno = _cp;
  m_Compressed = _isCompressed;
  m_pagelen = _len;
  currentchunk = 0;
  pageoffset = 0;

  if (chunklist != NULL) delete [] chunklist;

  fseek(fin, filepos, SEEK_SET);
  if (m_Compressed)
    {
      fread(&nochunks, 1, sizeof(nochunks), fin);
      fread(&m_pagelen, 1, sizeof(m_pagelen), fin);
      chunklist = new UInt32[nochunks];
      fread(chunklist, nochunks, 4, fin);
    }
  else
    {
      chunklist = NULL;
      nochunks = (_len+m_blocksize-1)/m_blocksize;
    }
  m_startoff = 0;
  m_endoff = m_pagelen;
  chunkpos = ftell(fin);
  qDebug("Compressed:%u Expanded:%u", _len, m_pagelen);
}

void RBPage::startpage(UInt32 pos, UInt32 _cp, bool _isCompressed, UInt32 _len)
{
  initpage(pos, _cp, _isCompressed, _len);
  readchunk();
}

int CReb::getch()
{
  if (tagoffset < tagstring.length())
    return tagstring[tagoffset++].unicode();
  else
    return currentpage.getch(this);
}

int RBPage::getch(CReb* parent)
{
  if (chunkoffset >= chunklen)
    {
      if (++currentchunk >= nochunks)
	{
	  --currentchunk;
	  return EOF;
	}
      pageoffset += chunklen;
      parent->unsuspend();
      readchunk();
    }
  if (offset() == m_endoff) return EOF;
  return chunk[chunkoffset++];
}

unsigned short int RBPage::getuint(CReb* parent)
{
  unsigned short int ret = 0;
  char *buffer = (char*)(&ret);
  for (int i = 0; i < 2; ++i)
    {
      int ch = getch(parent);
      if (ch == EOF) return 0;
      buffer[i] = ch;
    }
  return ret;
}

int RBPage::getint(CReb* parent)
{
  int ret = 0;
  char *buffer = (char*)(&ret);
  for (int i = 0; i < 4; ++i)
    {
      int ch = getch(parent);
      if (ch == EOF) return 0;
      buffer[i] = ch;
    }
  return ret;
}

void RBPage::readchunk()
{
  if (m_Compressed)
    {
      chunkoffset = 0;
      fseek(fin, chunkpos, SEEK_SET);
      UInt8* inbuf = new UInt8[chunklist[currentchunk]];
      fread(inbuf, 1, chunklist[currentchunk], fin);
      chunklen = (*m_decompress)(inbuf, chunklist[currentchunk], chunk, m_blocksize);
      delete [] inbuf;
      chunkpos = ftell(fin);
    }
  else
    {
      chunkoffset = 0;
      chunklen = m_blocksize;
      if (m_blocksize*(currentchunk+1) > m_pagelen)
	{
	  chunklen = m_pagelen - currentchunk*m_blocksize;
	}
      fseek(fin, chunkpos, SEEK_SET);
      chunklen = fread(chunk, 1, chunklen, fin);
      chunkpos = ftell(fin);
    }
}

void RBPage::setoffset(UInt32 pos, size_t _cp, bool _isCompressed, UInt32 _len, UInt32 _offset)
{
  if (m_pageno != _cp)
    {
      initpage(pos, _cp, _isCompressed, _len);
    }
  else
    {
      if (m_Compressed)
	{
	  chunkpos = filepos + sizeof(nochunks) + sizeof(m_pagelen) + 4*nochunks;
	}
      else
	{
	  chunkpos = filepos;
	}
    }

  currentchunk = _offset/m_blocksize;
  pageoffset = m_blocksize*currentchunk;
  if (m_Compressed)
    {
      for (int i = 0; i < currentchunk; ++i)
	{
	  chunkpos += chunklist[i];
	}
    }
  else
    {
      chunkpos += pageoffset;
    }
  readchunk();
  chunkoffset = _offset - pageoffset;
}

void CReb::start2endSection()
{
  if (m_pagedetails != NULL)
    {
      if (nojoins > 0)
	{
	  //UInt32 jl = binarychop<UInt32>(joins, nojoins, currentpage.offset());
	  
	  UInt32 jl = 0,jh = nojoins-1,jm = (jl+jh)/2;
	  while (jh > jl+1)
	    {
	      if (joins[jm] > currentpage.offset())
		{
		  jh = jm;
		}
	      else
		{
		  jl = jm;
		}
	      jm = (jl+jh)/2;
	    }
	  
	  currentpage.m_startoff = joins[jl];
	  currentpage.m_endoff = joins[jl+1]-1;
	  //currentpage.m_endoff = joins[jh]-1;
	}
      m_currentstart = m_pagedetails[currentpage.pageno()].pagestart+currentpage.m_startoff;
      m_currentend = m_pagedetails[currentpage.pageno()].pagestart+currentpage.m_endoff;
    }
  else
    {
      m_currentstart = m_currentend = 0;
    }
  qDebug("s2e:[%u, %u, %u]", m_currentstart, locate(), m_currentend);
}