/*

Copyright (C) 2005-2011 Sergey A. Tachenov

This program is free software; you can redistribute it and/or modify it

under the terms of the GNU Lesser General Public License as published by

the Free Software Foundation; either version 2 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 Lesser

General Public License for more details.

You should have received a copy of the GNU Lesser General Public License

along with this program; if not, write to the Free Software Foundation,

Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

See COPYING file for the full LGPL text.

Original ZIP package is copyrighted by Gilles Vollant, see

quazip/(un)zip.h files for details, basically it's zlib license.

 **/

#include <QFile>

#include "quazip.h"

class QuaZipPrivate {

  friend class QuaZip;

  private:

    QTextCodec *fileNameCodec, *commentCodec;

    QString zipName;

    QIODevice *ioDevice;

    QString comment;

    QuaZip::Mode mode;

    union {

      unzFile unzFile_f;

      zipFile zipFile_f;

    };

    bool hasCurrentFile_f;

    int zipError;

    inline QuaZipPrivate():

      fileNameCodec(QTextCodec::codecForLocale()),

      commentCodec(QTextCodec::codecForLocale()),

      ioDevice(NULL),

      mode(QuaZip::mdNotOpen),

      hasCurrentFile_f(false),

      zipError(UNZ_OK) {}

    inline QuaZipPrivate(const QString &zipName):

      fileNameCodec(QTextCodec::codecForLocale()),

      commentCodec(QTextCodec::codecForLocale()),

      zipName(zipName),

      ioDevice(NULL),

      mode(QuaZip::mdNotOpen),

      hasCurrentFile_f(false),

      zipError(UNZ_OK) {}

    inline QuaZipPrivate(QIODevice *ioDevice):

      fileNameCodec(QTextCodec::codecForLocale()),

      commentCodec(QTextCodec::codecForLocale()),

      ioDevice(ioDevice),

      mode(QuaZip::mdNotOpen),

      hasCurrentFile_f(false),

      zipError(UNZ_OK) {}

};

QuaZip::QuaZip():

  p(new QuaZipPrivate())

{

}

QuaZip::QuaZip(const QString& zipName):

  p(new QuaZipPrivate(zipName))

{

}

QuaZip::QuaZip(QIODevice *ioDevice):

  p(new QuaZipPrivate(ioDevice))

{

}

QuaZip::~QuaZip()

{

  if(isOpen())

    close();

  delete p;

}

bool QuaZip::open(Mode mode, zlib_filefunc_def* ioApi)

{

  p->zipError=UNZ_OK;

  if(isOpen()) {

    qWarning("QuaZip::open(): ZIP already opened");

    return false;

  }

  QIODevice *ioDevice = p->ioDevice;

  if (ioDevice == NULL) {

    if (p->zipName.isEmpty()) {

      qWarning("QuaZip::open(): set either ZIP file name or IO device first");

      return false;

    } else {

      ioDevice = new QFile(p->zipName);

    }

  }

  switch(mode) {

    case mdUnzip:

      p->unzFile_f=unzOpen2(ioDevice, ioApi);

      if(p->unzFile_f!=NULL) {

        p->mode=mode;

        p->ioDevice = ioDevice;

        return true;

      } else {

        p->zipError=UNZ_OPENERROR;

        if (!p->zipName.isEmpty())

          delete ioDevice;

        return false;

      }

    case mdCreate:

    case mdAppend:

    case mdAdd:

      p->zipFile_f=zipOpen2(ioDevice,

          mode==mdCreate?APPEND_STATUS_CREATE:

          mode==mdAppend?APPEND_STATUS_CREATEAFTER:

          APPEND_STATUS_ADDINZIP,

          NULL,

          ioApi);

      if(p->zipFile_f!=NULL) {

        p->mode=mode;

        p->ioDevice = ioDevice;

        return true;

      } else {

        p->zipError=UNZ_OPENERROR;

        if (!p->zipName.isEmpty())

          delete ioDevice;

        return false;

      }

    default:

      qWarning("QuaZip::open(): unknown mode: %d", (int)mode);

      if (!p->zipName.isEmpty())

        delete ioDevice;

      return false;

      break;

  }

}

void QuaZip::close()

{

  p->zipError=UNZ_OK;

  switch(p->mode) {

    case mdNotOpen:

      qWarning("QuaZip::close(): ZIP is not open");

      return;

    case mdUnzip:

      p->zipError=unzClose(p->unzFile_f);

      break;

    case mdCreate:

    case mdAppend:

    case mdAdd:

      p->zipError=zipClose(p->zipFile_f, p->commentCodec->fromUnicode(p->comment).constData());

      break;

    default:

      qWarning("QuaZip::close(): unknown mode: %d", (int)p->mode);

      return;

  }

  // opened by name, need to delete the internal IO device

  if (!p->zipName.isEmpty())

    delete p->ioDevice;

  if(p->zipError==UNZ_OK)

    p->mode=mdNotOpen;

}

void QuaZip::setZipName(const QString& zipName)

{

  if(isOpen()) {

    qWarning("QuaZip::setZipName(): ZIP is already open!");

    return;

  }

  p->zipName=zipName;

  p->ioDevice = NULL;

}

void QuaZip::setIoDevice(QIODevice *ioDevice)

{

  if(isOpen()) {

    qWarning("QuaZip::setIoDevice(): ZIP is already open!");

    return;

  }

  p->ioDevice = ioDevice;

  p->zipName = QString();

}

int QuaZip::getEntriesCount()const

{

  QuaZip *fakeThis=(QuaZip*)this; // non-const

  fakeThis->p->zipError=UNZ_OK;

  if(p->mode!=mdUnzip) {

    qWarning("QuaZip::getEntriesCount(): ZIP is not open in mdUnzip mode");

    return -1;

  }

  unz_global_info globalInfo;

  if((fakeThis->p->zipError=unzGetGlobalInfo(p->unzFile_f, &globalInfo))!=UNZ_OK)

    return p->zipError;

  return (int)globalInfo.number_entry;

}

QString QuaZip::getComment()const

{

  QuaZip *fakeThis=(QuaZip*)this; // non-const

  fakeThis->p->zipError=UNZ_OK;

  if(p->mode!=mdUnzip) {

    qWarning("QuaZip::getComment(): ZIP is not open in mdUnzip mode");

    return QString();

  }

  unz_global_info globalInfo;

  QByteArray comment;

  if((fakeThis->p->zipError=unzGetGlobalInfo(p->unzFile_f, &globalInfo))!=UNZ_OK)

    return QString();

  comment.resize(globalInfo.size_comment);

  if((fakeThis->p->zipError=unzGetGlobalComment(p->unzFile_f, comment.data(), comment.size())) < 0)

    return QString();

  fakeThis->p->zipError = UNZ_OK;

  return p->commentCodec->toUnicode(comment);

}

bool QuaZip::setCurrentFile(const QString& fileName, CaseSensitivity cs)

{

  p->zipError=UNZ_OK;

  if(p->mode!=mdUnzip) {

    qWarning("QuaZip::setCurrentFile(): ZIP is not open in mdUnzip mode");

    return false;

  }

  if(fileName.isEmpty()) {

    p->hasCurrentFile_f=false;

    return true;

  }

  // Unicode-aware reimplementation of the unzLocateFile function

  if(p->unzFile_f==NULL) {

    p->zipError=UNZ_PARAMERROR;

    return false;

  }

  if(fileName.length()>MAX_FILE_NAME_LENGTH) {

    p->zipError=UNZ_PARAMERROR;

    return false;

  }

  bool sens;

  if(cs==csDefault) {

#ifdef Q_WS_WIN

    sens=false;

#else

    sens=true;

#endif

  } else sens=cs==csSensitive;

  QString lower, current;

  if(!sens) lower=fileName.toLower();

  p->hasCurrentFile_f=false;

  for(bool more=goToFirstFile(); more; more=goToNextFile()) {

    current=getCurrentFileName();

    if(current.isEmpty()) return false;

    if(sens) {

      if(current==fileName) break;

    } else {

      if(current.toLower()==lower) break;

    }

  }

  return p->hasCurrentFile_f;

}

bool QuaZip::goToFirstFile()

{

  p->zipError=UNZ_OK;

  if(p->mode!=mdUnzip) {

    qWarning("QuaZip::goToFirstFile(): ZIP is not open in mdUnzip mode");

    return false;

  }

  p->zipError=unzGoToFirstFile(p->unzFile_f);

  p->hasCurrentFile_f=p->zipError==UNZ_OK;

  return p->hasCurrentFile_f;

}

bool QuaZip::goToNextFile()

{

  p->zipError=UNZ_OK;

  if(p->mode!=mdUnzip) {

    qWarning("QuaZip::goToFirstFile(): ZIP is not open in mdUnzip mode");

    return false;

  }

  p->zipError=unzGoToNextFile(p->unzFile_f);

  p->hasCurrentFile_f=p->zipError==UNZ_OK;

  if(p->zipError==UNZ_END_OF_LIST_OF_FILE)

    p->zipError=UNZ_OK;

  return p->hasCurrentFile_f;

}

bool QuaZip::getCurrentFileInfo(QuaZipFileInfo *info)const

{

  QuaZip *fakeThis=(QuaZip*)this; // non-const

  fakeThis->p->zipError=UNZ_OK;

  if(p->mode!=mdUnzip) {

    qWarning("QuaZip::getCurrentFileInfo(): ZIP is not open in mdUnzip mode");

    return false;

  }

  unz_file_info info_z;

  QByteArray fileName;

  QByteArray extra;

  QByteArray comment;

  if(info==NULL) return false;

  if(!isOpen()||!hasCurrentFile()) return false;

  if((fakeThis->p->zipError=unzGetCurrentFileInfo(p->unzFile_f, &info_z, NULL, 0, NULL, 0, NULL, 0))!=UNZ_OK)

    return false;

  fileName.resize(info_z.size_filename);

  extra.resize(info_z.size_file_extra);

  comment.resize(info_z.size_file_comment);

  if((fakeThis->p->zipError=unzGetCurrentFileInfo(p->unzFile_f, NULL,

      fileName.data(), fileName.size(),

      extra.data(), extra.size(),

      comment.data(), comment.size()))!=UNZ_OK)

    return false;

  info->versionCreated=info_z.version;

  info->versionNeeded=info_z.version_needed;

  info->flags=info_z.flag;

  info->method=info_z.compression_method;

  info->crc=info_z.crc;

  info->compressedSize=info_z.compressed_size;

  info->uncompressedSize=info_z.uncompressed_size;

  info->diskNumberStart=info_z.disk_num_start;

  info->internalAttr=info_z.internal_fa;

  info->externalAttr=info_z.external_fa;

  info->name=p->fileNameCodec->toUnicode(fileName);

  info->comment=p->commentCodec->toUnicode(comment);

  info->extra=extra;

  info->dateTime=QDateTime(

      QDate(info_z.tmu_date.tm_year, info_z.tmu_date.tm_mon+1, info_z.tmu_date.tm_mday),

      QTime(info_z.tmu_date.tm_hour, info_z.tmu_date.tm_min, info_z.tmu_date.tm_sec));

  return true;

}

QString QuaZip::getCurrentFileName()const

{

  QuaZip *fakeThis=(QuaZip*)this; // non-const

  fakeThis->p->zipError=UNZ_OK;

  if(p->mode!=mdUnzip) {

    qWarning("QuaZip::getCurrentFileName(): ZIP is not open in mdUnzip mode");

    return QString();

  }

  if(!isOpen()||!hasCurrentFile()) return QString();

  QByteArray fileName(MAX_FILE_NAME_LENGTH, 0);

  if((fakeThis->p->zipError=unzGetCurrentFileInfo(p->unzFile_f, NULL, fileName.data(), fileName.size(),

      NULL, 0, NULL, 0))!=UNZ_OK)

    return QString();

  return p->fileNameCodec->toUnicode(fileName.constData());

}

void QuaZip::setFileNameCodec(QTextCodec *fileNameCodec)

{

  p->fileNameCodec=fileNameCodec;

}

void QuaZip::setFileNameCodec(const char *fileNameCodecName)

{

  p->fileNameCodec=QTextCodec::codecForName(fileNameCodecName);

}

QTextCodec *QuaZip::getFileNameCodec()const

{

  return p->fileNameCodec;

}

void QuaZip::setCommentCodec(QTextCodec *commentCodec)

{

  p->commentCodec=commentCodec;

}

void QuaZip::setCommentCodec(const char *commentCodecName)

{

  p->commentCodec=QTextCodec::codecForName(commentCodecName);

}

QTextCodec *QuaZip::getCommentCodec()const

{

  return p->commentCodec;

}

QString QuaZip::getZipName() const

{

  return p->zipName;

}

QIODevice *QuaZip::getIoDevice() const

{

  if (!p->zipName.isEmpty()) // opened by name, using an internal QIODevice

    return NULL;

  return p->ioDevice;

}

QuaZip::Mode QuaZip::getMode()const

{

  return p->mode;

}

bool QuaZip::isOpen()const

{

  return p->mode!=mdNotOpen;

}

int QuaZip::getZipError() const

{

  return p->zipError;

}

void QuaZip::setComment(const QString& comment)

{

  p->comment=comment;

}

bool QuaZip::hasCurrentFile()const

{

  return p->hasCurrentFile_f;

}

unzFile QuaZip::getUnzFile()

{

  return p->unzFile_f;

}

zipFile QuaZip::getZipFile()

{

  return p->zipFile_f;

}