#pragma once


#include <cstdint>
#include "ColorRgba.h"


namespace Data
{
  extern const unsigned short MORTON_TABLE[256];
  extern const uint8_t BITSCALE_5_TO_8[32];
  extern const uint8_t BITSCALE_4_TO_8[16];
  extern const uint8_t BITSCALE_3_TO_8[8];
  extern const uint8_t BITSCALE_8_TO_5_FLOOR[256];
  extern const uint8_t BITSCALE_8_TO_4_FLOOR[256];
  extern const uint8_t BITSCALE_8_TO_3_FLOOR[256];
  extern const uint8_t BITSCALE_8_TO_5_CEIL[256];
  extern const uint8_t BITSCALE_8_TO_4_CEIL[256];
  extern const uint8_t BITSCALE_8_TO_3_CEIL[256];
} // namespace Data


class Bitmap {
public:
    int width;
    int height;
    unsigned char *data;

    Bitmap(int w, int h, int bytesPerPixel)
        : width(w)
        , height(h)
        , data(new unsigned char[width * height * bytesPerPixel]) {
    }
    virtual ~Bitmap() {
        delete [] data;
    }

    void GetSize(int& w, int& h) const { w = width; h = height; }
    int GetArea() const { return width * height; }
    int GetBitmapWidth() const { return width; }
    int GetBitmapHeight() const { return height; }
    const unsigned char *GetRawData() const { return data; }
};


class AlphaBitmap : public Bitmap {
public:
    AlphaBitmap(int w, int h) : Bitmap(w, h, 1) {} 
    const unsigned char *GetData() const { return data; }
    unsigned char *GetData() { return data; }
};


class RgbBitmap : public Bitmap {
public:
    RgbBitmap(int w, int h) : Bitmap(w, h, 3) {}
    const ColorRgb<unsigned char> *GetData() const { 
        return reinterpret_cast<ColorRgb<unsigned char> *>(data); 
    }
    ColorRgb<unsigned char> *GetData() { 
        return reinterpret_cast<ColorRgb<unsigned char> *>(data); 
    }
};


class RgbaBitmap : public Bitmap {
public:
    RgbaBitmap(int w, int h) : Bitmap(w, h, 4) {}
    const ColorRgba<unsigned char> *GetData() const { 
        return reinterpret_cast<ColorRgba<unsigned char> *>(data); 
    }
    ColorRgba<unsigned char> *GetData() { 
        return reinterpret_cast<ColorRgba<unsigned char> *>(data); 
    }
};


class BitUtility {
public:
    static bool IsPowerOf2(unsigned int x) {
        return (x & (x - 1)) == 0;
    }

    static unsigned int RotateRight(unsigned int value, unsigned int shift) {
        if ((shift &= sizeof(value) * 8 - 1) == 0) {
            return value;
        }
        return (value >> shift) | (value << (sizeof(value) * 8 - shift));
    }
};



template<typename T>
class Interval {
public:
    T min;
    T max;

    Interval() {
    }

    Interval<T> &operator|=(const T &x) {
        min.SetMin(x); 
        max.SetMax(x);
        return *this;
    }
};