/*

 * HEIF codec.

 * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>

 *

 * This file is part of libheif.

 *

 * libheif 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 3 of

 * the License, or (at your option) any later version.

 *

 * libheif 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 libheif.  If not, see <http://www.gnu.org/licenses/>.

 */

#include "file_layout.h"

#include "sequences/seq_boxes.h"

#include <limits>

FileLayout::FileLayout()

{

  auto ftyp = std::make_shared<Box_ftyp>();

  ftyp->set_output_position(0);

  m_boxes.push_back(ftyp);

  // TODO: these variables are not used yet

  (void)m_writeMode;

  (void)m_file_size;

}

Error FileLayout::read(const std::shared_ptr<StreamReader>& stream, const heif_security_limits* limits)

{

  m_boxes.clear();

  m_stream_reader = stream;

  // --- read initial range, large enough to cover 'ftyp' box

  m_max_length = stream->request_range(0, INITIAL_FTYP_REQUEST);

  if (m_max_length < MAXIMUM_BOX_HEADER_SIZE) {

    return {heif_error_Invalid_input,

            heif_suberror_Unspecified,

            "File size too small."};

  }

  // --- read 'ftyp' box header

  BitstreamRange ftyp_hdr_range(m_stream_reader, m_max_length);

  BoxHeader ftyp_header;

  Error err;

  err = ftyp_header.parse_header(ftyp_hdr_range);

  if (err) {

    return err;

  }

  // --- check whether it is a valid 'ftyp' box header

  if (ftyp_header.get_short_type() != fourcc("ftyp")) {

    return {heif_error_Invalid_input,

            heif_suberror_No_ftyp_box,

            "File does not start with 'ftyp' box."};

  }

  uint64_t ftyp_size = ftyp_header.get_box_size();

  if (ftyp_size == 0) {

    return {heif_error_Invalid_input,

            heif_suberror_No_ftyp_box,

            "ftyp box shall not be the only box in the file"};

  }

  if (ftyp_size > m_max_length) {

    return {heif_error_Invalid_input,

            heif_suberror_No_ftyp_box,

            "ftyp box larger than initial read range"};

  }

  // --- read the 'ftyp' box

  BitstreamRange ftyp_range(m_stream_reader, 0, ftyp_size);

  std::shared_ptr<Box> ftyp_box;

  err = Box::read(ftyp_range, &ftyp_box, limits);

  if (err) {

    return err;

  }

  m_boxes.push_back(ftyp_box);

  m_ftyp_box = std::dynamic_pointer_cast<Box_ftyp>(ftyp_box);

  // --- skip through box headers until we find the 'meta' box

  uint64_t next_box_start = ftyp_size;

  bool meta_found = false;

  bool mini_found = false;

  bool moov_found = false;

  for (;;) {

    // TODO: overflow

    uint64_t next_box_header_end = next_box_start + MAXIMUM_BOX_HEADER_SIZE;

    if (next_box_header_end > m_max_length) {

      m_max_length = stream->request_range(next_box_start, next_box_header_end);

    }

    if (next_box_header_end > m_max_length) {

      if (meta_found || mini_found || moov_found) {

        return Error::Ok;

      }

      else {

        return {heif_error_Invalid_input,

                heif_suberror_Unspecified,

                "Insufficient input data"};

      }

    }

    BitstreamRange box_range(m_stream_reader, next_box_start, m_max_length);

    BoxHeader box_header;

    err = box_header.parse_header(box_range);

    if (err) {

      return err;

    }

    if (box_header.get_short_type() == fourcc("meta")) {

      const uint64_t meta_box_start = next_box_start;

      uint64_t end_of_meta_box;

      if (box_header.get_box_size() == BoxHeader::size_until_end_of_file) {

        // A box size of 0 means the box extends to the end of the file

        // (ISO/IEC 14496-12 clause 4.2), which is legal for the last box.

        // Resolve it to the file size.

        end_of_meta_box = m_stream_reader->request_range(meta_box_start,

                                                         std::numeric_limits<uint64_t>::max());

        m_max_length = end_of_meta_box;

        if (end_of_meta_box <= meta_box_start) {

          return {heif_error_Invalid_input,

                  heif_suberror_No_meta_box,

                  "Cannot read meta box with unspecified size"};

        }

      }

      else {

        end_of_meta_box = box_header.get_box_size();

        if (end_of_meta_box > std::numeric_limits<uint64_t>::max() - meta_box_start) {

          return {heif_error_Invalid_input,

                  heif_suberror_No_meta_box,

                  "Cannot read meta box with invalid size"};

        }

        end_of_meta_box += meta_box_start;

      }

      if (m_max_length < end_of_meta_box) {

        m_max_length = m_stream_reader->request_range(meta_box_start, end_of_meta_box);

      }

      if (m_max_length < end_of_meta_box) {

        return {heif_error_Invalid_input,

                heif_suberror_No_meta_box,

                "Cannot read full meta box"};

      }

      BitstreamRange meta_box_range(m_stream_reader, meta_box_start, end_of_meta_box);

      std::shared_ptr<Box> meta_box;

      err = Box::read(meta_box_range, &meta_box, limits);

      if (err) {

        return err;

      }

      m_boxes.push_back(meta_box);

      m_meta_box = std::dynamic_pointer_cast<Box_meta>(meta_box);

      meta_found = true;

    }

    // TODO: this is basically the same as the meta box case above, with different error handling.

    if (box_header.get_short_type() == fourcc("mini")) {

      const uint64_t mini_box_start = next_box_start;

      uint64_t end_of_mini_box;

      if (box_header.get_box_size() == BoxHeader::size_until_end_of_file) {

        // A box size of 0 means the box extends to the end of the file

        // (ISO/IEC 14496-12 clause 4.2), which is legal for the last box.

        // Resolve it to the file size.

        end_of_mini_box = m_stream_reader->request_range(mini_box_start,

                                                         std::numeric_limits<uint64_t>::max());

        m_max_length = end_of_mini_box;

        if (end_of_mini_box <= mini_box_start) {

          return {heif_error_Invalid_input,

                  heif_suberror_Invalid_mini_box,

                  "Cannot read mini box with unspecified size"};

        }

      }

      else {

        end_of_mini_box = box_header.get_box_size();

        if (end_of_mini_box > std::numeric_limits<uint64_t>::max() - mini_box_start) {

          return {heif_error_Invalid_input,

                  heif_suberror_Invalid_mini_box,

                  "Cannot read mini box with invalid size"};

        }

        end_of_mini_box += mini_box_start;

      }

      if (m_max_length < end_of_mini_box) {

        m_max_length = m_stream_reader->request_range(mini_box_start, end_of_mini_box);

      }

      if (m_max_length < end_of_mini_box) {

        return {heif_error_Invalid_input,

                heif_suberror_Invalid_mini_box,

                "Cannot read full mini box"};

      }

      BitstreamRange mini_box_range(m_stream_reader, mini_box_start, end_of_mini_box);

      std::shared_ptr<Box> mini_box;

      err = Box::read(mini_box_range, &mini_box, limits);

      if (err) {

        return err;

      }

      m_boxes.push_back(mini_box);

      m_mini_box = std::dynamic_pointer_cast<Box_mini>(mini_box);

      mini_found = true;

    }

    if (box_header.get_short_type() == fourcc("moov")) {

      const uint64_t moov_box_start = next_box_start;

      uint64_t end_of_moov_box;

      if (box_header.get_box_size() == BoxHeader::size_until_end_of_file) {

        // A box size of 0 means the box extends to the end of the file

        // (ISO/IEC 14496-12 clause 4.2), which is legal for the last box.

        // Resolve it to the file size.

        end_of_moov_box = m_stream_reader->request_range(moov_box_start,

                                                         std::numeric_limits<uint64_t>::max());

        m_max_length = end_of_moov_box;

        if (end_of_moov_box <= moov_box_start) {

          return {heif_error_Invalid_input,

                  heif_suberror_No_moov_box,

                  "Cannot read moov box with unspecified size"};

        }

      }

      else {

        end_of_moov_box = box_header.get_box_size();

        if (end_of_moov_box > std::numeric_limits<uint64_t>::max() - moov_box_start) {

          return {heif_error_Invalid_input,

                  heif_suberror_No_moov_box,

                  "Cannot read moov box with invalid size"};

        }

        end_of_moov_box += moov_box_start;

      }

      if (m_max_length < end_of_moov_box) {

        m_max_length = m_stream_reader->request_range(moov_box_start, end_of_moov_box);

      }

      if (m_max_length < end_of_moov_box) {

        return {heif_error_Invalid_input,

                heif_suberror_No_moov_box,

                "Cannot read full moov box"};

      }

      BitstreamRange moov_box_range(m_stream_reader, moov_box_start, end_of_moov_box);

      std::shared_ptr<Box> moov_box;

      err = Box::read(moov_box_range, &moov_box, limits);

      if (err) {

        return err;

      }

      m_boxes.push_back(moov_box);

      m_moov_box = std::dynamic_pointer_cast<Box_moov>(moov_box);

      moov_found = true;

    }

    uint64_t boxSize = box_header.get_box_size();

    if (boxSize == Box::size_until_end_of_file) {

      if (meta_found || mini_found || moov_found) {

        return Error::Ok;

      }

      else {

        return {heif_error_Invalid_input,

                heif_suberror_Unspecified,

                "No meta box found"};

      }

    }

    if (std::numeric_limits<uint64_t>::max() - boxSize < next_box_start) {

      return {heif_error_Invalid_input,

              heif_suberror_Unspecified,

              "Box size too large, integer overflow"};

    }

    next_box_start = next_box_start + boxSize;

  }

  return Error::Ok;

}

void FileLayout::set_write_mode(WriteMode writeMode, const std::shared_ptr<StreamWriter>& writer)

{

}

Error FileLayout::write(std::shared_ptr<StreamWriter>& stream)

{

  return Error::Ok;

}