/// LSU EE 4702-1 (Fall 2022), GPU Programming
//
 /// LIVE: Code from class on 28 August 2026
//
 /// 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.

  if ( x1 < x0 ) { swap(x0,x1); swap(y0,y1); }

  int dy = (y1-y0);
  int dx = ( x1 - x0 );

  assert( x0 <= x1 );

  if ( abs(dy) <= dx )
    {
      float dydx = float(dy) / dx;

      for ( int x = x0;  x < x1;  x++ )
        {
          int y = y0 +  ( x - x0 ) * dydx  ;
          //  int y_stop = min( y1, ( y + dydx ) );
          fb[ y * wid + x ] = co;
        }
    } else {
      float dxdy = float(dx) / dy;

      for ( int y = min(y0,y1);  y < max(y1,y0);  y++ )
        {
          int x = x0 +  ( y - y0 ) * dxdy;
          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.
  //

  /// SOLUTION BELOW IS COMPLETE.
  //
  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_y1; y<sq_y0; y++ )
    {
      fb[ y * win_width + sq_x0 ] = 0xff00ff;
      fb[ y * win_width + sq_x1 ] = 0xff00;
    }

  /// 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 [[maybe_unused]] = 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 from_width = sq_slen / zoom;
  for ( int i=0; i<from_width; i++ )
    for ( int j=0; j<from_width; j++ )
      {
        int x_from = mouse_x - from_width / 2 + i;
        int y_from = mouse_y - from_width / 2 + j;
        uint32_t px = fb[ x_from + y_from * win_width ];
        for ( int ii=0; ii<zoom; ii++ )
          for ( int jj=0; jj<zoom; jj++ )
            {
              int x_to = sq_x0 + i * zoom + ii;
              int y_to = sq_y1 + j * zoom + jj;

              // Quick-and-dirty way to avoid overwriting the square
              // framing the magnified region.
              //
              if ( x_to <= sq_x0 || x_to >= sq_x1 || y_to <= sq_y1
                   || y_to >= sq_y0 ) continue;
              //
              // If someone submitted this as a solution I might point
              // out that it would be better to set x_to and y_to so
              // they never overwrite the square, than to waste time
              // on every iteration on the comparison.

              fb[ x_to + y_to * win_width ] = px;
            }
      }


  /// 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;
}