#include "tiio_zcc.h"
//#include "tparam.h"
#include "tsystem.h"
 
#ifdef DOPO_LO_FACCIAMO
 
#define PID_TAG(X)                                                             \
  (((X) >> 24) | ((X >> 8) & 0x0000FF00) | ((X << 8) & 0x00FF0000) |           \
   ((X) << 24))
 
/*
 
HEADER 'HDR '  32 bytes >
  0 |  4  |  Magic number 'ZCC '
  4 |  4  |  Major revision
  8 |  4  |  Minor revision
 12 |  4  |  Frame rate num
 16 |  4  |  Frame rate den
 20 |  4  |  Frame count
 24 |  4  |  Compressor type ( 'YUV2', 'RGBM' )
 28 |  4  |  Padding (future use)
<HEADER
 
 
FRAMEDATA 'FRME' >
  0 FRAMEDESCRIPTOR 'DSCR' 16 bytes >
     0 |  4  |  Frame ID
     4 |  4  |  Width
     8 |  4  |  Height
    12 |  4  |  RawData size
   <FRAMEDESCRIPTOR
 
  16 RAWDATA 'DATA' RawDataSize >
     0 |
   <RAWDATA
 
<FRAMEDATA
 
*/
 
/*
class ZCCParser {
TFile &m_file;
public:
  ZCCParser(TFile&file) : m_file(file)
    {
    m_file.seek(0);
    string tag = readTag();
    }
private:
  string readTag()
    {
 
 
    }
};
 
*/
//-----------------------------------------------------------
 
TReaderWriterInfo *TReaderWriterInfoZCC::create(const string &) {
  return new TReaderWriterInfoZCC();
}
 
//-----------------------------------------------------------
 
TReaderWriterInfoZCC::TReaderWriterInfoZCC() {
  int c               = 0;
  TIntEnumParamP type = new TIntEnumParam();
 
  type->addItem(c++, "RGBM Uncompressed");
  type->addItem(c++, "YUV  Uncompressed");
  addParam("codec", type.getPointer());
}
 
//-----------------------------------------------------------
 
TReaderWriterInfo *TReaderWriterInfoZCC::clone() const {
  return new TReaderWriterInfoZCC(*this);
}
 
//-----------------------------------------------------------
 
TReaderWriterInfoZCC::~TReaderWriterInfoZCC() {}
 
//-----------------------------------------------------------
 
TReaderWriterInfoZCC::TReaderWriterInfoZCC(const TReaderWriterInfoZCC &src)
    : TReaderWriterInfo(src) {}
 
//===========================================================
class TImageReaderWriterZCC : public TImageReaderWriter {
public:
  TImageReaderWriterZCC(const TFilePath &fp, int index,
                        TLevelReaderWriterZCC *lrw);
 
private:
  // not implemented
  TImageReaderWriterZCC(const TImageReaderWriterZCC &);
  TImageReaderWriterZCC &operator=(const TImageReaderWriterZCC &src);
 
public:
  void save(const TImageP &);
  TImageP load();
  void load(const TRasterP &ras, const TPoint &pos = TPoint(0, 0),
            int shrinkX = 1, int shrinkY = 1);
  int m_index;
 
private:
  TLevelReaderWriterZCC *m_lrw;
};
 
//------------------------------------------------------------------------------
 
using namespace TFileConsts;
TLevelReaderWriterZCC::TLevelReaderWriterZCC(const TFilePath &path,
                                             TReaderWriterInfo *winfo)
    : TLevelReaderWriter(path, winfo)
    , m_file(path, kReadWrite | kUnbuffered | kOpenAlways)
    , m_indexFile(path.withType("ndx"), kReadWrite | kOpenAlways)
    , m_initDone(false)
    , m_blockSize(0) {
  if (!m_file.isOpen()) throw TImageException(path, m_file.getLastError());
 
  TFilePathSet fps = TSystem::getDisks();
  TFilePath disk;
 
  for (TFilePathSet::iterator it = fps.begin(); it != fps.end(); it++) {
    disk = *it;
    if (disk.isAncestorOf(m_path)) {
      DWORD sectorsPerCluster;
      // DWORD bytesPerSector;
      DWORD numberOfFreeClusters;
      DWORD totalNumberOfClusters;
 
      BOOL rc = GetDiskFreeSpaceW(
          disk.getWideString().c_str(), &sectorsPerCluster, &m_blockSize,
          &numberOfFreeClusters, &totalNumberOfClusters);
      break;
    }
  }
  assert(m_blockSize);
}
 
//-----------------------------------------------------------
 
void TLevelReaderWriterZCC::saveSoundTrack(TSoundTrack *st) {}
//-----------------------------------------------------------
 
TLevelP TLevelReaderWriterZCC::loadInfo() {
  TLevelP level;
  if (!m_file.size()) return level;
 
  m_file.seek(0);
  UCHAR *buffer = new UCHAR[m_blockSize];
 
  m_file.read(buffer, m_blockSize);
 
  ULONG magicNumber = *(ULONG *)&buffer[0];
  assert(magicNumber == PID_TAG('ZCC '));
  ULONG majorRevision  = *(ULONG *)&buffer[4];
  ULONG minorRevision  = *(ULONG *)&buffer[8];
  ULONG frameRateNum   = *(ULONG *)&buffer[12];
  ULONG frameRateDen   = *(ULONG *)&buffer[16];
  ULONG frameCount     = *(ULONG *)&buffer[20];
  ULONG compressorType = *(ULONG *)&buffer[24];
 
  delete[] buffer;
 
  TINT64 offset = m_blockSize;
  TINT64 fs     = m_file.size();
  while (offset < fs) {
    m_file.seek(offset);
    m_file.read(buffer, m_blockSize);
 
    ULONG frameId     = *(ULONG *)&buffer[0];
    ULONG width       = *(ULONG *)&buffer[4];
    ULONG height      = *(ULONG *)&buffer[8];
    ULONG rawDataSize = *(ULONG *)&buffer[12];
 
    TINT64 d = rawDataSize + 16;
 
    int headerSize = 16;
    int dataSize   = rawDataSize + headerSize;
 
    long bufferSize = tceil(dataSize / (double)m_blockSize) * m_blockSize;
 
    m_map[frameId] = C(offset, bufferSize, width, height);
    level->setFrame(TFrameId(frameId), TImageP());
 
    offset += bufferSize;
  }
  return level;
}
 
//-----------------------------------------------------------
 
TImageReaderWriterP TLevelReaderWriterZCC::getFrameReaderWriter(TFrameId id) {
  TImageReaderWriterZCC *iwm =
      new TImageReaderWriterZCC(m_path, id.getNumber(), this);
  return TImageReaderWriterP(iwm);
}
 
//-----------------------------------------------------------
 
TLevelReaderWriterZCC::~TLevelReaderWriterZCC() {
  m_file.seek(0);
  UCHAR *buffer = new UCHAR[m_blockSize];
  memset(buffer, 0, m_blockSize);
 
  ULONG *magicNumber = (ULONG *)&buffer[0];
  *magicNumber       = PID_TAG('ZCC ');
 
  ULONG *majorRevision = (ULONG *)&buffer[4];
  *majorRevision       = 0x0001;
 
  ULONG *minorRevision = (ULONG *)&buffer[8];
  *minorRevision       = 0x0000;
 
  ULONG *frameRateNum = (ULONG *)&buffer[12];
  *frameRateNum       = 25;
 
  ULONG *frameRateDen = (ULONG *)&buffer[16];
  *frameRateDen       = 1;
 
  ULONG *frameCount = (ULONG *)&buffer[20];
  *frameCount       = 0xffff;
 
  ULONG *compressorType = (ULONG *)&buffer[24];
  *compressorType       = PID_TAG('RGBM');
 
  m_file.write(buffer, m_blockSize);
  delete[] buffer;
}
 
//-----------------------------------------------------------
 
TImageReaderWriterZCC::TImageReaderWriterZCC(const TFilePath &fp, int index,
                                             TLevelReaderWriterZCC *lrw)
    : TImageReaderWriter(fp), m_lrw(lrw), m_index(index) {}
 
//-----------------------------------------------------------
 
void TImageReaderWriterZCC::save(const TImageP &img) {
  TFile &file = m_lrw->m_file;
 
  TRaster32P ras = TRasterImageP(img)->getRaster();
 
  int rasDataSize = ras->getRowSize() * ras->getLy();
  int headerSize  = 16;
  int dataSize    = rasDataSize + headerSize;
 
  int bufferSize =
      tceil(dataSize / (double)m_lrw->m_blockSize) * m_lrw->m_blockSize;
 
  TINT64 offset         = bufferSize * m_index + m_lrw->m_blockSize;
  m_lrw->m_map[m_index] = C(offset, bufferSize, ras->getLx(), ras->getLy());
 
  if (!file.seek(offset /*per l'header*/))
    throw TImageException(m_path, file.getLastError());
 
  TRasterImageP rasImage = img;
 
  UCHAR *buffer = new UCHAR[bufferSize];
 
  ULONG *frameId = (ULONG *)&buffer[0];
  *frameId       = m_index;
 
  ULONG *width = (ULONG *)&buffer[4];
  *width       = ras->getLx();
 
  ULONG *height           = (ULONG *)&buffer[8];
  *height                 = ras->getLy();
  bwww ULONG *rawDataSize = (ULONG *)&buffer[12];
  *rawDataSize            = rasDataSize;
  memcpy(&buffer[16], ras->getRawData(), rasDataSize);
 
  if (!file.write(buffer, bufferSize))
    throw TImageException(m_path, file.getLastError());
  delete[] buffer;
}
 
//-----------------------------------------------------------
 
TImageP TImageReaderWriterZCC::load() {
  C c = m_lrw->m_map[m_index];
 
  TRaster32P ras(c.m_lx, c.m_ly);
  load(ras);
  return TImageP(TRasterImageP(ras));
}
 
//-----------------------------------------------------------
 
void TImageReaderWriterZCC::load(const TRasterP &ras, const TPoint &pos,
                                 int shrinkX, int shrinkY) {
  if (!m_lrw->m_initDone) {
    //
    // write header
    //
    m_lrw->m_initDone = true;
  }
  TFile &file = m_lrw->m_file;
 
  /*
std::map<int, C>::iterator it = std::find(m_lrw->m_map.begin(),
m_lrw->m_map.end(), m_index);
if (it == m_lrw->m_map.end())
return;
*/
 
  C c = m_lrw->m_map[m_index];
 
  if (!file.seek(c.m_offset))
    throw TImageException(m_path, file.getLastError());
 
  UCHAR *buffer = new UCHAR[c.m_size];
 
  if (!file.read(buffer, c.m_size))
    throw TImageException(m_path, file.getLastError());
 
  ULONG *frameId = (ULONG *)&buffer[0];
  assert(*frameId == (ULONG)m_index);
 
  ULONG *width = (ULONG *)&buffer[4];
 
  ULONG *height = (ULONG *)&buffer[8];
 
  ULONG *rawDataSize = (ULONG *)&buffer[12];
 
  assert((ULONG)ras->getLx() == *width);
  assert((ULONG)ras->getLy() == *height);
 
  memcpy(ras->getRawData(), &buffer[16], *rawDataSize);
 
  delete[] buffer;
}
 
#endif