#include <Windows.h>
#include <d3d11.h>
#include "dx11/D3DX11.h"
#include <d3dcompiler.h>
#include <iostream>
#include <vector>
#include "mymath/mymath.h"
#include "SFML/Window.hpp"

using namespace mymath;
using namespace std;

#include <sstream>
#include <string>

#define WINMSG(X) MessageBox(GetActiveWindow(), (X), "message m8", MB_OK)

void WINCHECK( HRESULT hr )
{
  if( FAILED( hr ) )
  {
    WINMSG( "WE GOT A PROBLEM, DEBUG M89 :(" );
  }
}

struct interleaved_vertex
{
  float x, y, z, u, v;

  static const D3D11_INPUT_ELEMENT_DESC layout[2];
  static const unsigned num_layout_elements;
};

const D3D11_INPUT_ELEMENT_DESC interleaved_vertex::layout[2] =
{ //Interleaved
  { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
  { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
const unsigned interleaved_vertex::num_layout_elements = ARRAYSIZE( interleaved_vertex::layout );

class dx11_fullscreen_quad_renderer
{
protected:
  ID3D11Buffer* vertex_buffer, *tex_coord_buffer, *index_buffer;
  ID3D11VertexShader* vertex_shader;
  ID3D11PixelShader* pixel_shader;
  ID3D11InputLayout* input_layout;
  ID3D11DepthStencilState* depth_stencil_state;
  ID3D11RasterizerState* rasterizer_state;
  bool is_set_up;

  dx11_fullscreen_quad_renderer()
  {
    is_set_up = false;
    vertex_buffer = tex_coord_buffer = index_buffer = 0;
  }

  void set_up( ID3D11Device* dev )
  {
    //set up only once
    if( is_set_up )
      return;
    else
      is_set_up = true;

    { //create vertex/texcoord/index buffers
      vector<interleaved_vertex> vertices;
      vector<unsigned> indices;

      vertices.reserve( 4 );
      indices.reserve( 2 * 3 );

      indices.push_back( 0 );
      indices.push_back( 1 );
      indices.push_back( 2 );

      indices.push_back( 0 );
      indices.push_back( 2 );
      indices.push_back( 3 );

      //use default coordinate space
      vec3 ll( -1, -1, 0 );
      vec3 lr( 1, -1, 0 );
      vec3 ul( -1, 1, 0 );
      vec3 ur( 1, 1, 0 );

      //ccw
      vertices.push_back( { ll.x, ll.y, ll.z, 0, 0 } );
      vertices.push_back( { lr.x, lr.y, lr.z, 1, 0 } );
      vertices.push_back( { ur.x, ur.y, ur.z, 1, 1 } );
      vertices.push_back( { ul.x, ul.y, ul.z, 0, 1 } );

      D3D11_BUFFER_DESC bd_vertices = { 0 };
      bd_vertices.Usage = D3D11_USAGE_DEFAULT;
      bd_vertices.ByteWidth = sizeof(interleaved_vertex)* vertices.size();
      bd_vertices.BindFlags = D3D11_BIND_VERTEX_BUFFER;
      D3D11_SUBRESOURCE_DATA srd_vertices = { 0 };
      srd_vertices.pSysMem = vertices.data();

      D3D11_BUFFER_DESC bd_indices = { 0 };
      bd_indices.Usage = D3D11_USAGE_DEFAULT;
      bd_indices.ByteWidth = sizeof(float)* indices.size();
      bd_indices.BindFlags = D3D11_BIND_INDEX_BUFFER;
      D3D11_SUBRESOURCE_DATA srd_indices = { 0 };
      srd_indices.pSysMem = indices.data();

      WINCHECK( dev->CreateBuffer( &bd_vertices, &srd_vertices, &vertex_buffer ) );
      WINCHECK( dev->CreateBuffer( &bd_indices, &srd_indices, &index_buffer ) );
    }

    { //create shaders
      string shader_src =
        //"Texture2D tex; \n"
        //"SamplerState sam{ Filter = D3D11_FILTER_MIN_MAG_MIP_POINT; AddressU = D3D11_TEXTURE_ADDRESS_CLAMP; AddressV = D3D11_TEXTURE_ADDRESS_CLAMP; }; \n"
        "struct vs_in{ float3 pos : POSITION; float2 tex_coord : TEXCOORD0; }; \n"
        "struct vs_out{ float4 pos : SV_POSITION; float2 tex_coord : TEXCOORD0; }; \n"
        "struct ps_in{ float2 tex_coord : TEXCOORD0; }; \n"
        "vs_out vs_main( vs_in i ){ vs_out o; o.pos = float4( i.pos, 1 ); o.tex_coord = i.tex_coord; return o; } \n"
        "float4 ps_main( ps_in i ) : SV_TARGET { \n"
        //"  return tex.Sample( sam, i.tex_coord ); \n"
        "  return float4( 1, 1, 1, 1 ); \n"
        "} \n";

      unsigned compile_options = D3DCOMPILE_ENABLE_STRICTNESS
        | D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR; //opengl conventions
#ifdef _DEBUG
      compile_options |= D3DCOMPILE_DEBUG;
#endif
      auto check_shader_compilation = []( ID3DBlob* error )
      {
        if( error )
        {
          WINMSG( (const char*)error->GetBufferPointer() );
        }
      };

      ID3DBlob* vertex_shader_buffer, *pixel_shader_buffer;
      ID3DBlob* error = 0;

      D3DCompile( shader_src.c_str(), shader_src.length(), 0, 0, 0, "vs_main", "vs_5_0", compile_options, 0, &vertex_shader_buffer, &error );
      check_shader_compilation( error );
      D3DCompile( shader_src.c_str(), shader_src.length(), 0, 0, 0, "ps_main", "ps_5_0", compile_options, 0, &pixel_shader_buffer, &error );
      check_shader_compilation( error );

      WINCHECK( dev->CreateVertexShader( vertex_shader_buffer->GetBufferPointer(), vertex_shader_buffer->GetBufferSize(), 0, &vertex_shader ) );
      WINCHECK( dev->CreatePixelShader( pixel_shader_buffer->GetBufferPointer(), pixel_shader_buffer->GetBufferSize(), 0, &pixel_shader ) );

      { //create vertex input layout
        WINCHECK( dev->CreateInputLayout( interleaved_vertex::layout, interleaved_vertex::num_layout_elements, vertex_shader_buffer->GetBufferPointer(), vertex_shader_buffer->GetBufferSize(), &input_layout ) );
      }
    }

    { //create states used for drawing
      D3D11_DEPTH_STENCIL_DESC dsd = { 0 };
      dsd.DepthEnable = false;
      dsd.StencilEnable = false;
      dsd.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
      WINCHECK( dev->CreateDepthStencilState( &dsd, &depth_stencil_state ) );

      D3D11_RASTERIZER_DESC rd =
      {
        D3D11_FILL_SOLID,
        D3D11_CULL_NONE,
        true, //CCW triangles
        0,
        0,
        0,
        false,
        false,
        false,
        false
      };
      WINCHECK( dev->CreateRasterizerState( &rd, &rasterizer_state ) );
    }
  }
public:
  static dx11_fullscreen_quad_renderer& get_instance()
  {
    static dx11_fullscreen_quad_renderer qr;
    return qr;
  }

  void render( ID3D11Device* dev, ID3D11DeviceContext* devcon )
  {
    set_up( dev );

    unsigned stride = sizeof( interleaved_vertex );
    unsigned offset = 0;

    devcon->VSSetShader( vertex_shader, 0, 0 );
    devcon->PSSetShader( pixel_shader, 0, 0 );
    devcon->IASetInputLayout( input_layout );
    devcon->IASetVertexBuffers( 0, 1, &vertex_buffer, &stride, &offset );
    devcon->IASetIndexBuffer( index_buffer, DXGI_FORMAT_R32_UINT, 0 );
    devcon->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
    devcon->OMSetBlendState( 0, 0, 0 );
    devcon->OMSetDepthStencilState( depth_stencil_state, 0 );
    devcon->RSSetState( rasterizer_state );
    devcon->DrawIndexed( 6, 0, 0 );
  }
};

int main( int argc, char** argv )
{
  uvec2 screen( 1280, 720 );
  bool fullscreen = false;
  string title = "DX11 fullscreen quad experiment";

  /*
   * Initialize the DX11 context
   */

  sf::Window window( sf::VideoMode( screen.x, screen.y ), title.c_str() );
  window.setVisible( true );

  //create device and swapchain
  DXGI_SWAP_CHAIN_DESC scd = { 0 };
  scd.BufferCount = 1;                                    // one back buffer
  scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;     // use 32-bit color
  scd.BufferDesc.Width = screen.x;
  scd.BufferDesc.Height = screen.y;
  scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;      // how swap chain is to be used
  scd.OutputWindow = window.getSystemHandle();            // the window to be used
  scd.SampleDesc.Count = 1;                               // how many multisamples
  scd.Windowed = TRUE;

  IDXGISwapChain* swapchain = 0;
  ID3D11Device* d3d11_device = 0;
  ID3D11DeviceContext* devcon = 0;
  UINT device_flags = 0;
#ifdef _DEBUG
  device_flags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
  WINCHECK( D3D11CreateDeviceAndSwapChain( 0, D3D_DRIVER_TYPE_HARDWARE, 0, device_flags, 0, 0, D3D11_SDK_VERSION, &scd, &swapchain, &d3d11_device, 0, &devcon ) );

  ID3D11Texture2D* back_buffer = 0;
  ID3D11RenderTargetView* render_target_view = 0;

  //get back buffer tex
  WINCHECK( swapchain->GetBuffer( 0, __uuidof( ID3D11Texture2D ), (LPVOID*)&back_buffer ) );
  //create render target view of it
  WINCHECK( d3d11_device->CreateRenderTargetView( back_buffer, 0, &render_target_view ) );

  //create depth stencil texture
  ID3D11Texture2D* ds_tex = 0;
  D3D11_TEXTURE2D_DESC ds_desc = { 0 };
  ds_desc.Width = screen.x;
  ds_desc.Height = screen.y;
  ds_desc.MipLevels = 1;
  ds_desc.ArraySize = 1;
  ds_desc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
  ds_desc.SampleDesc.Count = 1;
  ds_desc.SampleDesc.Quality = 0;
  ds_desc.Usage = D3D11_USAGE_DEFAULT;
  ds_desc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
  ds_desc.CPUAccessFlags = 0;
  ds_desc.MiscFlags = 0;
  WINCHECK( d3d11_device->CreateTexture2D( &ds_desc, 0, &ds_tex ) );

  ID3D11DepthStencilView* depth_stencil_view = 0;
  D3D11_DEPTH_STENCIL_VIEW_DESC ds_view_desc = {
    ds_desc.Format,
    D3D11_DSV_DIMENSION_TEXTURE2D,
    0,
    { 0 }
  };
  WINCHECK( d3d11_device->CreateDepthStencilView( ds_tex, &ds_view_desc, &depth_stencil_view ) );

  //we'll render to the back buffer ofc...
  devcon->OMSetRenderTargets( 1, &render_target_view, depth_stencil_view );

  //set viewport
  D3D11_VIEWPORT vp = { 0 };
  vp.Width = screen.x;
  vp.Height = screen.y;
  vp.MinDepth = 0;
  vp.MaxDepth = 1;
  vp.TopLeftX = 0;
  vp.TopLeftY = 0;
  devcon->RSSetViewports( 1, &vp );

  /*
   * Handle events
   */

  bool run = true;

  auto event_handler = [&]( const sf::Event & ev )
  {
    switch( ev.type )
    {
      default:
        break;
    }
  };

  /*
   * Render
   */

  sf::Event ev;

  while( run )
  {
    //-----------------------------
    //do event handling
    //-----------------------------

    while( window.pollEvent( ev ) )
    {
      if( ev.type == sf::Event::Closed ||
          (
          ev.type == sf::Event::KeyPressed &&
          ev.key.code == sf::Keyboard::Escape
          )
          )
      {
        run = false;
      }

      event_handler( ev );
    }

    //-----------------------------
    //render
    //-----------------------------

    vec4 sky( 0.5, 0.5, 0.8, 1 );

    devcon->ClearRenderTargetView( render_target_view, &sky.x );
    devcon->ClearDepthStencilView( depth_stencil_view, D3D11_CLEAR_DEPTH, 1.0f, 0 );

    //render full screen quad
    dx11_fullscreen_quad_renderer::get_instance().render( d3d11_device, devcon );

    //-----------------------------
    //present to screen
    //-----------------------------

    swapchain->Present( 0, 0 );
  }

  return 0;
}