/* Screen.c by Nathan Hellweg */

#include<curses.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<term.h>
#include"screen.h"

#define min(a,b) ((a)<(b)?(a):(b))

int Scrn_state=0;

char *tparm();
char *getenv();

int **Scrn_Buffer;
int **Scrn_Image;

int Rows;
int Cols;

int cur_y;
int cur_x;
int cur_state;

struct termios termios_old;

void move_cur(int y, int x) {
	char *s;

	if(!cursor_address) {
		fprintf(debug,"Cursor motion string not set");
		exit(1);
	}
	s=tparm(cursor_address,y,x);
	putp(s);
}	

void cls() {
	if(clear_screen == NULL){
		fprintf(debug,"Clear Scrn not set");
		exit(1);
	}
	putp(clear_screen);
}


int terminit() {
	char *term;
	int outc();
	int status;
	int i,j;
	char *s;

	/*Get term type */
	if((term=getenv("TERM"))==NULL) {
		fprintf(stderr,"TERM is not set");
		exit(1);
	}
	setupterm(term,1,&status);
	if(status!=1){
		fprintf(stderr,"Error in setupterm");
		exit(1);
	}

	/* clear Scrn */

	cls();

	Cols=columns;
	Rows=lines;

	return(1);
}



int Buff_Init() {
	int i,j;


	Scrn_Buffer=(int **)malloc(sizeof(int *)*Rows);

	Scrn_Image=(int **)malloc(sizeof(int *)*Rows);

	for(i=0;i<Rows;i++) {
		Scrn_Buffer[i]=(int *)malloc(sizeof(int)*Cols);
		Scrn_Image[i]=(int *)malloc(sizeof(int)*Cols);
	}
	
	for(i=0;i<Rows;i++){
		for(j=0;j<Cols;j++) {
				Scrn_Image[i][j]=' ';
				Scrn_Buffer[i][j]=bg_char;
		}
	}
	return(1);
}

void Buff_Close() {
	int i;

	for(i=1;i<Rows;i++) {
		free(Scrn_Image[i]);
		free(Scrn_Buffer[i]);
	}
	free(Scrn_Image);
	free(Scrn_Buffer);
}

void Buff_Resize()
{
	Buff_Close();
	Buff_Init();
}

void Scrn_Refresh() {
	int i,j;
	char buff[1024];

	setbuffer(stdout,buff,1024);
	for(i=0;i<Rows;i++){
		for(j=0;j<Cols;j++)
			if(Scrn_Image[i][j]!=Scrn_Buffer[i][j])
				Scrn_Write(i,j,Scrn_Image[i][j]=Scrn_Buffer[i][j]);
	}
	fflush(stdout);
	setbuf(stdout,0);
	move_cur(0,0);
}

void Scrn_Putch(int y, int x, int c) {
	if(y<0||y>=Rows||x<0||x>=Cols)
		return;
	Scrn_Buffer[y][x]=c;	
}

void Scrn_Redraw() {
	int i,j;

	for(i=0;i<Rows;i++) {
		move_cur(i,0);
		for(j=0;j<Cols-1;j++)
			putchar(Scrn_Image[i][j]=Scrn_Buffer[i][j]);
	}
}

int Scrn_Init()
{
	struct termios termios_new;

	if(terminit()==0) {
		fprintf(stderr,"Error initializing terminal \n");
		exit (1);
	}
	Buff_Init();
	/* Kick in to raw mode... */
	if(tcgetattr(0,&termios_old)) {
		fprintf(stderr,"Couldn't get stdin's attributes! (errno=%d)\n",errno);
		exit(-1);
	}
	if(tcgetattr(0,&termios_new)) {
		fprintf(stderr,"Couldn't get stdin's attributes! (errno=%d)\n",errno);
		Scrn_End();
	}
	cfmakeraw(&termios_new);
	if(tcsetattr(0,0,&termios_new)) {
		fprintf(stderr,"Couldn't set stdin's attributes! (errno=%d)\n",errno);
		Scrn_End();
	}

	Scrn_Refresh();
}

void Scrn_End() {
	Scrn_State(0);

	/* Kick back to cooked mode... */
	if(tcsetattr(0,0,&termios_old))
		fprintf(debug,"Couldn't set stdin's attributes! (errno=%d)\n",errno);

	Buff_Close();
	cls();
}

void Scrn_State(int NewState) {
	if(NewState==cur_state)
		return;

	putp(exit_attribute_mode);
	putp(exit_underline_mode);
	putp(exit_standout_mode);
	putp(exit_alt_charset_mode);
	
	if(NewState&TW_ALTCHAR)
		putp(enter_alt_charset_mode);
	if(NewState&TW_ULCHAR)
		putp(enter_underline_mode);
	if(NewState&TW_REVCHAR)
		putp(enter_reverse_mode);
	if(NewState&TW_BOLDCHAR)
		putp(enter_bold_mode);
	if(NewState&TW_BLINKCHAR)
		putp(enter_blink_mode);
	cur_state=NewState;
}

void Scrn_Move(int y, int x) {
	char *s;
	
	if(cur_y==y&&cur_x==x)
		return;
	if(cursor_address == NULL){
		fprintf(debug,"Cursor motion string not set");
		exit(1);
	}
	s=tparm(cursor_address,y,x);
	putp(s);
}	

void Scrn_Write(int y, int x, int c) {
	if(y>=Rows||x>=Cols)
		return;
	if(y!=cur_y||x!=cur_x)
		Scrn_Move(y,x);
	if(state(c)!=state(cur_state)){
/*		fprintf(debug,"Changed states from %d to %d\n",state(cur_state),state(c)); */
		Scrn_State(state(c));
	}
	putchar(c);
	cur_x++;
	if(cur_x>=Cols)
		Scrn_Move(cur_y+1,0);
}