#include <iostream>
#include <chrono>
#include <fstream>
#include <sstream>
#include <SFML/Graphics.hpp>

#ifdef linux
#include <CL/cl.h>
#include <CL/opencl.h>

#elif defined _WIN32
#include <windows.h>
#include <CL/cl_gl.h>
#include <CL/cl.h>
#include <CL/opencl.h>
#include <GL/GL.h>

#include <windows.h>

#elif defined TARGET_OS_MAC
#include <OpenGL/gl.h>
# include <OpenGL/OpenGL.h>
# include <OpenCL/opencl.h>
#include <OpenCL/cl_gl_ext.h>
#include <OpenCL/cl_ext.h>

#endif
#include "Map.h"
#include "Curses.h"
#include "util.hpp"
#include "RayCaster.h"
#include "CL_Wrapper.h"
#include "Vector4.hpp"
#include <Camera.h>

const int WINDOW_X = 1920;
const int WINDOW_Y = 1080;
const int WORK_SIZE = WINDOW_X * WINDOW_Y;

const int MAP_X = 512;
const int MAP_Y = 512;
const int MAP_Z = 512;

float elap_time(){
	static std::chrono::time_point<std::chrono::system_clock> start;
	static bool started = false;

	if (!started){
		start = std::chrono::system_clock::now();
		started = true;
	}

	std::chrono::time_point<std::chrono::system_clock> now = std::chrono::system_clock::now();
	std::chrono::duration<double> elapsed_time = now - start;
	return elapsed_time.count();
}

sf::Sprite window_sprite;
sf::Texture window_texture;

// Y: -1.57 is straight up
// Y: 1.57 is straight down


int main() {

	CL_Wrapper c;

	//Map m(sf::Vector3i (50, 50, 50));
	//m.generate_octree();
	return 1;

	//sf::RenderWindow window(sf::VideoMode(WINDOW_X, WINDOW_Y), "SFML");

	//if (c.compile_kernel("../kernels/ray_caster_kernel.cl", true, "min_kern") < 0) {
	//	std::cin.get();
	//	return -1;
	//}
	//
	//std::cout << "map...";
 //   sf::Vector3i map_dim(MAP_X, MAP_Y, MAP_Z);
 //   Map* map = new Map(map_dim);
 //   
	//c.create_buffer("map_buffer", sizeof(char) * map_dim.x * map_dim.y * map_dim.z, map->list);
	//c.create_buffer("dim_buffer", sizeof(int) * 3, &map_dim);

	//sf::Vector2i view_res(WINDOW_X, WINDOW_Y);
	//c.create_buffer("res_buffer", sizeof(int) * 2, &view_res);
 // 	

 //   double y_increment_radians = DegreesToRadians(50.0 / view_res.y);
 //   double x_increment_radians = DegreesToRadians(80.0 / view_res.x);

	//std::cout << "view matrix...";
 // 
	//sf::Vector4f* view_matrix = new sf::Vector4f[WINDOW_X * WINDOW_Y * 4];

 //   for (int y = -view_res.y / 2; y < view_res.y / 2; y++) {
 //       for (int x = -view_res.x / 2; x < view_res.x / 2; x++) {

 //           // The base ray direction to slew from
 //           sf::Vector3f ray(1, 0, 0);

	//		// Y axis, pitch
	//		ray = sf::Vector3f(
	//			ray.z * sin(y_increment_radians * y) + ray.x * cos(y_increment_radians * y),
	//			ray.y,
	//			ray.z * cos(y_increment_radians * y) - ray.x * sin(y_increment_radians * y)
	//		);


	//		// Z axis, yaw
	//		ray = sf::Vector3f(
	//			ray.x * cos(x_increment_radians * x) - ray.y * sin(x_increment_radians * x),
	//			ray.x * sin(x_increment_radians * x) + ray.y * cos(x_increment_radians * x),
	//			ray.z
	//		);
 //           
	//		int index = (x + view_res.x / 2) + view_res.x * (y + view_res.y / 2);
 //           ray = Normalize(ray);

 //           view_matrix[index] = sf::Vector4f(
	//			ray.x,
	//			ray.y,
	//			ray.z,
	//			0
	//		);
 //       }
 //   }

	//c.create_buffer("view_matrix_buffer", sizeof(float) * 4 * view_res.x * view_res.y, view_matrix);

	//Camera camera(
	//	sf::Vector3f(70, 60, 50),
	//	sf::Vector2f(0.0f, 1.00f)
	//);
	//
	//c.create_buffer("cam_dir_buffer", sizeof(float) * 4, (void*)camera.get_direction_pointer(), CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR);
	//c.create_buffer("cam_pos_buffer", sizeof(float) * 4, (void*)camera.get_position_pointer(), CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR);
 //   
	//int light_count = 2;
	//c.create_buffer("light_count_buffer", sizeof(int), &light_count);

	//// {r, g, b, i, x, y, z, x', y', z'}
	//sf::Vector3f v = Normalize(sf::Vector3f(1.0, 0.0, 0.0));
	//sf::Vector3f v2 = Normalize(sf::Vector3f(1.1, 0.4, 0.7));
	//float light[] = { 0.4, 0.8, 0.1, 1, 50, 50, 50, v.x, v.y, v.z,
	//				  0.4, 0.8, 0.1, 1, 50, 50, 50, v2.x, v2.y, v2.z};
	//c.create_buffer("light_buffer", sizeof(float) * 10 * light_count, light, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR);

	//// The drawing canvas
 //   unsigned char* pixel_array = new sf::Uint8[WINDOW_X * WINDOW_Y * 4];

 //   for (int i = 0; i < WINDOW_X * WINDOW_Y * 4; i += 4) {

 //       pixel_array[i] = 255; // R?
 //       pixel_array[i + 1] = 255; // G?
 //       pixel_array[i + 2] = 255; // B?
 //       pixel_array[i + 3] = 100; // A?
 //   }

	//sf::Texture t;
 //   t.create(WINDOW_X, WINDOW_Y);
 //   t.update(pixel_array);

 //   int error;
 //   cl_mem image_buff = clCreateFromGLTexture(
 //           c.getContext(), CL_MEM_WRITE_ONLY, GL_TEXTURE_2D,
 //           0, t.getNativeHandle(), &error);

 //   if (c.assert(error, "clCreateFromGLTexture"))
 //       return -1;

 //   c.store_buffer(image_buff, "image_buffer");

 //   c.set_kernel_arg("min_kern", 0, "map_buffer");
 //   c.set_kernel_arg("min_kern", 1, "dim_buffer");
 //   c.set_kernel_arg("min_kern", 2, "res_buffer");
 //   c.set_kernel_arg("min_kern", 3, "view_matrix_buffer");
 //   c.set_kernel_arg("min_kern", 4, "cam_dir_buffer");
 //   c.set_kernel_arg("min_kern", 5, "cam_pos_buffer");
	//c.set_kernel_arg("min_kern", 6, "light_buffer");
	//c.set_kernel_arg("min_kern", 7, "light_count_buffer");
	//c.set_kernel_arg("min_kern", 8, "image_buffer");

	//sf::Sprite s;
	//s.setTexture(t);
	//s.setPosition(0, 0);

 //   // The step size in milliseconds between calls to Update()
 //   // Lets set it to 16.6 milliseonds (60FPS)
 //   float step_size = 0.0166f;

 //   // Timekeeping values for the loop
 //   double  frame_time = 0.0,
 //           elapsed_time = 0.0,
 //           delta_time = 0.0,
 //           accumulator_time = 0.0,
 //           current_time = 0.0;

 //   fps_counter fps;

	//// ============================= RAYCASTER SETUP ==================================

	//// Setup the sprite and texture
	//window_texture.create(WINDOW_X, WINDOW_Y);
	//window_sprite.setPosition(0, 0);

	//// State values

	//sf::Vector3f cam_vec(0, 0, 0);

	//RayCaster ray_caster(map, map_dim, view_res);

	//sf::Vector2f *dp = camera.get_direction_pointer();
	//debug_text cam_text_x(1, 30, &dp->x, "X: ");
	//debug_text cam_text_y(2, 30, &dp->y, "Y: ");

	//sf::Vector3f *mp = camera.get_movement_pointer();
	//debug_text cam_text_mov_x(4, 30, &mp->x, "X: ");
	//debug_text cam_text_mov_y(5, 30, &mp->y, "Y: ");
	//debug_text cam_text_mov_z(6, 30, &mp->y, "Z: ");
	////debug_text cam_text_z(3, 30, &p->z);

	//debug_text light_x(7, 30, &light[7], "X: ");
	//debug_text light_y(8, 30, &light[8], "Y: ");
	//debug_text light_z(9, 30, &light[9], "Z: ");
	//// ===============================================================================

	//// Mouse capture
	//sf::Vector2i deltas;
	//sf::Vector2i fixed(window.getSize());
	//bool mouse_enabled = true;

	//sf::Vector3f cam_mov_vec;

	//while (window.isOpen()) {

	//	// Poll for events from the user
	//	sf::Event event;
	//	while (window.pollEvent(event)) {

	//		// If the user tries to exit the application via the GUI
	//		if (event.type == sf::Event::Closed)
	//			window.close();
	//		if (event.type == sf::Event::KeyPressed) {
	//			if (event.key.code == sf::Keyboard::Space) {
	//				if (mouse_enabled)
	//					mouse_enabled = false;
	//				else
	//					mouse_enabled = true;
	//			}
	//		}
	//	}

	//	cam_vec.x = 0;
	//	cam_vec.y = 0;
	//	cam_vec.z = 0;

	//	float speed = 1.0f;

	//	if (sf::Keyboard::isKeyPressed(sf::Keyboard::LShift)) {
	//		speed = 0.2f;
	//	}
	//	if (sf::Keyboard::isKeyPressed(sf::Keyboard::Q)) {
	//		camera.add_relative_impulse(Camera::DIRECTION::DOWN, speed);
	//	}
	//	if (sf::Keyboard::isKeyPressed(sf::Keyboard::E)) {
	//		camera.add_relative_impulse(Camera::DIRECTION::UP, speed);
	//	}
	//	if (sf::Keyboard::isKeyPressed(sf::Keyboard::W)) {
	//		camera.add_relative_impulse(Camera::DIRECTION::FORWARD, speed);
	//	}
	//	if (sf::Keyboard::isKeyPressed(sf::Keyboard::S)) {
	//		camera.add_relative_impulse(Camera::DIRECTION::REARWARD, speed);
	//	}
	//	if (sf::Keyboard::isKeyPressed(sf::Keyboard::A)) {
	//		camera.add_relative_impulse(Camera::DIRECTION::LEFT, speed);
	//	}
	//	if (sf::Keyboard::isKeyPressed(sf::Keyboard::D)) {
	//		camera.add_relative_impulse(Camera::DIRECTION::RIGHT, speed);
	//	}
	//	if (sf::Keyboard::isKeyPressed(sf::Keyboard::T)) {
	//		camera.set_position(sf::Vector3f(50, 50, 50));
	//	}

	//	camera.add_static_impulse(cam_vec);

	//	if (mouse_enabled) {
	//		deltas = fixed - sf::Mouse::getPosition();
	//		if (deltas != sf::Vector2i(0, 0) && mouse_enabled == true) {

	//			// Mouse movement
	//			sf::Mouse::setPosition(fixed);
	//			camera.slew_camera(sf::Vector2f(
	//				deltas.y / 300.0f,
	//				deltas.x / 300.0f
	//			));
	//		}
	//	}

 //       // Time keeping
	//	elapsed_time = elap_time();
	//	delta_time = elapsed_time - current_time;
	//	current_time = elapsed_time;
	//	if (delta_time > 0.2f)
	//		delta_time = 0.2f;
	//	accumulator_time += delta_time;
	//	while ((accumulator_time - step_size) >= step_size) {
 //           accumulator_time -= step_size;

 //           // ==== DELTA TIME LOCKED ====
 //       }

	//	float l[] = {
	//		light[9] * sin(delta_time / 1) + light[7] * cos(delta_time / 1),
	//		light[8],
	//		light[9] * cos(delta_time / 1) - light[7] * sin(delta_time / 1)
	//	};

	//	float l2[] = {
	//		l[0] * cos(delta_time) - l[2] * sin(delta_time),
	//		l[0] * sin(delta_time) + l[2] * cos(delta_time),
	//		l[2]
	//	};

	//	light[7] = l[0];
	//	light[8] = l[1];
	//	light[9] = l[2];

 //       // ==== FPS LOCKED ====
	//	camera.update(delta_time);

	//	// Run the raycast
	//	c.run_kernel("min_kern", WORK_SIZE);
	//			
	//	// ==== RENDER ====

	//	window.clear(sf::Color::Black);

 //       window.draw(s);

	//	// Give the frame counter the frame time and draw the average frame time
	//	fps.frame(delta_time);
	//	fps.draw(&window);

	//	cam_text_x.draw(&window);
	//	cam_text_y.draw(&window);

	//	cam_text_mov_x.draw(&window);
	//	cam_text_mov_y.draw(&window);
	//	cam_text_mov_z.draw(&window);

	//	light_x.draw(&window);
	//	light_y.draw(&window);
	//	light_z.draw(&window);
	//		
	//	window.display();

	//}
	return 0;
}