/* -*- Mode: C++ -*- */
/*
 * libopenraw - rawfile.h
 *
 * Copyright (C) 2005-2016 Hubert Figuière
 *
 * This library 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.
 *
 * This library 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 this library.  If not, see
 * <http://www.gnu.org/licenses/>.
 */



#ifndef LIBOPENRAWPP_RAWFILE_H_
#define LIBOPENRAWPP_RAWFILE_H_

#include <string>
#include <vector>

#include <libopenraw/rawfile.h>

namespace OpenRaw {

namespace IO {
class Stream;
}
class Thumbnail;
class RawData;
class BitmapData;
class MetaValue;

namespace Internals {
class RawContainer;
class ThumbDesc;
struct BuiltinColourMatrix;
}

void init();

class RawFile
{
public:
    typedef ::or_rawfile_type Type;
    typedef ::or_rawfile_typeid TypeId;

    RawFile(const RawFile&) = delete;
    RawFile & operator=(const RawFile &) = delete;

    /** return a NULL terminated list of file extensions 
     * that the library handle. This is purely informational.
     * @return a pointer the list, NULL terminated. The pointer is
     * owned by the library.
     */
    static const char **fileExtensions();

    /** factory method to create the proper RawFile instance.
     * @param _filename the name of the file to load
     * @param _typeHint a hint on the type. Use UNKNOWN_TYPE
     * if you want to let the library detect it for you.
     */
    static RawFile *newRawFile(const char*_filename, 
                               Type _typeHint = OR_RAWFILE_TYPE_UNKNOWN);
    /** factory method to create the proper RawFile instance 
     *  from content 
     * @param buffer the buffer to examine.
     * @param len the number of bytes in the length.
     * @param _typeHint a hint on the type. Use UNKNOWN_TYPE
     * if you want to let the library detect it for you.
     */
    static RawFile *newRawFileFromMemory(const uint8_t *buffer, uint32_t len, 
                                         Type _typeHint = OR_RAWFILE_TYPE_UNKNOWN);

    /** Destructor */
    virtual ~RawFile();
    /** Accessor for the type */
    Type type() const;

    /** The RAW file type ID. Identify it if needed. 
     *  @todo figure how to make this const.
     */
    TypeId typeId();

    // standard api, like get thumbnail
    // and get exif.

    /** list the available thumbnail sizes
     */
    const std::vector<uint32_t> & listThumbnailSizes(void);
    /** Get the thumbnail from the raw file 
     * @param size the square size in px
     * @param thumbnail the thumbnail to extract into
     * @return the error code
     */
    ::or_error getThumbnail(uint32_t size, Thumbnail & thumbnail);

    /** Get the RAW data 
     * @param rawdata the RawData to put the data into
     * @param options the option bits defined by %or_options
     * @return the error code
     */
    ::or_error getRawData(RawData & rawdata, uint32_t options);

    /** Get the rendered image
     * @param bitmapdata the BitmapData to put the image into
     * @param options the option bits. Pass 0 for now.
     * @return the error code
     */
    ::or_error getRenderedImage(BitmapData & bitmapdata, uint32_t options);    

    /** Get the orientation of the image, using Exif enums.
     */
    int32_t getOrientation();

    /**
     * @return the number of items in the colour matrix.
     */
    uint32_t colourMatrixSize();

    /** Get colour matrix
     * @param index The matrix index.
     * @param [out] matrix an array of %size double.
     * @param size the size of the buffer. On out the actual size. If it is too 
     * small the size is adjusted and an error %OR_ERROR_BUF_TOO_SMALL returned.
     * @return an error code.
     */
    ::or_error getColourMatrix1(double* matrix, uint32_t & size);
    ::or_error getColourMatrix2(double* matrix, uint32_t & size);

    /** Get calibration illuminant that match the colour matrix.
     * @return the Exif value. 0 = unknown. Likely not found.
     */
    ExifLightsourceValue getCalibrationIlluminant1();
    ExifLightsourceValue getCalibrationIlluminant2();

    const MetaValue *getMetaValue(int32_t meta_index);
protected:
    struct camera_ids_t {
        const char * model;
        const uint32_t type_id;
    };
    /**
     * Construct a raw file
     * @param _type the type
     */
    RawFile(Type _type);

    /** Set the file type id */
    void _setTypeId(TypeId _type_id);
    /** Just get the type id value. No identification.
     *  You might want to use %typeId() in the general case.
     */
    TypeId _typeId() const;

    /** Get the container. */
    virtual Internals::RawContainer* getContainer() const = 0;

    /** enumerate the thumbnail sizes. 
     * @param list the list to enumerate into
     * @return OR_ERROR_NONE if success
     */
    virtual ::or_error _enumThumbnailSizes(std::vector<uint32_t> &list) = 0;
		
    /** get the thumbnail of exact size. 
     * @param size the size in pixel of the square
     * @retval thumbnail the thumbnail to load
     * @return OR_ERROR_NONE if success
     * @seealso listThumbnailSizes() to understand how to fetch the sizes
     * available
     */
    virtual ::or_error _getThumbnail(uint32_t size, Thumbnail & thumbnail);
    void _addThumbnail(uint32_t size, const Internals::ThumbDesc& desc);

    /** get the RAW data 
     * @param data the RAW data
     * @param option the option bits
     * @return OR_ERROR_NONE if success
     * Return the data compressed or uncompressed.
     */
    virtual ::or_error _getRawData(RawData & data, uint32_t options) = 0;

    /** get the colour matrix.
     * @param index 1 or 2
     */
    virtual ::or_error _getColourMatrix(uint32_t index, double* matrix, uint32_t & size);
    virtual ExifLightsourceValue _getCalibrationIlluminant(uint16_t index);
    virtual MetaValue *_getMetaValue(int32_t /*meta_index*/) = 0;

    TypeId _typeIdFromModel(const std::string& make, const std::string & model);
    TypeId _typeIdFromMake(const std::string& make);
    void _setIdMap(const camera_ids_t *map);
    void _setMatrices(const Internals::BuiltinColourMatrix* matrices);
    const Internals::BuiltinColourMatrix* _getMatrices() const;

    virtual void _identifyId() = 0;

    static ::or_error _getBuiltinLevels(const Internals::BuiltinColourMatrix* m,
                                        TypeId type_id,
                                        uint16_t & black,
                                        uint16_t & white);
    static ::or_error _getBuiltinColourMatrix(const Internals::BuiltinColourMatrix* m,
                                              TypeId type_id,
                                              double* matrix,
                                              uint32_t & size);

private:
    static Type identify(const char*_filename);
    static ::or_error identifyBuffer(const uint8_t* buff, size_t len,
                                     Type &_type);
    static const camera_ids_t s_make[];
    static const camera_ids_t* _lookupCameraId(const camera_ids_t * map,
                                               const std::string& value);


    class Private;

    Private *d;
};



}

/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0))
  indent-tabs-mode:nil
  fill-column:80
  End:
*/
#endif