/// LSU EE 4702-1 (Fall 2022), GPU Programming
//
//
 /// Homework 1
 //
 //  This code is based on cpu-only/demo-01-frame-buffer.cc

#include <gp/coord.h>
#include "frame_buffer.h"

void
line_draw( pFrame_Buffer& fb, int x0, int y0, int x1, int y1, uint32_t co)
{
  /// Problem 2
  //
  //  Write the frame buffer so that it shows a line from (x0,y0) to
  //  (x1,y1) of color co.
  //
  //  [ ] There should not be gaps between the pixels.
  //  [ ] Try to avoid writing the same pixel multiple times.

  // Width of window.
  const int wid = fb.width_get();

  // The code below is to help you get started. Please remove it when
  // it is no longer needed.
  //
  fb[ y0 * wid + x0 ] = 0xffffff; // First pixel white.
  fb[ y1 * wid + x1 ] = 0x00ff00; // Last pixel green.


  double the_slope = double( y1 - y0 ) / ( ( x1 - x0 ) ?: 1 );

  if ( fabs(the_slope) > 1 )
    {
      if ( y0 > y1 ) { swap(y0,y1); swap(x0,x1); the_slope = - the_slope; }
      for ( int y = y0; y < y1; y++ )
        {
          int x = x0 + ( y - y0 ) / the_slope;
          fb[ y * wid + x ] = co;
        }
    }
  else
    {
      double the_other_slope = double( x1 - x0 ) / ( ( y1 - y0 ) ?: 1 );
      if ( x0 > x1 ) { swap(y0,y1); swap(x0,x1); the_other_slope = - the_other_slope; }
      for ( int x = x0; x < x1; x++ )
        {
          int y = y0 + ( x - x0 ) / the_other_slope;
          fb[ y * wid + x ] = co;
        }
    }

}


void
render_hw01(pFrame_Buffer& fb)
{
  // Window Size, in Pixels
  //
  const int win_width = fb.width_get();
  const int win_height = fb.height_get();

  //                           RRGGBB
  const uint32_t color_red = 0xff0000;

  /// Compute square coordinates based on window size.
  //
  const int sq_slen = min(win_width,win_height) * .45;
  const int sq_x0 = sq_slen * 0.1,   sq_y0 = win_height - 150;
  const int sq_x1 = sq_x0 + sq_slen, sq_y1 = sq_y0 - sq_slen;
  //
  // One vertex of the square is at (sq_x0,sq_y0) and the opposite
  // vertex is at (sq_x1,sq_y1).


  /// Problem 1
  //
  // Modify the code below so that the square properly uses the
  // coordinates in variables sq_x0, etc.
  //
#define PLAN_A
#ifdef PLAN_A
  for ( int i=0; i<sq_slen; i++ )
    {
      int x = sq_x0 + i, y = sq_y0 - i;
      fb[ sq_y0 * win_width + x ] = color_red;
      fb[ sq_y1 * win_width + x ] = 0xffff;
      fb[ y * win_width + sq_x0 ] = 0xff00ff;
      fb[ y * win_width + sq_x1 ] = 0xff00;
    }
#else
  for ( int x=sq_x0; x<sq_x1; x++ )
    {
      fb[ sq_y0 * win_width + x ] = color_red;
      fb[ sq_y1 * win_width + x ] = 0xffff;
    }
  for ( int y=sq_y0; y<sq_y1; y++ )
    {
      fb[ y * win_width + sq_x0 ] = 0xff00ff;
      fb[ y * win_width + sq_x1 ] = 0xff00;
    }
#endif
  /// Demo Code: Draw Sine Waves  -- No need to modify this.
  //
  int num_waves = 4;
  float plot_ht = sq_slen/float(num_waves);
  for ( float yb = sq_y0 - plot_ht/2,
          freq = 4 * M_PI / float( win_width - 40 - sq_x1 );
        yb > sq_y1; yb -= plot_ht, freq *= 2 )
    for ( int x = sq_x1 + 20;  x < win_width - 20;  x++ )
      {
        int y = yb + sin( x * freq ) * plot_ht * .45;
        fb[ y * win_width + x ] = 0xff00;
      }


  /// Demo Code: Draw Lines Radiating From a Point -- No need to modify.
  //
  //  This code calls the line_draw routine.
  //
  int n_lines = 24;
  float c_r1 = sq_slen/6;  // Inner radius
  float c_r2 = sq_slen/2;  // Outer radius.
  pCoor c_ctr( win_width - c_r2 - 20, c_r2 + 20 ); // Center of lines.
  float delta_theta = 2 * M_PI / n_lines;
  for ( int i=0; i<n_lines; i++ )
    {
      float theta = i * delta_theta;
      pVect dir( cosf(theta), sinf(theta), 0 );
      pCoor p1 = c_ctr + c_r1 * dir;  // Point on inner radius.
      pCoor p2 = c_ctr + c_r2 * dir;  // Point on outer radius.
      line_draw(fb, p1.x, p1.y, p2.x, p2.y, 0xffffff);
    }


  /// Problem 3
  //
  //  Copy the pixels around the mouse pointer into the square,
  //  (sq_x0+1,sq_y0-1) to (sq_x1-1,sq_y1+1), so that the square shows
  //  a zoomed (magnified) version of the area around the mouse
  //  pointer. (Do not overwrite the lines drawn above.) Use variable
  //  zoom as the factor, so that each pixel under the mouse pointer
  //  is copied to 4*4=16 pixels in the square.
  //
  fb.fb_stats_off(); // Turn off "redundancy" statistics.

  // Coordinates of mouse pointer.
  //
  const int mouse_x = fb.mouse_x;
  const int mouse_y = fb.mouse_y;
  const int zoom = 4;

  // The code below is to help you get started. Please remove it when
  // you are done.
  //
  // Copy the pixel under the mouse pointer to the middle of the
  // square.
  //
  fb[ ( sq_y1 + sq_slen/2 ) * win_width + sq_x0 + sq_slen/2 ]
    = fb[ mouse_y * win_width + mouse_x ];

  int ctr_y = ( sq_y0 + sq_y1 ) / 2;

  for ( int i = 1;  i < sq_slen; i++ )
    {
      int sq_y = sq_y1 + i;
      int delta_y = ( sq_y - ctr_y ) / zoom;
      for ( int j = 1;  j < sq_slen; j++ )
        {
          int sq_x = sq_x0 + j;
          int ctr_x = ( sq_x0 + sq_x1 ) /2;
          int delta_x = ( sq_x - ctr_x ) / zoom;
          int z_x = mouse_x + delta_x;
          int z_y = mouse_y + delta_y;
          fb[ sq_y * win_width + sq_x ] = fb[ z_y * win_width + z_x ];
        }
    }

  /// Problem 3 -- Put code to draw the blue square here (below).
  //
  // Put the code to draw the blue square AFTER the code to copy
  // the frame buffer contents.


}


int
main(int argc, char **argv)
{
  pFrame_Buffer demo_frame_buffer(argc,argv);
  demo_frame_buffer.show(render_hw01);
  return 0;
}