/*
 * Copyright (C) 2006 Ondrej Palkovsky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <genarch/fb/font-8x16.h>
#include <genarch/fb/fb.h>
#include <console/chardev.h>
#include <console/console.h>
#include <panic.h>
#include <memstr.h>

#include "helenos.xbm"

SPINLOCK_INITIALIZE(fb_lock);

static __u8 *fbaddress=NULL;
static int xres,yres;
static int position=0;
static int columns=0;
static int rows=0;
static int pixelbytes=0;

#define COL_WIDTH   8
#define ROW_HEIGHT  (FONT_SCANLINES)
#define ROW_PIX     (xres*ROW_HEIGHT*pixelbytes)

#define BGCOLOR   0x000080
#define FGCOLOR   0xffff00
#define LOGOCOLOR 0x2020b0

#define RED(x,bits)    ((x >> (16+8-bits)) & ((1<<bits)-1))
#define GREEN(x,bits)  ((x >> (8+8-bits)) & ((1<<bits)-1))
#define BLUE(x,bits)   ((x >> (8-bits)) & ((1<<bits)-1))

#define POINTPOS(x,y)   ((y*xres+x)*pixelbytes)

/***************************************************************/
/* Pixel specific fuctions */

static void (*putpixel)(int x,int y,int color);
static int (*getpixel)(int x,int y);

/** Put pixel - 24-bit depth, 1 free byte */
static void putpixel_4byte(int x,int y,int color)
{
	int startbyte = POINTPOS(x,y);

	*((__u32 *)(fbaddress+startbyte)) = color;
}

/** Return pixel color */
static int getpixel_4byte(int x,int y)
{
	int startbyte = POINTPOS(x,y);

	return *((__u32 *)(fbaddress+startbyte)) & 0xffffff;
}

/** Draw pixel of given color on screen - 24-bit depth */
static void putpixel_3byte(int x,int y,int color)
{
	int startbyte = POINTPOS(x,y);

	fbaddress[startbyte] = RED(color,8);
	fbaddress[startbyte+1] = GREEN(color,8);
	fbaddress[startbyte+2] = BLUE(color,8);
}

static int getpixel_3byte(int x,int y)
{
	int startbyte = POINTPOS(x,y);
	int result;

	result = fbaddress[startbyte] << 16 \
		| fbaddress[startbyte+1] << 8 \
		| fbaddress[startbyte+2];
	return result;
}

/** Put pixel - 16-bit depth (5:6:6) */
static void putpixel_2byte(int x,int y,int color)
{
	int startbyte = POINTPOS(x,y);
	int compcolor;

	/* 5-bit, 5-bits, 5-bits */
	compcolor = RED(color,5) << 11 \
		| GREEN(color,6) << 5 \
		| BLUE(color,5);
	*((__u16 *)(fbaddress+startbyte)) = compcolor;
}

static int getpixel_2byte(int x,int y)
{
	int startbyte = POINTPOS(x,y);
	int color;
	int red,green,blue;

	color = *((__u16 *)(fbaddress+startbyte));
	red = (color >> 11) & 0x1f;
	green = (color >> 5) & 0x3f;
	blue = color & 0x1f;
	return (red << (16+3)) | (green << (8+2)) | (blue << 3);
}

/** Put pixel - 8-bit depth (3:2:3) */
static void putpixel_1byte(int x,int y,int color)
{
	int compcolor;

	/* 3-bit, 2-bits, 3-bits */
	compcolor = RED(color,3) << 5 \
		| GREEN(color,2) << 3 \
		| BLUE(color,3);
	fbaddress[POINTPOS(x,y)] = compcolor;
}


static int getpixel_1byte(int x,int y)
{
	int color;
	int red,green,blue;

	color = fbaddress[POINTPOS(x,y)];
	red = (color >> 5) & 0x7;
	green = (color >> 3) & 0x3;
	blue = color & 0x7;
	return (red << (16+5)) | (green << (8+6)) | blue << 5;
}

static void clear_line(int y);
/** Scroll screen one row up */
static void scroll_screen(void)
{
	int i;

	memcpy((void *) fbaddress, (void *) &fbaddress[ROW_PIX], (xres*yres*pixelbytes)-ROW_PIX);

	/* Clear last row */
	for (i=0; i < ROW_HEIGHT;i++)
		clear_line((rows-1)*ROW_HEIGHT+i);
	
}


/***************************************************************/
/* Screen specific function */

/** Fill line with color BGCOLOR */
static void clear_line(int y)
{
	int x;
	for (x=0; x<xres;x++)
		(*putpixel)(x,y,BGCOLOR);
}

/** Fill screen with background color */
static void clear_screen(void)
{
	int y;

	for (y=0; y<yres;y++)
		clear_line(y);
}

static void invert_pixel(int x, int y)
{
	(*putpixel)(x,y, ~(*getpixel)(x,y));
}


/** Draw one line of glyph at a given position */
static void draw_glyph_line(int glline, int x, int y)
{
	int i;

	for (i=0; i < 8; i++)
		if (glline & (1 << (7-i))) {
			(*putpixel)(x+i,y,FGCOLOR);
		} else
			(*putpixel)(x+i,y,BGCOLOR);
}

/***************************************************************/
/* Character-console functions */

/** Draw character at given position */
static void draw_glyph(__u8 glyph, int col, int row)
{
	int y;

	for (y=0; y < FONT_SCANLINES; y++)
		draw_glyph_line(fb_font[glyph*FONT_SCANLINES+y],
				col*COL_WIDTH, row*ROW_HEIGHT+y);
}

/** Invert character at given position */
static void invert_char(int col, int row)
{
	int x,y;

	for (x=0; x < COL_WIDTH; x++)
		for (y=0; y < FONT_SCANLINES; y++)
			invert_pixel(col*COL_WIDTH+x,row*ROW_HEIGHT+y);
}

/** Draw character at default position */
static void draw_char(char chr)
{
	draw_glyph(chr, position % columns, position/columns);
}

static void draw_logo(int startx, int starty)
{
	int x,y;
	int byte;
	int rowbytes;

	rowbytes = (helenos_width-1)/8 + 1;

	for (y=0;y < helenos_height;y++)
		for (x=0;x < helenos_width; x++ ) {
			byte = helenos_bits[rowbytes*y + x/8];
			byte >>= x % 8;
			if (byte & 1)
				(*putpixel)(startx+x,starty+y,LOGOCOLOR);
		}
}

/***************************************************************/
/* Stdout specific functions */

static void invert_cursor(void)
{
	invert_char(position % columns, position/columns);
}

/** Print character to screen
 *
 *  Emulate basic terminal commands
 */
static void fb_putchar(chardev_t *dev, char ch)
{
	spinlock_lock(&fb->lock);

	if (ch == '\n') {
		invert_cursor();
		position += columns;
		position -= position % columns;
	} else if (ch == '\r') {
		invert_cursor();
		position -= position % columns;
	} else if (ch == '\b') {
		invert_cursor();
		if (position % columns)
			position--;
	} else if (ch == '\t') {
		invert_cursor();
		do {
			draw_char(' ');
			position++;
		} while (position % 8);
	} else {
		draw_char(ch);
		position++;
	}
	if (position >= columns*rows) {
		position -= columns;
		scroll_screen();
	}
	invert_cursor();
	spinlock_unlock(&fb->lock);
}

static chardev_t framebuffer;
static chardev_operations_t fb_ops = {
	.write = fb_putchar,
};


/** Initialize framebuffer as a chardev output device
 *
 * @param addr Address of framebuffer
 * @param x X resolution
 * @param y Y resolution
 * @param bytes Bytes per pixel (2,3,4)
 */
void fb_init(__address addr, int x, int y, int bytes)
{
	fbaddress = (unsigned char *)addr;

	switch (bytes) {
	case 1:
		putpixel = putpixel_1byte;
		getpixel = getpixel_1byte;
		break;
	case 2:
		putpixel = putpixel_2byte;
		getpixel = getpixel_2byte;
		break;
	case 3:
		putpixel = putpixel_3byte;
		getpixel = getpixel_3byte;
		break;
	case 4:
		putpixel = putpixel_4byte;
		getpixel = getpixel_4byte;
		break;
	default:
		panic("Unsupported color depth");
	}
	
	xres = x;
	yres = y;
	pixelbytes = bytes;
	
	rows = y/ROW_HEIGHT;
	columns = x/COL_WIDTH;

	clear_screen();
	draw_logo(xres-helenos_width, 0);
	invert_cursor();

	chardev_initialize("fb", &framebuffer, &fb_ops);
	stdout = &framebuffer;
}