#include <iostream>

#include <Windows.h>
#include "prepare_shader.hpp"
#include <gl/GL.h>
#include <gl/GLU.h>
#include <gl/freeglut.h>
#include <cassert>

#pragma comment(lib,"glew32.lib")

//ウィンドウの幅と高さ
int width, height;

GLuint buf_points1;
GLuint buf_points2;


GLuint programIDR;
GLuint programIDG;

GLuint uniformBufferID;
struct CMatrices {
  GLfloat mproj[16];
  GLfloat mmodel[16];
} _matrices;

void GetZRotate(GLfloat* m, GLfloat rad);

// シェーダとデータの設定
void init() {

  std::vector<GLfloat> points;

  GLfloat s=0.0;
  GLfloat v = 0.8;

  push_3(points, 0 + s, 0,   0);//座標　XYZ
  push_3(points, 0 + s, v,   0);
  push_3(points, v + s, 0,   0);
  prepare_buffer(&buf_points1, points.data(), points.size() * sizeof(GLfloat), GL_STATIC_DRAW);

  s = 0.1;
  points.clear();
  push_3(points, 0 + s, 0, 0);//座標　XYZ
  push_3(points, 0 + s, v, 0);
  push_3(points, v + s, 0, 0);
  prepare_buffer(&buf_points2, points.data(), points.size() * sizeof(GLfloat), GL_STATIC_DRAW);


  GLuint vtxShader;
  GLuint flagShaderR;
  GLuint flagShaderG;
  const char* vtxfile = "default.vert";
  const char* fragfileR = "default-R.frag";
  const char* fragfileG = "default-G.frag";

  std::string verr;
  std::string ferr;
  prepare_shader_byfile(&vtxShader, GL_VERTEX_SHADER, vtxfile, &verr);
  prepare_shader_byfile(&flagShaderR, GL_FRAGMENT_SHADER, fragfileR, &ferr);
  prepare_shader_byfile(&flagShaderG, GL_FRAGMENT_SHADER, fragfileG, &ferr);

  std::cout << verr << std::endl;
  std::cout << ferr << std::endl;

  std::string linkerr;
  link_program(&programIDR, { vtxShader ,flagShaderR }, nullptr, &linkerr);
  link_program(&programIDG, { vtxShader ,flagShaderG }, nullptr, &linkerr);

  loadidentity44(_matrices.mproj);
  loadidentity44(_matrices.mmodel);

  // UBOを作成
  glGenBuffers(1, &uniformBufferID);
  glBindBuffer(GL_UNIFORM_BUFFER, uniformBufferID);
  glBufferData(GL_UNIFORM_BUFFER, sizeof(CMatrices), &_matrices, GL_DYNAMIC_DRAW); //UBOの内容を書き込み
  glBindBuffer(GL_UNIFORM_BUFFER, 0);

}

//描画関数
void disp(void) {

  glViewport(0, 0, width, height);

  glClearColor(0.2, 0.2, 0.2, 1);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  static int angle = 0;
  GetZRotate(_matrices.mmodel, angle++ * (3.14159 / 180.0));

  glBindBuffer(GL_UNIFORM_BUFFER, uniformBufferID);
  glBufferData(GL_UNIFORM_BUFFER, sizeof(CMatrices), &_matrices, GL_DYNAMIC_DRAW);
  glBindBuffer(GL_UNIFORM_BUFFER, 0);

  GLuint block_index_r = glGetUniformBlockIndex(programIDR, "Matrices");
  GLuint block_index_g = glGetUniformBlockIndex(programIDG, "Matrices");


  GLuint index = 0; //この数字はGL_MAX_UNIFORM_BUFFER_BINDINGS未満ならなんでもいい
  assert(index < GL_MAX_UNIFORM_BUFFER_BINDINGS);

  glUseProgram(programIDR);//使用するプログラムを変更
  glBindBufferBase(GL_UNIFORM_BUFFER, index, uniformBufferID);
  glUniformBlockBinding(programIDR, block_index_r, index);
  {
    auto bindbufP = EnableAndBindFArrayBuffer(0, buf_points1, 3, GL_FLOAT);//prepare_shader.hpp
    glDrawArrays(GL_TRIANGLES, 0, 3);
  }

  glUseProgram(programIDG);//使用するプログラムを変更
  glBindBufferBase(GL_UNIFORM_BUFFER, index, uniformBufferID);
  glUniformBlockBinding(programIDG, block_index_g, index);
  {
    auto bindbufP = EnableAndBindFArrayBuffer(0, buf_points2, 3, GL_FLOAT);//prepare_shader.hpp
    glDrawArrays(GL_TRIANGLES, 0, 3);
  }

  glUseProgram(0);

  glFlush();
}

//ウィンドウサイズの変化時に呼び出される
void reshape(int w, int h) {
  width = w; height = h;

  disp();
}

void timer(int value) {
  glutPostRedisplay();
  glutTimerFunc(50, timer, 0);
}

//エントリポイント
int main(int argc, char** argv)
{
  glutInit(&argc, argv);
  glutInitWindowPosition(100, 50);
  glutInitWindowSize(500, 500);
  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);

  glutCreateWindow("sample");
  glutDisplayFunc(disp);
  glutReshapeFunc(reshape);

  glutTimerFunc(10, timer, 0);

  glewInit();

  init();

  glutMainLoop();

  return 0;
}


//! @brief X軸回転行列を作成する
//! @param [out] m 結果を格納する要素数16の配列
//! @param [in] rad 回転角（ラジアン）
//! @return なし
void GetZRotate(GLfloat* m, GLfloat rad) {
  m[0] = cos(rad);
  m[1] = sin(rad);
  m[2] = 0;
  m[3] = 0;

  m[4] = -sin(rad);
  m[5] = cos(rad);
  m[6] = 0;
  m[7] = 0;

  m[8] = 0;
  m[9] = 0;
  m[10] = 1;
  m[11] = 0;

  m[12] = 0;
  m[13] = 0;
  m[14] = 0;
  m[15] = 1;

}

#version 460 core

layout (location = 0) in vec3 coord;

out vec4 vColor;

//Uniformブロック std140はメモリ配置方法
layout (std140) uniform Matrices {
  mat4 ProjectionMatrix;
  mat4 ModelViewMatrix;
};

void main()
{
  gl_Position = ProjectionMatrix * ModelViewMatrix * vec4(coord, 1.0);
}

#version 460 core

in vec4 vColor;

out vec4 FragColor;

void main()
{
  FragColor[0] = 0.0;
  FragColor[1] = 1.0;
  FragColor[2] = 0.0;
  FragColor[3] = 1.0;
} 

#version 460 core

in vec4 vColor;

out vec4 FragColor;

void main()
{
  FragColor[0] = 1.0;
  FragColor[1] = 0.0;
  FragColor[2] = 0.0;
  FragColor[3] = 1.0;
} 

#pragma once


#include "gwindbg.hpp"
#include <mutex>
 

//! @brief DIBを扱う
struct DIBData {
  BITMAPINFO m_bmpInfo;   //!< CreateDIBSectionに渡す構造体
  LPDWORD m_lpPixel;      //!< 画素へのポインタ
  HBITMAP m_hBitmap;      //!< 作成したMDCのビットマップハンドル
  HDC m_hMemDC;           //!< 作成したMDCのハンドル

  int m_imagesizemax;     //!< 合計画素数(width*height)
  int m_width;            //!< 画像の幅(ピクセル,自然数)
  int m_height;           //!< 画像の高さ(ピクセル,自然数)

  int m_bitcount;
  DIBData() {
    DeleteDC(m_hMemDC);
    DeleteObject(m_hBitmap);
  }
  ~DIBData() {
    m_hBitmap = nullptr;
    m_hMemDC = nullptr;
    m_lpPixel = nullptr;
    m_width = 0;
    m_height = 0;
    m_bitcount = 0;
  }
  void create(int width, int height, int bitcount) {
    if (width != m_width || height != m_height) {
      if (m_hBitmap) {
        DeleteObject(m_hBitmap);
        m_hBitmap = nullptr;
      }
      if (m_hMemDC) {
        DeleteDC(m_hMemDC);
        m_hMemDC = nullptr;
      }
      //DIBの情報を設定する
      m_bmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
      m_bmpInfo.bmiHeader.biWidth = width;
      m_bmpInfo.bmiHeader.biHeight = -height; //-を指定しないと上下逆になる
      m_bmpInfo.bmiHeader.biPlanes = 1;
      m_bmpInfo.bmiHeader.biBitCount = bitcount;
      m_bmpInfo.bmiHeader.biCompression = BI_RGB;

      HDC hdc = GetDC(nullptr);
      m_hBitmap = CreateDIBSection(hdc, &m_bmpInfo, DIB_RGB_COLORS, (void**)&m_lpPixel, nullptr, 0);
      m_hMemDC = CreateCompatibleDC(hdc);
      SelectObject(m_hMemDC, m_hBitmap);
      ReleaseDC(nullptr, hdc);

      m_width = width;
      m_height = height;
      m_bitcount = bitcount;
    }
  }
};

//! @brief 画素の値を透明度でブレンドする
//! @param [in] back 背景画像の色のr,g,bのいずれかの値
//! @param [in] data 塗りたい色のr,g,bのいずれかの値
//! @param [in] dataalpha 塗りたい色の透明度
//データの色の割合
unsigned char pixel_alpha_blend(
  unsigned char back,
  unsigned char data,
  unsigned char dataalpha
) {
  float weight_data = dataalpha / 255.0f;//データの色の割合
  float weight_bkc = 1.0 - weight_data;//背景色の割合
  int ret = data * weight_data + back * weight_bkc; if (data > 255)data = 255;
  return ret;
}

//! @brief RGB,RGBAの画像を表示するウィンドウのクラス。
class CImageViewWindow : public GraphicDebugWindow {

  DIBData dibdata_background; //!< 背景画像
  DIBData dibdata_result;     //!< 表示画像

  int m_magnification;    //!< 表示倍率
  unsigned char* m_img_p; //!< 画像データへのポインタ
  int m_img_width;        //!< 画像データの幅
  int m_img_height;       //!< 画像データの高さ
  int m_pixelbyte;        //!< 画像データのピクセルのバイト数。RGBなら3,RGBAなら4

  std::mutex m_mainmuitex;

public:
  CImageViewWindow() {}

  //! @brief 背景（透明を表現するチェスボードのような画像）を作成する
  void create_background_image() {

    const int blocksize = 10;

    if (get_hwnd() == nullptr)
      return;
    RECT rect;
    GetClientRect(get_hwnd(), &rect);

    //現在の背景画像が、画面サイズより小さかったら作り直す。
    //画面サイズより大きな背景画像が既に作成済みならそのまま使用する
    if (dibdata_background.m_width < rect.right || dibdata_background.m_height < rect.bottom) {

      dibdata_background.create(rect.right, rect.bottom, 32);
      int bkwidth = dibdata_background.m_width;
      int bkheight = dibdata_background.m_height;

      //背景画像の作成(チェスボードのような画像)
      for (int x = 0; x < bkwidth; x++) {
        for (int y = 0; y < bkheight; y++) {

          int pos = y * bkwidth + x;

          bool xb = (bool)((x / blocksize) % 2);
          bool yb = (bool)((y / blocksize) % 2);

          if (xb == yb) {
            dibdata_background.m_lpPixel[pos] = RGB(100, 100, 100);
          }
          else {
            dibdata_background.m_lpPixel[pos] = RGB(200, 200, 200);
          }

        }
      }
    }

  }