/*
 * Reading the ST-NICCC megademo data stored in
 * the SPI flash and streaming it to polygons,
 * rendered as ANSI character sequences through
 * the UART.
 * 
 * The polygon stream is a 640K file, that needs
 * to be stored in the SPI flash, using:
 * ICEStick: iceprog -o 1M EXAMPLES/DATA/scene1.dat
 * ULX3S:    cp EXAMPLES/DATA/scene1.dat scene1.img
 *           ujprog -j flash -f 1048576 scene1.img
 *   (using latest version of ujprog compiled from https://github.com/kost/fujprog)
 *
 * More details and links in EXAMPLES/DATA/notes.txt
 */

#include <stdint.h>
#include <stdio.h>

#ifdef __linux__
#include <stdlib.h>
#include <unistd.h>
#else
#include "io.h"
#endif

// when compiling for SPI flash, uncomment to fit some routines in fast BRAM
// (but it does not change much, the bottleneck is ANSI RGB encoding and uart.
//#define RV32_FASTCODE __attribute((section(".fastcode")))
#define RV32_FASTCODE

// when compiling for SPI flash, uncomment to enable wireframe mode (but it is ugly
// and it will not fit in BRAM !)
// #define WITH_WIREFRAME 

#ifdef WITH_WIREFRAME
int wireframe = 0;
#endif

#define MIN(x,y) ((x) < (y) ? (x) : (y))
#define MAX(x,y) ((x) > (y) ? (x) : (y))


/**********************************************************************************/
/* Graphics routines                                                              */
/**********************************************************************************/


// Map coordinates from file to screen

static inline uint8_t map_x(uint8_t x) {
    return x >> 1;
}

static inline uint8_t map_y(uint8_t y) {
    return y >> 2;
}

void GL_clear() {
    printf("\033[48;5;16m"   // set background color black
           "\033[2J");       // clear screen
}

/* 
 * Set background color using 6x6x6 colorcube codes
 * see https://stackoverflow.com/questions/4842424/list-of-ansi-color-escape-sequences
 */
static inline void GL_setcolor(int color) {
   static int last_color = -1;
   if(color != last_color) {
      printf("\033[48;5;%dm",color);
   }
   last_color = color;
}

static inline void GL_setpixel(int x, int y) {
   printf("\033[%d;%dH ",y,x); // Goto_XY(x1,y) and print space
}

#ifdef WITH_WIREFRAME
void GL_line(int x1, int y1, int x2, int y2) RV32_FASTCODE;
void GL_line(int x1, int y1, int x2, int y2) {
    int x,y,dx,dy,sy,tmp;

    // Swap both extremities to ensure x increases
    if(x2 < x1) {
       tmp = x2;
       x2 = x1;
       x1 = tmp;
       tmp = y2;
       y2 = y1;
       y1 = tmp;
    }
   
    // Bresenham line drawing.
    dy = y2 - y1;
    sy = 1;
    if(dy < 0) {
	sy = -1;
	dy = -dy;
    }

    dx = x2 - x1;
   
    x = x1;
    y = y1;
    
    if(dy > dx) {
	int ex = (dx << 1) - dy;
	for(int u=0; u<dy; u++) {
	    GL_setpixel(x,y);
	    y += sy;
	    if(ex >= 0)  {
		x++;
		ex -= dy << 1;
		GL_setpixel(x,y);
	    }
	    while(ex >= 0)  {
		x++;
		ex -= dy << 1;
	        putchar(' ');
	    }
	    ex += dx << 1;
	}
    } else {
	int ey = (dy << 1) - dx;
	for(int u=0; u<dx; u++) {
	    GL_setpixel(x,y);
	    x++;
	    while(ey >= 0) {
		y += sy;
		ey -= dx << 1;
		GL_setpixel(x,y);
	    }
	    ey += dy << 1;
	}
    }
}
#endif

void GL_fillpoly(int nb_pts, int* points) RV32_FASTCODE;
void GL_fillpoly(int nb_pts, int* points) {
    static int last_color = -1;
   
    char x_left[128];
    char x_right[128];

    /* Determine clockwise, miny, maxy */
    int clockwise = 0;
    int miny =  256;
    int maxy = -256;
    
    for(int i1=0; i1<nb_pts; ++i1) {
	int i2=(i1==nb_pts-1) ? 0 : i1+1;
	int i3=(i2==nb_pts-1) ? 0 : i2+1;
	int x1 = points[2*i1];
	int y1 = points[2*i1+1];
	int dx1 = points[2*i2]   - x1;
	int dy1 = points[2*i2+1] - y1;
	int dx2 = points[2*i3]   - x1;
	int dy2 = points[2*i3+1] - y1;
	clockwise += dx1 * dy2 - dx2 * dy1;
	miny = MIN(miny,y1);
	maxy = MAX(maxy,y1);
    }

    /* Determine x_left and x_right for each scaline */
    for(int i1=0; i1<nb_pts; ++i1) {
	int i2=(i1==nb_pts-1) ? 0 : i1+1;

	int x1 = points[2*i1];
	int y1 = points[2*i1+1];
	int x2 = points[2*i2];
	int y2 = points[2*i2+1];

#ifdef WITH_WIREFRAME
        if(wireframe) {
	   if((clockwise > 0) ^ (y2 > y1)) {
	      GL_line(x1,y1,x2,y2);
	   }
	    continue;
	}
#endif
       
	char* x_buffer = ((clockwise > 0) ^ (y2 > y1)) ? x_left : x_right;
	int dx = x2 - x1;
	int sx = 1;
	int dy = y2 - y1;
	int sy = 1;
	int x = x1;
	int y = y1;
	int ex;
	
	if(dx < 0) {
	    sx = -1;
	    dx = -dx;
	}
	
	if(dy < 0) {
	    sy = -1;
	    dy = -dy;
	}

	if(y1 == y2) {
	   x_left[y1]  = MIN(x1,x2);
	   x_right[y1] = MAX(x1,x2);
	   continue;
	}

	ex = (dx << 1) - dy;

	for(int u=0; u <= dy; ++u) {
    	    x_buffer[y] = x; 
	    y += sy;
	    while(ex >= 0) {
		x += sx;
		ex -= dy << 1;
	    }
	    ex += dx << 1;
	}
    }

#ifdef WITH_WIREFRAME    
    if(!wireframe) 
#endif    
    {
	for(int y = miny; y <= maxy; ++y) {
	    int x1 = x_left[y];
	    int x2 = x_right[y];
	    printf("\033[%d;%dH",y,x1); // Goto_XY(x1,y)
	    for(int x=x1; x<x2; ++x) {
		putchar(' ');
	    }
	}
    }
}


/**********************************************************************************/

/*
 * Starting address of data stream stored in the 
 * SPI.
 * I put the data stream starting from 1M offset,
 * just to make sure it does not collide with
 * FPGA wiring configuration ! (but FPGA configuration
 * only takes a few tenth of kilobytes I think).
 * Using the IO interface, it is using the physical address
 *  (starting at 1M). Using the mapped memory interface,
 *  SPI_FLASH_BASE is mapped to 1M.
 */
uint32_t spi_addr = 0;

/*
 * Word address and cached word used in mapped mode
 */
uint32_t spi_word_addr = 0;
union {
  uint32_t spi_word;
  uint8_t spi_bytes[4];
} spi_u;

#define ADDR_OFFSET 1024*1024

/*
 * Restarts reading from the beginning of the stream.
 */
void spi_reset() {
  spi_addr = ADDR_OFFSET;
  spi_word_addr = (uint32_t)(-1);
}


#ifdef __linux__

FILE* f = NULL;

/**
 * Reads one byte of data from the file (emulates read_spi_byte() when running on desktop)
 */
uint8_t next_spi_byte() {
   uint8_t result;
   if(f == NULL) {
      f = fopen("../../../FIRMWARE/EXAMPLES/DATA/scene1.dat","rb");
      if(f == NULL) {
	 printf("Could not open data file\n");
	 exit(-1);
      }
   }
   if(spi_word_addr != spi_addr >> 2) {
      spi_word_addr = spi_addr >> 2;
      fseek(f, spi_word_addr*4-ADDR_OFFSET, SEEK_SET);
      fread(&(spi_u.spi_word), 4, 1, f);
   }
   result = spi_u.spi_bytes[spi_addr&3];
   ++spi_addr;
   return (uint8_t)(result);
}

#else


# define SPI_FLASH_BASE ((uint32_t*)(1 << 23))

/**
 * Reads one byte from the SPI flash, using the mapped SPI flash interface.
 */
static inline uint8_t next_spi_byte() {
   uint8_t result;
   if(spi_word_addr != spi_addr >> 2) {
      spi_word_addr = spi_addr >> 2;
      spi_u.spi_word = SPI_FLASH_BASE[spi_word_addr];
   }
   result = spi_u.spi_bytes[spi_addr&3];
   ++spi_addr;
   return (uint8_t)(result);
}

#endif

static inline uint16_t next_spi_word() {
   /* In the ST-NICCC file,  
    * words are stored in big endian format.
    * (see DATA/scene_description.txt).
    */
   uint16_t hi = (uint16_t)next_spi_byte();    
   uint16_t lo = (uint16_t)next_spi_byte();
   return (hi << 8) | lo;
}

/* 
 * The colormap, encoded in such a way that it
 * can be directly sent as ANSI color codes.
 */
int cmap[16];

/*
 * Current frame's vertices coordinates (if frame is indexed),
 *  mapped to OLED display dimensions (divide by 2 from file).
 */
uint8_t  X[255];
uint8_t  Y[255];

/*
 * Current polygon vertices, as expected
 * by GL_fillpoly():
 * xi = poly[2*i], yi = poly[2*i+1]
 */
int      poly[30];

/*
 * Masks for frame flags.
 */
#define CLEAR_BIT   1
#define PALETTE_BIT 2
#define INDEXED_BIT 4

/*
 * Reads a frame's polygonal description from
 * SPI flash and rasterizes the polygons using
 * FemtoGL.
 * returns 0 if last frame.
 *   See DATA/scene_description.txt for the 
 * ST-NICCC file format.
 *   See DATA/test_ST_NICCC.c for an example
 * program.
 */
int read_frame() RV32_FASTCODE;
int read_frame() {
    uint8_t frame_flags = next_spi_byte();

    // Update palette data.
    if(frame_flags & PALETTE_BIT) {
	uint16_t colors = next_spi_word();
	for(int b=15; b>=0; --b) {
	    if(colors & (1 << b)) {
		int rgb = next_spi_word();
	       
		// Get the three 3-bits per component R,G,B
	        int b3 = (rgb & 0x007);
		int g3 = (rgb & 0x070) >> 4;
		int r3 = (rgb & 0x700) >> 8;

		// Re-encode them as ANSI 8-bits color
		b3 = b3 * 6 / 8;
		g3 = g3 * 6 / 8;
		r3 = r3 * 6 / 8;		
		cmap[15-b] = 16 + b3 + 6*(g3 + 6*r3);
	    }
	}
    }

    if(frame_flags & CLEAR_BIT) {
       // GL_clear(); 
    }

    // Update vertices
    if(frame_flags & INDEXED_BIT) {
	uint8_t nb_vertices = next_spi_byte();
	for(int v=0; v<nb_vertices; ++v) {
	    X[v] = map_x(next_spi_byte());
	    Y[v] = map_y(next_spi_byte());
	}
    }

    // Draw frame's polygons
    for(;;) {
	uint8_t poly_desc = next_spi_byte();

	// Special polygon codes (end of frame,
	// seek next block, end of stream)
	
	if(poly_desc == 0xff) {
	    break; // end of frame
	}
	if(poly_desc == 0xfe) {
	    // Go to next 64kb block
	    spi_addr -= ADDR_OFFSET;
	    spi_addr &= ~65535;
	    spi_addr +=  65536;
	    spi_addr += ADDR_OFFSET;
	    return 1; 
	}
	if(poly_desc == 0xfd) {
	    return 0; // end of stream
	}
	
	uint8_t nvrtx = poly_desc & 15;
	uint8_t poly_col = poly_desc >> 4;
	for(int i=0; i<nvrtx; ++i) {
	    if(frame_flags & INDEXED_BIT) {
		uint8_t index = next_spi_byte();
		poly[2*i]   = X[index];
		poly[2*i+1] = Y[index];
	    } else {
		poly[2*i]   = map_x(next_spi_byte());
		poly[2*i+1] = map_y(next_spi_byte());
	    }
	}
        GL_setcolor(cmap[poly_col]);
	GL_fillpoly(nvrtx,poly);
    }
    return 1; 
}


int main() {
    // printf("\x1B[?25l"); // hide cursor

#ifndef __linux__   
    IO_OUT(IO_LEDS,15);
#endif
    printf("starting\n");

#ifdef WITH_WIREFRAME    
     wireframe = 0;
#endif     
    int frame = 0;
    GL_clear();
    for(;;) {
        spi_reset();
        frame = 0;
	while(read_frame()) {
#ifdef WITH_WIREFRAME    
	   if(wireframe) {
	      GL_clear();
	   }
#endif
#ifdef __linux__       
        usleep(20000);
#else
        IO_OUT(IO_LEDS,frame);
#endif	   
        ++frame;
	}
#ifdef WITH_WIREFRAME    
        wireframe = !wireframe;
#endif        
    }
}