import os

import random, string

# @brief ダミーファイル名を作成
# @details 処理時、一度この名前でファイルを書き換えてから目的の名前に変更する
# @sa https://qiita.com/Scstechr/items/c3b2eb291f7c5b81902a
def create_random_filename():
  
  n = 10
  
  dummy = ''
  while True:
    dummy = ''.join(random.choices(string.ascii_letters + string.digits, k=n))
    
    # 生成した文字列をファイル名とするファイルが存在しなければ処理を終了
    if os.path.exists(dummy) == False:
      break
      
  return dummy

# @brief ファイル名の変更規則一覧作成
# @param [in] _format_ ファイル名の書式
# @param [in] _range_ 元のファイルの番号の範囲
# @param [in] _new_offset_ 新しい番号の先頭番号
# @return [ 現在のファイル名 , ダミーファイル名 , 変更後のファイル名 ] のリスト
def sequence_filename( _format_ , _range_, _new_offset_ ):
	Li=[]
	
	dir = os.path.dirname( _format_ ) + "/"
	
	for i in _range_:
	
	  # 変更したい対象のファイル名を作成
	  fname = _format_ % i
	  
	  retfname = _format_ % (_new_offset_ + i - _range_[0])# 新たなファイル名を作成
	  
	  # ランダムなファイル名作成
	  dummyname = dir + create_random_filename()
	  
	  Li.append([fname,dummyname,retfname])
	  
	return Li

def filename_shift( _format_ , _start_,_stop_, _new_offset_):
  Li = sequence_filename( _format_ , range(_start_,_stop_+1), _new_offset_ )

  # 現在のファイル名　→　ダミーファイル名
  for j in Li:
    os.rename(j[0],j[1])

  # ダミーファイル名　→　目的のファイル名
  for j in Li:
    os.rename(j[1],j[2])

############################################
############################################
############################################

# 50番～のファイル名を300番～に変更
filename_shift( "files/data-%04d.txt" , 50,55,300 )

#include <iostream>

#pragma warning(disable:4996)

#include "../CudaRuntime1/mytest.h"

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

void pnmP3_Write(const char* const fname, const int vmax, const int width, const int height, const unsigned char* const p);

int main()
{
  data_t dat;

  dat.width = 100;
  dat.height = 50;

  unsigned char *c = new unsigned char[dat.width * dat.height * 3];

  for (size_t i = 0; i < dat.width * dat.height; i++) {
    c[i * 3 + 0] = 0;
    c[i * 3 + 1] = 0;
    c[i * 3 + 2] = 255;
  }

  dat.rgbdata = c;




  //GPU側メモリ確保
  void* device = gpu_my_alloc(dat.width, dat.height);

  //GPU側へデータ転送
  host_to_device(&dat, device);

  //処理実行
  func_inverse(dat.width, dat.height, device);

  //CPU側へ結果を返却
  device_to_host(device, &dat);

  //GPU側のメモリ解放
  gpu_my_free(device);


  pnmP3_Write("test.ppm", 255, dat.width, dat.height, dat.rgbdata);

}

/////////////////////////////////////////////
//画像ファイル書き出し/////////////////////////
//! @brief PPM(RGB各1byte,カラー,テキスト)を書き込む
//! @param [in] fname ファイル名
//! @param [in] vmax 全てのRGBの中の最大値
//! @param [in] width 画像の幅
//! @param [in] height 画像の高さ
//! @param [in] p 画像のメモリへのアドレス
//! @details RGBRGBRGB....のメモリを渡すと、RGBテキストでファイル名fnameで書き込む
void pnmP3_Write(const char* const fname, const int vmax, const int width, const int height, const unsigned char* const p) { // PPM ASCII

  FILE* fp = fopen(fname, "wb");
  fprintf(fp, "P3\n%d %d\n%d\n", width, height, vmax);

  size_t k = 0;
  for (size_t i = 0; i < (size_t)height; i++) {
    for (size_t j = 0; j < (size_t)width; j++) {
      fprintf(fp, "%d %d %d ", p[k * 3 + 0], p[k * 3 + 1], p[k * 3 + 2]);
      k++;
    }
    fprintf(fp, "\n");
  }

  fclose(fp);
}

#ifdef __DLL_EXPORT_DO
#define DLL_PORT extern "C" _declspec(dllexport)
#else
#define DLL_PORT extern "C" _declspec(dllimport)
#endif

struct data_t {
  int width;
  int height;
  unsigned char* rgbdata;
};

//GPU側メモリ確保
DLL_PORT void* gpu_my_alloc(int width, int height);

//処理実行
DLL_PORT void func_inverse(int width,int height, void* device);

//GPU側へデータ転送
DLL_PORT void host_to_device(data_t* host, void* device);

//CPU側へ結果を返却
DLL_PORT void device_to_host(void* device, data_t* host);

//GPU側のメモリ解放
DLL_PORT void gpu_my_free(void* gpuptr);

#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>

#include "mytest.h"

struct gpudata {
  int width;
  int height;
  unsigned char* c;
};

__device__
void color_inverse(unsigned char* c, int width, int height) {
  c[0] = 255 - c[0];
  c[1] = 255 - c[1];
  c[2] = 255 - c[2];
}

__global__ void thread_inverse(gpudata data) {
  //このスレッドが担当する画素の位置を二次元座標で求める
  size_t xpos = blockIdx.x * blockDim.x + threadIdx.x;
  size_t ypos = blockIdx.y * blockDim.y + threadIdx.y;

  if (xpos < data.width && ypos < data.height) {
    size_t pos = (ypos * data.width + xpos) * 3;

    unsigned char* c = data.c + pos;
    // この関数はfunction.cuで定義されている
    color_inverse(c, xpos, ypos);
  }

}

void func_inverse(int width, int height, void* device){

  // 16*16 == 256 < 512
  int blockw = 16;
  int blockh = 16;
  dim3 block(blockw, blockh);

  int gridw = width / blockw + 1;
  int gridh = height / blockh + 1;

  dim3 grid(gridw,gridh);



  gpudata gpud;
  gpud.width = width;
  gpud.height = height;
  gpud.c = (unsigned char*)device;
  thread_inverse<<<grid,block>>> (gpud);//GPU側の関数を呼出


}

void host_to_device(data_t* host, void* device) {
  cudaMemcpy(
    device,
    host->rgbdata,
    host->width * host->height * 3,
    cudaMemcpyHostToDevice);//GPU側へ処理したいデータを転送

}

void device_to_host(void* device, data_t* host) {
  cudaMemcpy(
    host->rgbdata,
    device,
    host->width * host->height * 3,
    cudaMemcpyDeviceToHost);//GPU側から実行結果を取得

}


void* gpu_my_alloc(int width, int height) {
  unsigned char* g_gpu;
  cudaMalloc(
    (void**)&g_gpu, 
    width * height * 3);//GPU側メモリ確保

  return g_gpu;
}

void gpu_my_free(void* gpuptr) {
  cudaFree(gpuptr);//GPU側のメモリを解放
}

#include <cstdlib>
#include <iostream>

#include <Windows.h>
#include <gl/GL.h>
#include <GLFW/glfw3.h>

#pragma comment(lib,"opengl32.lib")
#pragma comment(lib,"glfw3.lib")

int main()
{
  ////////////////////////////////////////////////////////////////////////////////
  // GLFW の初期化
  if (glfwInit() == GL_FALSE) {
    // 初期化に失敗したら終了
    return 1;
  }

  ////////////////////////////////////////////////////////////////////////////////
  // ウィンドウを作成
  GLFWwindow* window = glfwCreateWindow(
    400,       //width
    400,       //height
    "window title",//title 
    NULL,      //monitor
    NULL       //share
  );

  ////////////////////////////////////////////////////////////////////////////////
  // ウィンドウを作成できなければ終了
  if (window == nullptr) {
    glfwTerminate();
    return 1;
  }

  glfwMakeContextCurrent(window);
 

  double prev = glfwGetTime();
  const double TIME = 0.1;

  int angle = 0;

  while (glfwWindowShouldClose(window) == GL_FALSE) {


    int width, height;
    glfwGetFramebufferSize(window, &width, &height);

    /////////////////////
    // 描画
    glViewport(0, 0, width, height);
    glOrtho(-1, 1, -1, 1, -1, 1);

    glClearColor(0, 0, 0, 1);
    glClear(GL_COLOR_BUFFER_BIT);

    glLoadIdentity();
    glPushMatrix();

    // glfwGetTime()で現在時刻を秒で取得
    double now = glfwGetTime();

    // 現在時刻 - 前回更新時刻 が TIME秒より開いていたら
    // 定期的に行いたい処理を実行する
    if (now - prev > TIME) {
      prev = now; // 前回更新時刻更新

      // ここで関数呼び出しなど必要な処理を行う
      // 今回はangleを増加するのみ。
      printf("angle %d\n",angle);
      angle += 15;


    }

    glRotatef(angle, 1, 0, 0);


    glBegin(GL_QUADS);
    glColor3d(1, 0, 0);
    glVertex2d(-0.7, -0.7);
    glColor3d(0, 1, 0);
    glVertex2d(-0.7, 0.7);
    glColor3d(0, 0, 1);
    glVertex2d(0.7, 0.7);
    glColor3d(1, 1, 1);
    glVertex2d(0.7, -0.7);
    glEnd();

    glPopMatrix();

    glFlush();


    glfwSwapBuffers(window);

    // イベント取得
    //glfwWaitEvents();
    glfwPollEvents();

  }

  glfwTerminate();

}

#include "helper_math.h"

// helper_math.h でincludeされているので不要
// #include "cuda_runtime.h"

#include "device_launch_parameters.h"

float3 my_calc(float3 a, float3 b) {
  return a + b;
}