// Copyright 2019 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef EASYMEDIA_STREAM_H_
#define EASYMEDIA_STREAM_H_

#include <stddef.h>
#include <stdint.h>

#ifdef __cplusplus
extern "C" {

typedef struct {
    int (*close)(void* stream);
    size_t (*read)(void* ptr, size_t size, size_t nmemb, void* stream);
    size_t (*write)(const void* ptr, size_t size, size_t nmemb, void* stream);
    int (*seek)(void* stream, int64_t offset, int whence);
    long (*tell)(void* stream);
} StreamOperation;
}
#endif

#include "control.h"
#include "image.h"
#include "media_reflector.h"
#include "utils.h"

namespace easymedia
{

    DECLARE_FACTORY(Stream)

    // usage: REFLECTOR(Stream)::Create<T>(streamname, param)
    //        T must be the final class type exposed to user
    DECLARE_REFLECTOR(Stream)

#define DEFINE_STREAM_FACTORY(REAL_PRODUCT, FINAL_EXPOSE_PRODUCT)                                                      \
    DEFINE_MEDIA_CHILD_FACTORY(REAL_PRODUCT, REAL_PRODUCT::GetStreamName(), FINAL_EXPOSE_PRODUCT, Stream)              \
    DEFINE_MEDIA_CHILD_FACTORY_EXTRA(REAL_PRODUCT)                                                                     \
    DEFINE_MEDIA_NEW_PRODUCT_BY(REAL_PRODUCT, FINAL_EXPOSE_PRODUCT, Open() < 0)

    class MediaBuffer;
#ifdef IN_EASYMEDIA_STREAM_CC
    static int local_close(void* stream);
#endif
    // interface
    class _API Stream
    {
      public:
        static StreamOperation c_operations;

        Stream() : readable(false), writeable(false), seekable(false)
        {
        }
        virtual ~Stream() = default;

        virtual size_t Read(void* ptr, size_t size, size_t nmemb) = 0;
        virtual size_t Write(const void* ptr, size_t size, size_t nmemb) = 0;
        // whence: SEEK_SET, SEEK_CUR, SEEK_END
        virtual int Seek(int64_t offset, int whence) = 0;
        virtual long Tell() = 0;

        virtual int NewStream(std::string new_path _UNUSED)
        {
            return -1;
        };
        virtual size_t WriteAndClose(const void* ptr _UNUSED, size_t size _UNUSED, size_t nmemb _UNUSED)
        {
            return -1;
        };
        virtual int ReName(std::string old_path _UNUSED, std::string new_path _UNUSED)
        {
            return -1;
        };

        virtual bool Readable()
        {
            return readable;
        }
        virtual bool Writeable()
        {
            return writeable;
        }
        virtual bool Seekable()
        {
            return seekable;
        }

        void SetReadable(bool able)
        {
            readable = able;
        }
        void SetWriteable(bool able)
        {
            writeable = able;
        }
        void SetSeekable(bool able)
        {
            seekable = able;
        }

        virtual bool Eof()
        {
            return false;
        }

        // No need size input. For some device, such as V4L2, always return specific
        // buffer
        virtual std::shared_ptr<MediaBuffer> Read()
        {
            return nullptr;
        }
        virtual bool Write(std::shared_ptr<MediaBuffer>)
        {
            return false;
        }
        // The IoCtrl must be called in the same thread of Read()/Write()
        virtual int IoCtrl(unsigned long int request _UNUSED, ...)
        {
            return -1;
        }
        virtual int SubIoCtrl(unsigned long int request _UNUSED, void* arg, int size = 0)
        {
            SubRequest subreq = {request, size, arg};
            return IoCtrl(S_SUB_REQUEST, &subreq);
        }

        // read data as image by ImageInfo
        bool ReadImage(void* ptr, const ImageInfo& info);

      protected:
        virtual int Open() = 0;
        virtual int Close() = 0;

        friend int local_close(void* stream);

      private:
        bool readable;
        bool writeable;
        bool seekable;

        DECLARE_PART_FINAL_EXPOSE_PRODUCT(Stream)
    };

} // namespace easymedia

#endif // #ifndef EASYMEDIA_STREAM_H_