// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

#ifndef PYARROW_IO_H
#define PYARROW_IO_H

#include "arrow/io/interfaces.h"
#include "arrow/io/memory.h"
#include "arrow/util/visibility.h"

#include "arrow/python/config.h"

#include "arrow/python/common.h"

namespace arrow {

class MemoryPool;

namespace py {

// A common interface to a Python file-like object. Must acquire GIL before
// calling any methods
class ARROW_EXPORT PythonFile {
 public:
  explicit PythonFile(PyObject* file);
  ~PythonFile();

  Status Close();
  Status Seek(int64_t position, int whence);
  Status Read(int64_t nbytes, PyObject** out);
  Status Tell(int64_t* position);
  Status Write(const uint8_t* data, int64_t nbytes);

 private:
  PyObject* file_;
};

class ARROW_EXPORT PyReadableFile : public io::RandomAccessFile {
 public:
  explicit PyReadableFile(PyObject* file);
  virtual ~PyReadableFile();

  Status Close() override;

  Status Read(int64_t nbytes, int64_t* bytes_read, uint8_t* out) override;
  Status Read(int64_t nbytes, std::shared_ptr<Buffer>* out) override;

  Status GetSize(int64_t* size) override;

  Status Seek(int64_t position) override;

  Status Tell(int64_t* position) override;

  bool supports_zero_copy() const override;

 private:
  std::unique_ptr<PythonFile> file_;
};

class ARROW_EXPORT PyOutputStream : public io::OutputStream {
 public:
  explicit PyOutputStream(PyObject* file);
  virtual ~PyOutputStream();

  Status Close() override;
  Status Tell(int64_t* position) override;
  Status Write(const uint8_t* data, int64_t nbytes) override;

 private:
  std::unique_ptr<PythonFile> file_;
  int64_t position_;
};

// A zero-copy reader backed by a PyBuffer object
class ARROW_EXPORT PyBytesReader : public io::BufferReader {
 public:
  explicit PyBytesReader(PyObject* obj);
  virtual ~PyBytesReader();
};

// TODO(wesm): seekable output files

}  // namespace py
}  // namespace arrow

#endif  // PYARROW_IO_H
