#ifndef GRIB_FUNCTIONS_H
#define GRIB_FUNCTIONS_H

#define SW_INCLUDE_FILE "GRIB_Functions"
#include "INCLUDE.h"

#include "TREE_Functions.h"

#define GRIB_WRAP_MASK (unsigned long)(1)

#ifndef GRIB_FUNCTIONS_C

    extern char * GRIB_ptrOriginatingCenters[];
    extern char * GRIB_ptrGeneratingProcess[];
    extern char * GRIB_ptrParameter[];
    extern char * GRIB_ptrParameterSimple[];
    extern char * GRIB_ptrParameterLevel[];

#endif

namespace GRIB
{
    #include "GRIB_Enumerations.h"

    inline DataType
    Type(const char * Type)
    {
        return (DataType)(UTIL::String::CompareMulti(Type,
                                                     (const char **)(&(GRIB_ptrParameterSimple[0])),
                                                     255) - 1);
    }

    inline const char *
    Type(const DataType Type)
    {
        return ( (int)(Type) >= 0 && (int)(Type) <= 255 )
            ? GRIB_ptrParameterSimple[Type]
            : NULL;
    }

    struct Is
    {
        unsigned int  m_uintSectionLength;
        unsigned char m_uchrVersionNumber;

        bool Read(UTIL::Input * In);
        bool Write(UTIL::Output * Out) const;
    };

    struct Pds
    {
        unsigned int   m_uintSectionLength;
        unsigned char  m_uchrVersionNumber;
        unsigned char  m_uchrOriginatingCenter;
        unsigned char  m_uchrGeneratingProcess;
        unsigned char  m_uchrGridIndex;
        unsigned char  m_uchrFlag;
        unsigned char  m_uchrParameter;
        unsigned char  m_uchrParameterLevel;
        unsigned short m_ushtHeightPressureLevels;
        unsigned char  m_uchrYear;
        unsigned char  m_uchrMonth;
        unsigned char  m_uchrDay;
        unsigned char  m_uchrHour;
        unsigned char  m_uchrMinute;
        unsigned char  m_uchrForecastTimeUnit;
        unsigned char  m_uchrTimePeriod1;
        unsigned char  m_uchrTimePeriod2;
        unsigned char  m_uchrTimeRangeIndicator;
        unsigned short m_ushtTimePeriod1;
        unsigned char  m_uchrMissingNumber;
        unsigned char  m_uchrCentury;
        unsigned char  m_uchrSubIdNumber;
        short          m_shtScaleFactor;
        void *         m_ptrExtraData;
        unsigned long  m_ulngExtraDataLength;

        Pds() : m_ptrExtraData(NULL), m_ulngExtraDataLength(0) {}
        ~Pds() {Finish();}

        void Finish(void);
        bool Read(UTIL::Input * In);
        bool Write(UTIL::Output * Out, const int FlagGds = 0, const int FlagBms = 0) const;
    };

    struct Gds
    {
	    struct Grid *  m_ptrGrid;
	    float          m_fltCorners[4];
	    unsigned int   m_uintSectionLength;
	    unsigned long  m_ulngGridPoints;
	    unsigned char  m_uchrVerticalNumberAmount;
	    unsigned char  m_uchrVerticalIndex;
	    unsigned char  m_uchrDataRepresentType;

        Gds() : m_ptrGrid(NULL) {}
        ~Gds() {Finish();}

        void Finish(void);
        bool Read(UTIL::Input * In);
        bool Write(UTIL::Output * Out, const unsigned short * Indices = NULL) const;
    };

    struct Bms
    {
	    unsigned int    m_uintSectionLength;
	    unsigned int    m_uintBitmapLength;
	    unsigned char * m_ptrBitmap;
	    unsigned short  m_ushtBitmapReference;
	    unsigned char   m_uchrUnusedBits;

        Bms() : m_ptrBitmap(NULL), m_uintBitmapLength(0) {}
        ~Bms() {Finish();}

        void Finish(void) {UTIL_SAFE_FREE(m_ptrBitmap); m_uintBitmapLength = 0;}
        int  CheckBit(const unsigned long Bit) const;
        bool Read(UTIL::Input * In, const bool ReadMask);
        bool Write(UTIL::Output * Out) const;
    };

    struct Bds
    {
	    unsigned int    m_uintDataAmount;
	    unsigned int    m_uintOutputSize;

        unsigned char   m_uchrReferenceValue[4];
	    unsigned char * m_ptrData;
	    unsigned int    m_uintDataLength;
	    unsigned int    m_uintSectionLength;
	    float           m_fltReferenceValue;
        float           m_fltScaleFactorDecimal;
        float           m_fltScaleFactorBinary;
	    short           m_shtScaleFactor;
	    unsigned char   m_uchrPackBits;
	    unsigned char   m_uchrFlag;
	    unsigned char   m_uchrFlagExtention;
 
        Bds() : m_ptrData(NULL), m_uintDataLength(0) {}
        ~Bds() {Finish();}

        void  Finish(void) {UTIL_SAFE_FREE(m_ptrData); m_uintDataLength = 0;}
        float GetData(const unsigned long Position) const;
        bool  Read(UTIL::Input * In, const bool ReadData);
        void  ValueCopy(const unsigned int Index, char * Data, unsigned int & Byte, unsigned int & Bit) const;
        float ValueGet(const unsigned int Index) const;
        bool  Write(UTIL::Output * p_ptrOut, const char * BitmapNew = NULL, const unsigned long PointsNew = 0, const char * BitmapCurrent = NULL, const unsigned long PointsCurrent = 0) const;
    };

    struct ChopParameters
    {
        float        m_fltMultiplier;
        float *      m_ptrConversionsTo;
        float *      m_ptrConversionsFrom;
        float *      m_ptrConversionDeltas;
        unsigned int m_uintConversions;

        ChopParameters()
            : m_fltMultiplier(1.0f),
              m_ptrConversionsTo(NULL),
              m_ptrConversionsFrom(NULL),
              m_ptrConversionDeltas(NULL),
              m_uintConversions(0) {}

        inline float Value(float p_fltValue)
        {
            p_fltValue *= m_fltMultiplier;

            for (unsigned int i=0; i<m_uintConversions; i++)
            {
                if ( p_fltValue >= (m_ptrConversionsFrom[i] - m_ptrConversionDeltas[i]) &&
                     p_fltValue <= (m_ptrConversionsFrom[i] + m_ptrConversionDeltas[i]) )
                {
                    return m_ptrConversionsTo[i];
                }
            }

            return p_fltValue;
        }
    };

    struct ChopResults
    {
        UTIL::D2::Box m_stuCorners;
        float         m_fltExtremes[2];
        bool          m_blnDataSet;

        ChopResults()
        {
            m_blnDataSet = false;
            m_fltExtremes[0] = UTIL::Max(0.0f);
            m_fltExtremes[1] = -1.0f * UTIL::Max(0.0f);
        }

        inline void Add(const float p_fltValue,
                        const UTIL::D2::Point p_stuPoint,
                        const bool p_blnDataExists)
        {
            if ( m_fltExtremes[0] > p_fltValue )
                m_fltExtremes[0] = p_fltValue;
            if ( m_fltExtremes[1] < p_fltValue )
                m_fltExtremes[1] = p_fltValue;

            if ( p_blnDataExists )
                m_stuCorners.AddW(&p_stuPoint);
            else
            {
                m_stuCorners[0] = m_stuCorners[1] = p_stuPoint[0];
                m_stuCorners[2] = m_stuCorners[3] = p_stuPoint[1];
            }
        }
    };

    struct ChopData
    {
        const Bds *    m_ptrBds;
        unsigned int   m_ushtPointsY;
        unsigned int   m_ushtPointsX;
        unsigned long  m_ulngDataPosition;
        int            m_intFirstPointX;
        int            m_intFirstPointY;
        short          m_shtIncrementX;
        short          m_shtIncrementY;
        unsigned short m_ushtIndices[4];

        ChopData()
        {
            m_ulngDataPosition = 0;
            m_ushtIndices[1] = m_ushtIndices[3] = 0;
            m_ushtIndices[0] = m_ushtIndices[2] = (unsigned short)(-1);
        }

        unsigned long Chop(TREE::Basic<float, float> * Tree, ChopParameters * Parameters, ChopResults * Results, const Bms * Bms, unsigned char * Bitmap);
        unsigned long Chop(TREE::Basic<float, float> * Tree, ChopParameters * Parameters, ChopResults * Results, unsigned char * Bitmap);
        unsigned long Chop(TREE::Basic<float, float> * Tree, ChopParameters * Parameters, ChopResults * Results, const Bms * Bms);
        unsigned long Chop(TREE::Basic<float, float> * Tree, ChopParameters * Parameters, ChopResults * Results);
    };

    class Message
    {
        friend struct Grid;

    private:

        Is            m_stuIs;
        Pds           m_stuPds;
        Gds           m_stuGds;
        Bds           m_stuBds;
        Bms           m_stuBms;
        DataType      m_enmType;
	    unsigned int  m_uintDecimalScaleFactor;

        bool ReadPds(UTIL::Input * In);
        bool ReadGds(UTIL::Input * In);
        bool ReadBds(UTIL::Input * In, const bool ReadData = true);
        bool ReadBms(UTIL::Input * In, const bool ReadMask = true);

    public:

        ~Message() {Finish();}

        UTIL::D2::Box Area(void) const {return UTIL::D2::Box(m_stuGds.m_fltCorners[0], m_stuGds.m_fltCorners[1], m_stuGds.m_fltCorners[2], m_stuGds.m_fltCorners[3]);}
        void          Basetime(UTIL::Time * Time) const;
        bool          Chop(TREE::Basic<float, float> * Tree, UTIL::Output * Out = NULL, ChopParameters * Parameters = NULL, ChopResults * Results = NULL) const;
        void          Finish(void) {m_stuPds.Finish(); m_stuGds.Finish(); m_stuBds.Finish(); m_stuBms.Finish();}
        int           Interval(void) const;
        bool          Read(UTIL::Input * In, const bool ReadMask = true, const bool ReadData = true);
        time_t        Time(void) const;
        DataType      Type(void) const {return (GRIB::DataType)(m_stuPds.m_uchrParameter);}
        bool          Write(UTIL::Output * Out) const;

    };

    bool Split(UTIL::Parser * GribData, const char * Directory, const char * Prefix, const char * Suffix, const unsigned char * Filter = NULL);

    struct Grid
    {
        unsigned long m_ulngGridPoints;
	    int           m_intFirstPointLat;
	    int           m_intFirstPointLon;
	    unsigned char m_uchrScanMode;
	    unsigned char m_uchrResolutionFlags;

        virtual bool SetChopData(ChopData * Data) = 0;
        virtual bool Read(UTIL::Input * In, float * Corners, unsigned long * p_ptrGridPoints) = 0;
        virtual bool Write(UTIL::Output * Out, const unsigned short * p_ptrNewIndices) = 0;
    };

    struct Grid_0 : Grid
    {
	    int            m_intLastPointLat;
	    int            m_intLastPointLon;
	    short          m_shtIncrementDirectionI;
	    short          m_shtIncrementDirectionJ;
	    unsigned short m_ushtParallelPoints;
	    unsigned short m_ushtMeridianPoints;

        virtual bool SetChopData(ChopData * Data);
        virtual bool Read(UTIL::Input * In, float * Corners, unsigned long * p_ptrGridPoints);
        virtual bool Write(UTIL::Output * Out, const unsigned short * p_ptrNewIndices);
    };

    struct Grid_1 : Grid
    {
	    int            m_intLastPointLat;
	    int            m_intLastPointLon;
	    int            m_intIntersectionLat;
	    int            m_intIncrementDirectionI;
	    int            m_intIncrementDirectionJ;
	    unsigned short m_ushtParallelPoints;
	    unsigned short m_ushtMeridianPoints;

        virtual bool SetChopData(ChopData * Data);
        virtual bool Read(UTIL::Input * In, float * Corners, unsigned long * p_ptrGridPoints);
        virtual bool Write(UTIL::Output * Out, const unsigned short * p_ptrNewIndices);
    };

    struct Grid_3 : Grid
    {
	    int            m_intOrientationLov;
	    int            m_intDirectionLengthX;
	    int            m_intDirectionLengthY;
	    int            m_intIntersectionLat1;
	    int            m_intIntersectionLat2;
	    int            m_intSouthPoleLat;
	    int            m_intSouthPoleLon;
	    unsigned short m_ushtAxisPointsX;
	    unsigned short m_ushtAxisPointsY;
	    unsigned char  m_uchrProjectionCenter;

        virtual bool SetChopData(ChopData * Data);
        virtual bool Read(UTIL::Input * In, float * Corners, unsigned long * p_ptrGridPoints);
        virtual bool Write(UTIL::Output * Out, const unsigned short * p_ptrNewIndices);
    };

    struct Grid_5 : Grid
    {
	    int            m_intLongitudeOrientation;
	    int            m_intDirectionLengthX;
	    int            m_intDirectionLengthY;
	    unsigned short m_ushtAxisPointsX;
	    unsigned short m_ushtAxisPointsY;
	    unsigned char  m_uchrProjectionCenterFlag;

        virtual bool SetChopData(ChopData * Data);
        virtual bool Read(UTIL::Input * In, float * Corners, unsigned long * p_ptrGridPoints);
        virtual bool Write(UTIL::Output * Out, const unsigned short * p_ptrNewIndices);
    };
}

#endif