#ifndef IMAGE_MAT_QUEUE_H
#define IMAGE_MAT_QUEUE_H

#include "../ImageProcess/ImageApplyHeaders.h"
#include "PaperSize.h"


#if defined(WIN32) || defined(_WIN64)
class IMat2Bmp {
public:
    virtual ~IMat2Bmp() {}
    virtual std::vector<unsigned char> getBmpDataBuffer() {
        return m_data;
    };
protected:
    std::vector<unsigned char> m_data;
};

class Mat2Bmp:public IMat2Bmp {
public:
    Mat2Bmp(const cv::Mat& mat,float res) {
        int headersize = mat.channels() == 3 ? 54 : 1078;
        int bmpdatasize = mat.step1() * mat.rows;
        m_data.resize(headersize + bmpdatasize);
        cv::imencode(".bmp", mat, m_data);
        BITMAPINFOHEADER* infoheader =(BITMAPINFOHEADER*)(m_data.data()+sizeof(BITMAPFILEHEADER));
        infoheader->biXPelsPerMeter = infoheader->biYPelsPerMeter = static_cast<LONG>(res * 39.37F + 0.5);
        infoheader->biClrUsed = infoheader->biClrImportant=infoheader->biBitCount == 8 ? 256 : 0;
        //short palettesize = sizeof(RGBQUAD) * infoheader->biClrUsed;
        //int imagedatasize = BYTES_PERLINE_ALIGN4(mat.cols, infoheader->biBitCount) * mat.rows;
        //int bitmapSize = sizeof(BITMAPINFOHEADER) + palettesize + imagedatasize;
        //infoheader->biSizeImage = bitmapSize;
    }
};

class Mat2BmpBw :public IMat2Bmp {
public:
    Mat2BmpBw(const cv::Mat& mat,float res) {
        //cv::imwrite("bw.bmp", mat);
        int headsize = 62;
        int width = mat.cols;
        int height = mat.rows;
        int bmpdatasize = (width + 31) / 32 * 4*height;
        m_data.resize(headsize + bmpdatasize);
        unsigned char* binary = m_data.data()+62;//file header(14)+info header(40)+RGBQUAD(8)
        setBmpFileHeader(mat,bmpdatasize);
        setBmpInfoHeader(mat, bmpdatasize, res);
        memcpy(m_data.data(), &m_fileHeader, sizeof(BITMAPFILEHEADER));
        memcpy(m_data.data() + sizeof(BITMAPFILEHEADER), &m_infoHeader, sizeof(BITMAPINFOHEADER));
        RGBQUAD* quad = (RGBQUAD*)(m_data.data() + sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER));
        quad->rgbBlue = quad->rgbGreen = quad->rgbRed = quad->rgbReserved = 0;
        quad++;
        quad->rgbBlue = quad->rgbGreen = quad->rgbRed = 255;
        quad->rgbReserved = 0;

        unsigned char* imageData = mat.data;
        unsigned char temp;
        int n_lineByte = (width + 7) >> 3;
        int m_lineByte = ((n_lineByte * 8 + 31) >> 5) << 2;
        for (int row = height - 1; row >= 0; row--)
        {
            for (int col = 0; col < width; col++)
            {
                int pos = col % 8;
                int pix = *(imageData + row * mat.step1() + col);
                temp = 1 << (7 - pos);
                if (pix == 255)
                {
                    *(binary + (height - row - 1) * m_lineByte + col / 8) |= temp ;
                }
                else
                {
                    *(binary + (height - row - 1) * m_lineByte + col / 8) &= (~temp);
                }
            }
        }
    }
private:
    void setBmpFileHeader(const cv::Mat& mat,const int bmpDataLen) {
        memset(&m_fileHeader, 0, sizeof(BITMAPFILEHEADER));
        m_fileHeader.bfType = ((unsigned short)('M' << 8) | 'B');
        m_fileHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (sizeof(RGBQUAD) * 1);
        int nDIBSize = sizeof(BITMAPINFOHEADER) + (sizeof(RGBQUAD) * 2) + bmpDataLen;
        m_fileHeader.bfSize = sizeof(BITMAPFILEHEADER) + nDIBSize;
    }

    void setBmpInfoHeader(const cv::Mat& mat,const int bmpDataLen, const long res) {
        memset(&m_infoHeader, 0, sizeof(BITMAPINFOHEADER));
        m_infoHeader.biSize = sizeof(BITMAPINFOHEADER);
        m_infoHeader.biWidth = mat.cols;
        m_infoHeader.biHeight = mat.rows;
        m_infoHeader.biPlanes = 1;
        m_infoHeader.biBitCount = 1;
        m_infoHeader.biCompression = 0;
        m_infoHeader.biSizeImage = bmpDataLen;
        m_infoHeader.biXPelsPerMeter = m_infoHeader.biYPelsPerMeter = static_cast<LONG>(res * 39.37F + 0.5);;
        m_infoHeader.biClrUsed = 2;
        m_infoHeader.biClrImportant = 2;
    }

private:
    BITMAPFILEHEADER m_fileHeader;
    BITMAPINFOHEADER m_infoHeader;
};
#endif

class IDecode 
{
public:
    virtual ~IDecode() {}
    virtual std::vector<std::shared_ptr<std::vector<char>>> getImageBuffs() 
    {
        return m_buffs;
    }
protected:
    std::vector<std::shared_ptr<std::vector<char>>> m_buffs;
};

class G200Decode : public IDecode
{
public:
    G200Decode(std::shared_ptr<std::vector<char>> buff,bool is_duplex,bool is_switchFrontBack);
    //G200Decode(void* buf, unsigned bytes);
};

class G400Decode : public IDecode
{
public:
    G400Decode(std::shared_ptr<std::vector<char>> buff,bool is_duplex);
};


class GRawDecode : public IDecode 
{
public:
    GRawDecode(std::shared_ptr<std::vector<char>> buff);
    GRawDecode(void* data, size_t bytes);
};



#endif