// グリッド一つ分
class cell {
  glm::vec3 _min;  //始点
  glm::vec3 _vecx; //方向1
  glm::vec3 _vecy; //方向2

public:
  cell(glm::vec3 _min_, glm::vec3 _vec_x, glm::vec3 _vec_y) {
    _min = _min_;
    _vecx = _vec_x;
    _vecy = _vec_y;
  }
  const glm::vec3& cmin()const {
    return _min;
  }
  const glm::vec3& cvecx()const {
    return _vecx;
  }
  const glm::vec3& cvecy()const {
    return _vecy;
  }

  // セルの中心
  glm::vec3 center()const {
    return _min + _vecx / 2.f + _vecy / 2.f;
  }
};

class grid {
  std::vector<cell> _cells;
  int _xcount;
  int _ycount;
  float _xwidth;
  float _ywidth;
  glm::vec3 _center;

public:

  size_t cellCount()const {
    return _cells.size();
  }
  cell& operator[](const size_t index) {
    return _cells[index];
  }
  const cell& operator[](const size_t index)const {
    return _cells[index];
  }
  grid() {}

  grid(const grid& g) {
    _cells = g._cells;
    _xcount = g._xcount;
    _ycount = g._ycount;
    _xwidth = g._xwidth;
    _ywidth = g._ywidth;
    _center = g._center;
  }
  grid& operator=(const grid& g) {
    _cells = g._cells;
    _xcount = g._xcount;
    _ycount = g._ycount;
    _xwidth = g._xwidth;
    _ywidth = g._ywidth;
    _center = g._center;
  }
  grid& operator=(grid&& g) {
    _cells = std::move(g._cells);
    _xcount = g._xcount;
    _ycount = g._ycount;
    _xwidth = g._xwidth;
    _ywidth = g._ywidth;
    _center = g._center;
    return *this;
  }

  // 平面一つ分。xcount × ycountのcellからなる
  grid(
    const glm::vec3 vecX,
    const glm::vec3 vecY,
    const glm::vec3 center,
    const float width,
    const float height,
    const int xcount,
    const int ycount) {

    _xcount = xcount;
    _ycount = ycount;
    _xwidth = width;
    _ywidth = height;

    _center = center;

    glm::vec3 NVecX = glm::normalize(vecX);
    glm::vec3 NVecY = glm::normalize(vecY);

    ////////////////////
    _cells.clear();

    // セル一個の縦方向、横方向のベクトル。長さはセル一個分
    const glm::vec3 CellVX = NVecX * (_xwidth / xcount);
    const glm::vec3 CellVY = NVecY * (_ywidth / ycount);

    // 面の始点
    const glm::vec3 Start = _center - NVecX * _xwidth / 2.f - NVecY * _ywidth / 2.f;

    for (size_t y = 0; y < ycount; y++) {
      for (size_t x = 0; x < xcount; x++) {

        // 各セルの始点
        glm::vec3 from =
          Start +
          CellVX * (float)x + CellVY * (float)y;

        // セルを記録
        _cells.push_back(
          cell(
            from,
            CellVX,
            CellVY
          )
        );

      }
    }

  }


  /*
  p0    p3
  +---------+
  |     |
  |     |
  |     |
  |     |
  +---------+
  p1    p2
  */
  glm::vec3 p0(const size_t index)const {
    return _cells[index].cmin();
  }
  glm::vec3 p1(const size_t index)const {

    return
      _cells[index].cmin() +
      _cells[index].cvecx();
  }
  glm::vec3 p2(const size_t index) const {
    return
      _cells[index].cmin() +
      _cells[index].cvecx() +
      _cells[index].cvecy();
  }
  glm::vec3 p3(const size_t index) const {
    return
      _cells[index].cmin() +
      _cells[index].cvecy();
  }

};

//! @brief グリッドを表示
//! @param [in] g グリッドオブジェクト
//! @param [in] dispcenter セルの中央を表示するか
void drawGrid(const grid& g, const bool dispcenter) {

  glLineWidth(1);
  glColor3d(1, 1, 1);
  for (size_t i = 0; i < g.cellCount(); i++) {
    glBegin(GL_LINE_LOOP);
    glVertex3fv(glm::value_ptr(g.p0(i)));
    glVertex3fv(glm::value_ptr(g.p1(i)));
    glVertex3fv(glm::value_ptr(g.p2(i)));
    glVertex3fv(glm::value_ptr(g.p3(i)));

    glEnd();
  }

  if (dispcenter) {
    glPointSize(1);
    glColor3d(1, 1, 1);
    glBegin(GL_POINTS);
    for (size_t i = 0; i < g.cellCount(); i++) {
      glVertex3fv(
        glm::value_ptr(g[i].center()));
    }
    glEnd();
  }
}

grid g(
  glm::vec3(1,0,0),
  glm::vec3(0,1,0),
  glm::vec3(0,0,0),
  4.f,4.f,
  10,10
);

drawGrid(g, false);

#pragma warning(disable:4996)

#include <vector>

// 圧縮に必要
#include <zlib.h>

#include <cassert>
#include <array>

// 圧縮に必要
#if _DEBUG
#pragma comment(lib,"zlibstaticd.lib")
#else
#pragma comment(lib,"zlibstatic.lib")
#endif

constexpr int BUFFER_SIZE = 1000;


struct buffer_t {
  size_t size;
  std::array<Byte, BUFFER_SIZE> buffer;

  buffer_t(
    const size_t _size,
    const std::array<Byte, BUFFER_SIZE>& data
  ) :
    size(_size),
    buffer(data) {}
};

//! @brief ファイルからデータを読み込む
//! @param [in] filename ファイル名
//! @param [out] ファイルを読み込んだ、固定長のバッファの一覧
//! @return ファイル一個分のデータ
void read_buffer(const char* filename, std::vector< buffer_t >& datalist) {
  // データの準備
  std::array<unsigned char, BUFFER_SIZE> buffer;
  FILE* fp = fopen(filename, "rb");

  do {
    size_t readsize = fread(buffer.data(), 1, buffer.size(), fp);

    // データと読み込んだサイズを保存
    datalist.emplace_back( readsize, buffer );


  } while (feof(fp) == 0);

  fclose(fp);

}

bool my_uncompress(
  const std::vector< buffer_t >& zippedBuffer,
  std::vector< buffer_t >& data_list) {

  z_stream strm;
  strm.zalloc = Z_NULL;
  strm.zfree = Z_NULL;
  strm.opaque = Z_NULL;
  strm.avail_in = 0;
  strm.next_in = Z_NULL;


  //初期化
  int ret = inflateInit(&strm);

  if (ret != Z_OK) {
    return false;
  }

  for (size_t i = 0; i < zippedBuffer.size(); i++) {

    // これから伸長するデータ。
    const buffer_t& inbuffer = zippedBuffer[i];

    strm.next_in = (Bytef*)inbuffer.buffer.data();
    strm.avail_in = (uInt)inbuffer.size;

    assert(strm.avail_in != 0);

    std::array<Byte, BUFFER_SIZE> tmpbuffer;

    do {
      strm.next_out = (Bytef*)tmpbuffer.data();// 伸長結果の書き込み先の指定
      strm.avail_out = BUFFER_SIZE;           // 書き込み先のバッファサイズ
      ret = inflate(&strm, Z_NO_FLUSH);       // 伸長
      assert((ret != Z_NEED_DICT) &&
        (ret != Z_STREAM_ERROR) &&
        (ret != Z_DATA_ERROR) &&
        (ret != Z_MEM_ERROR));

      uInt have = BUFFER_SIZE - strm.avail_out;// 展開されたデータのサイズ
      // 結果の出力先に積んでいく
      data_list.emplace_back(have, tmpbuffer);


    } while (strm.avail_out == 0);
  } while (ret != Z_STREAM_END);

  // 終了字呼び出す
  inflateEnd(&strm);

  return true;
}

int main()
{
  // freadで読み込むデータ一覧。
  // バッファが小さく一つの配列に収まらない状況を再現するため、
  // 小さめの領域のリストとして全てのデータを読み込む
  std::vector< buffer_t > zippedBuffer;

  // 圧縮済みデータを用意
  read_buffer("C:\\data\\cmp.data", zippedBuffer);

  std::vector< buffer_t > data_list;
  // 伸長実行
  my_uncompress(zippedBuffer, data_list);



  // ファイル書き出し
  FILE* fp = fopen("C:\\data\\uncmp.data", "wb");
  for (size_t i = 0; i < data_list.size(); i++) {
    const buffer_t& data = data_list[i];
    fwrite(data.buffer.data(), 1, data.size, fp);
  }
  fclose(fp);


}

#pragma warning(disable:4996)

#include <vector>

// 圧縮に必要
#include <zlib.h>

#include <cassert>
#include <array>

// 圧縮に必要
#if _DEBUG
#pragma comment(lib,"zlibstaticd.lib")
#else
#pragma comment(lib,"zlibstatic.lib")
#endif

constexpr int BUFFER_SIZE = 1000;

//! @brief 入出力バッファを格納するデータ型。
struct buffer_t {
  size_t size;                           //!< 有効なデータが入っているサイズ
  std::array<Byte, BUFFER_SIZE> buffer; //! @brief 確保したバッファ

  buffer_t(
    const size_t _size,
    const std::array<Byte, BUFFER_SIZE>& data
  ) :
    size(_size),
    buffer(data) {}
};

//! @brief ファイルからデータを読み込む
//! @param [in] filename ファイル名
//! @param [out] ファイルを読み込んだ、固定長のバッファの一覧
//! @return ファイル一個分のデータ
void read_buffer(const char* filename, std::vector< buffer_t >& datalist) {
  // データの準備
  std::array<unsigned char, BUFFER_SIZE> buffer;
  FILE* fp = fopen(filename, "rb");

  do {
    size_t readsize = fread(buffer.data(), 1, buffer.size(), fp);

    // データと読み込んだサイズを保存
    datalist.emplace_back( readsize, buffer );


  } while (feof(fp) == 0);

  fclose(fp);

}

bool my_compress(
  std::vector<buffer_t>& zippedBuffer,
  const std::vector< buffer_t >& data_list) {

  // 構造体の初期化
  z_stream strm;
  strm.zalloc = Z_NULL;
  strm.zfree = Z_NULL;
  strm.opaque = Z_NULL;


  //初期化
  int ret = deflateInit(&strm, Z_DEFAULT_COMPRESSION);

  if (ret != Z_OK) {
    return false;
  }

  int flush = Z_NO_FLUSH;

  for (size_t i = 0; i < data_list.size(); i++) {

    // これから圧縮するデータ。
    const buffer_t& inbuffer = data_list[i];

    // バッファが小さい場合、読み込みを分割せざるを得ない。
    // zlibではデータを複数回に分けて入力し、
    // すべて出そろった段階で処理を行えるような構造になっている。
    // ここにfreadを書くのもわかりにくいので今回は data_listとしてデータ一覧を用意する


    strm.next_in = (Bytef*)inbuffer.buffer.data(); //圧縮前データ
    strm.avail_in = (uInt)inbuffer.size;        // 圧縮前データのバイト数

    // 全てのデータが処理されたら、一番最後にZ_FINISH設定
    // つまり最後の一回だけ特別な処理をする。
    if (i == data_list.size() - 1) {
      flush = Z_FINISH;
    }
    else {
      flush = Z_NO_FLUSH;
    }

    // 圧縮関数に渡して処理されたデータを受け取るためのバッファ
    std::array<Byte, BUFFER_SIZE> tmpbuffer;

    do {
      strm.avail_out = BUFFER_SIZE;// 出力先バッファのサイズ
      strm.next_out = tmpbuffer.data(); // 出力先バッファ

      ret = deflate(&strm, flush);  /* no bad return value */
      assert(ret != Z_STREAM_ERROR);  /* state not clobbered */

      // バッファが全部使われた場合、avail_outは0となる
      // 従って BUFFER_SIZE - 0 で have==BUFFER_SIZE となる。

      //圧縮したデータサイズを取得
      unsigned have = BUFFER_SIZE - strm.avail_out;

      // 結果の出力先に積んでいく
      zippedBuffer.emplace_back(have,tmpbuffer);

    } while (strm.avail_out == 0);

  }

  // 終了時呼び出す。
  deflateEnd(&strm);

  return true;
}