// Copyright (c) the JPEG XL Project Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#ifndef LIB_JXL_CODEC_IN_OUT_H_
#define LIB_JXL_CODEC_IN_OUT_H_

// Holds inputs/outputs for decoding/encoding images.

#include <jxl/memory_manager.h>

#include <cstddef>
#include <cstdint>
#include <utility>
#include <vector>

#include "lib/jxl/base/status.h"
#include "lib/jxl/color_encoding_internal.h"
#include "lib/jxl/headers.h"
#include "lib/jxl/image.h"
#include "lib/jxl/image_bundle.h"
#include "lib/jxl/luminance.h"

namespace jxl {

// Optional text/EXIF metadata.
struct Blobs {
  std::vector<uint8_t> exif;
  std::vector<uint8_t> iptc;
  std::vector<uint8_t> jhgm;
  std::vector<uint8_t> jumbf;
  std::vector<uint8_t> xmp;
};

// Holds a preview, a main image or one or more frames, plus the inputs/outputs
// to/from decoding/encoding.
class CodecInOut {
 public:
  explicit CodecInOut(JxlMemoryManager* memory_manager)
      : memory_manager(memory_manager),
        preview_frame(memory_manager, &metadata.m) {
    frames.reserve(1);
    frames.emplace_back(memory_manager, &metadata.m);
  }

  // Move-only.
  CodecInOut(CodecInOut&&) = default;
  CodecInOut& operator=(CodecInOut&&) = default;

  size_t LastStillFrame() const {
    JXL_DASSERT(!frames.empty());
    size_t last = 0;
    for (size_t i = 0; i < frames.size(); i++) {
      last = i;
      if (frames[i].duration > 0) break;
    }
    return last;
  }

  ImageBundle& Main() { return frames[LastStillFrame()]; }
  const ImageBundle& Main() const { return frames[LastStillFrame()]; }

  // If c_current.IsGray(), all planes must be identical.
  Status SetFromImage(Image3F&& color, const ColorEncoding& c_current) {
    JXL_RETURN_IF_ERROR(Main().SetFromImage(std::move(color), c_current));
    SetIntensityTarget(&this->metadata.m);
    JXL_RETURN_IF_ERROR(SetSize(Main().xsize(), Main().ysize()));
    return true;
  }

  Status SetSize(size_t xsize, size_t ysize) {
    JXL_RETURN_IF_ERROR(metadata.size.Set(xsize, ysize));
    return true;
  }

  Status CheckMetadata() const {
    JXL_ENSURE(metadata.m.bit_depth.bits_per_sample != 0);
    JXL_ENSURE(!metadata.m.color_encoding.ICC().empty());

    if (preview_frame.xsize() != 0) {
      JXL_RETURN_IF_ERROR(preview_frame.VerifyMetadata());
    }
    JXL_ENSURE(preview_frame.metadata() == &metadata.m);

    for (const ImageBundle& ib : frames) {
      JXL_RETURN_IF_ERROR(ib.VerifyMetadata());
      JXL_ENSURE(ib.metadata() == &metadata.m);
    }
    return true;
  }

  size_t xsize() const { return metadata.size.xsize(); }
  size_t ysize() const { return metadata.size.ysize(); }
  Status ShrinkTo(size_t xsize, size_t ysize) {
    // preview is unaffected.
    for (ImageBundle& ib : frames) {
      JXL_RETURN_IF_ERROR(ib.ShrinkTo(xsize, ysize));
    }
    JXL_RETURN_IF_ERROR(SetSize(xsize, ysize));
    return true;
  }

  // -- DECODER OUTPUT, ENCODER INPUT:

  // Metadata stored into / retrieved from bitstreams.

  JxlMemoryManager* memory_manager;

  Blobs blobs;

  CodecMetadata metadata;  // applies to preview and all frames

  // If metadata.have_preview:
  ImageBundle preview_frame;

  std::vector<ImageBundle> frames;  // size=1 if !metadata.have_animation

  // If the image should be written to a JPEG, use this quality for encoding.
  size_t jpeg_quality;
};

}  // namespace jxl

#endif  // LIB_JXL_CODEC_IN_OUT_H_