// SPDX-License-Identifier: GPL-2.0-or-later

// included header files

#include "mrwimage.hpp"

#include "basicio.hpp"

#include "config.h"

#include "enforce.hpp"

#include "error.hpp"

#include "futils.hpp"

#include "image.hpp"

#include "tags.hpp"

#include "tiffimage.hpp"

#include <array>

#include <cstring>

#ifdef EXIV2_DEBUG_MESSAGES

#include <iostream>

#endif

namespace Exiv2 {

MrwImage::MrwImage(BasicIo::UniquePtr io, bool /*create*/) :

    Image(ImageType::mrw, mdExif | mdIptc | mdXmp, std::move(io)) {

}

std::string MrwImage::mimeType() const {

  return "image/x-minolta-mrw";

}

uint32_t MrwImage::pixelWidth() const {

  auto imageWidth = exifData_.findKey(Exiv2::ExifKey("Exif.Image.ImageWidth"));

  if (imageWidth != exifData_.end() && imageWidth->count() > 0) {

    return imageWidth->toUint32();

  }

  return 0;

}

uint32_t MrwImage::pixelHeight() const {

  auto imageHeight = exifData_.findKey(Exiv2::ExifKey("Exif.Image.ImageLength"));

  if (imageHeight != exifData_.end() && imageHeight->count() > 0) {

    return imageHeight->toUint32();

  }

  return 0;

}

void MrwImage::setExifData(const ExifData& /*exifData*/) {

  // Todo: implement me!

  throw(Error(ErrorCode::kerInvalidSettingForImage, "Exif metadata", "MRW"));

}

void MrwImage::setIptcData(const IptcData& /*iptcData*/) {

  // Todo: implement me!

  throw(Error(ErrorCode::kerInvalidSettingForImage, "IPTC metadata", "MRW"));

}

void MrwImage::setComment(const std::string&) {

  // not supported

  throw(Error(ErrorCode::kerInvalidSettingForImage, "Image comment", "MRW"));

}

void MrwImage::readMetadata() {

#ifdef EXIV2_DEBUG_MESSAGES

  std::cerr << "Reading MRW file " << io_->path() << "\n";

#endif

  if (io_->open() != 0) {

    throw Error(ErrorCode::kerDataSourceOpenFailed, io_->path(), strError());

  }

  IoCloser closer(*io_);

  // Ensure that this is the correct image type

  if (!isMrwType(*io_, false)) {

    if (io_->error() || io_->eof())

      throw Error(ErrorCode::kerFailedToReadImageData);

    throw Error(ErrorCode::kerNotAnImage, "MRW");

  }

  clearMetadata();

  // Find the TTW block and read it into a buffer

  uint32_t const len = 8;

  byte tmp[len];

  io_->read(tmp, len);

  uint32_t pos = len;

  uint32_t const end = getULong(tmp + 4, bigEndian);

  pos += len;

  Internal::enforce(pos <= end, ErrorCode::kerFailedToReadImageData);

  io_->read(tmp, len);

  if (io_->error() || io_->eof())

    throw Error(ErrorCode::kerFailedToReadImageData);

  while (memcmp(tmp + 1, "TTW", 3) != 0) {

    uint32_t const siz = getULong(tmp + 4, bigEndian);

    Internal::enforce(siz <= end - pos, ErrorCode::kerFailedToReadImageData);

    pos += siz;

    io_->seek(siz, BasicIo::cur);

    Internal::enforce(!io_->error() && !io_->eof(), ErrorCode::kerFailedToReadImageData);

    Internal::enforce(len <= end - pos, ErrorCode::kerFailedToReadImageData);

    pos += len;

    io_->read(tmp, len);

    Internal::enforce(!io_->error() && !io_->eof(), ErrorCode::kerFailedToReadImageData);

  }

  const uint32_t siz = getULong(tmp + 4, bigEndian);

  // First do an approximate bounds check of siz, so that we don't

  // get DOS-ed by a 4GB allocation on the next line. If siz is

  // greater than io_->size() then it is definitely invalid. But the

  // exact bounds checking is done by the call to io_->read, which

  // will fail if there are fewer than siz bytes left to read.

  Internal::enforce(siz <= io_->size(), ErrorCode::kerFailedToReadImageData);

  DataBuf buf(siz);

  io_->read(buf.data(), buf.size());

  Internal::enforce(!io_->error() && !io_->eof(), ErrorCode::kerFailedToReadImageData);

  ByteOrder bo = TiffParser::decode(exifData_, iptcData_, xmpData_, buf.c_data(), buf.size());

  setByteOrder(bo);

}  // MrwImage::readMetadata

void MrwImage::writeMetadata() {

  // Todo: implement me!

  throw(Error(ErrorCode::kerWritingImageFormatUnsupported, "MRW"));

}  // MrwImage::writeMetadata

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

// free functions

Image::UniquePtr newMrwInstance(BasicIo::UniquePtr io, bool create) {

  auto image = std::make_unique<MrwImage>(std::move(io), create);

  if (!image->good()) {

    return nullptr;

  }

  return image;

}

bool isMrwType(BasicIo& iIo, bool advance) {

  const int32_t len = 4;

  const std::array<byte, len> MrwId{0x0, 0x4d, 0x52, 0x4d};

  std::array<byte, len> buf;

  iIo.read(buf.data(), len);

  if (iIo.error() || iIo.eof()) {

    return false;

  }

  bool rc = buf == MrwId;

  if (!advance || !rc) {

    iIo.seek(-len, BasicIo::cur);

  }

  return rc;

}

}  // namespace Exiv2