#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define VERSION "1.00"

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

/*

vidmemsize   1024*1024*4

-----------

hsyncfreq = pixclock * 1000 / xlen
refreshrate = hsyncfreq * 1000 / ylen

-----------

xres        = 640
hsyncstart  = 664
vsyncend    = 760
xlen        = 800

yres        = 400
vsyncstart  = 409
vsyncend    = 411
ylen        = 450

pixclock    = hsyncfreq * xlen / 1000

-----------

Z = vidmemsize / xres
T = 1000000 / pixclock

l = xlen - hsyncend
r = hsyncstart - xres

t = ylen - vsyncend
b = vsyncstart - yres

h = hsyncend - hsyncstart
v = vsyncend - vsyncstart

-----------

geometry xres yres  xres Z
timings  T l r t b h v

-----------

*/

static int xres,yres, xlen,ylen, refreshrate, xofs,yofs;
static int depth, hslen,vslen, vidmemsize, hfreq;
static int fontxres, fontyres;

static void GenMode(void)
{
	float hsyncfreq = refreshrate * ylen / 1000.0;
	float pixclock = hsyncfreq * xlen / 1000.0;
	
	int hsyncstart = xres + xofs, hsyncend = hsyncstart + hslen;
	int vsyncstart = yres + yofs, vsyncend = vsyncstart + vslen;
	
	int Z = vidmemsize / xres;
	int T = 1000000 / pixclock;
	
	int l = xlen - hsyncend,  r = hsyncstart - xres;
	int t = ylen - vsyncend, b = vsyncstart - yres;
	
	int h = hsyncend - hsyncstart;
	int v = vsyncend - vsyncstart;
	
	printf(
		"# xres %d, yres %d, xlen %d, ylen %d, xofs %d, yofs %d,\n"
		"# mem %d kB, depth %d, hslen %d, vslen %d,\n"
		"# pixclock %g kHz, hfreq %g Hz, refresh %d Hz\n"
		"\n"
		"# XF86Config modelines\n"
		"Modeline \"%dx%d\"      %-8.3f %d %d %d %d    %d %d %d %d\n"
		"Modeline \"%dx%d\"      %-8.3f %d %d %d %d    %d %d %d %d doublescan\n"
		"\n"
		"# TextConfig modelines\n"
		"\"%dx%dx%d_%dHz\"  %-8.3f %d %d %d %d    %d %d %d %d  font %dx%d\n"
		"\"%dx%dx%d_%dHz\"  %-8.3f %d %d %d %d    %d %d %d %d  font %dx%d doublescan\n"
		"\n"
		"# fb.modes modeline\n"
		"mode \"%dx%d-%d\"\n"
		"  geometry %d %d  %d %d  %d\n"
		"  timings %d  %d %d  %d %d  %d %d\n"
		"endmode\n"
		"# fbset -accel true -g %d %d %d %d %d -t %d %d %d %d %d %d %d\n"
		"\n",
			/* comment */
			xres, yres, xlen, ylen, xofs, yofs,
			vidmemsize/1024, depth, hslen, vslen,
			refreshrate * hsyncfreq, hsyncfreq*1000, refreshrate,
			/* xf86 */
			xres,yres,
				pixclock,  xres,hsyncstart,hsyncend,xlen,  yres,vsyncstart,vsyncend,ylen,
			xres,yres/2,
				pixclock,  xres,hsyncstart,hsyncend,xlen,  yres/2,vsyncstart/2,vsyncend/2,ylen/2,
			/* textconfig */
			xres/fontxres,yres/fontyres, fontxres,refreshrate,
				pixclock,  xres,hsyncstart,hsyncend,xlen,  yres,vsyncstart,vsyncend,ylen,
				fontxres, fontyres,
			xres/fontxres,yres/fontyres/2, fontxres,refreshrate,
				pixclock,  xres,hsyncstart,hsyncend,xlen,  yres/2,vsyncstart/2,vsyncend/2,ylen/2,
				fontxres, fontyres,
			/* fbmode name */
			xres, yres, refreshrate,
			/* fbmode */
			xres, yres, xres, Z, depth, T, l,r, t,b, h,v,
			/* fbmode commandline */
			xres, yres, xres, Z, depth, T, l,r, t,b, h,v
		);
}


static int Heelp;
static char ProgName[] = "fbmodes";
static void PrintVersionInfo(void)
{
	printf(
		"%s version "VERSION"\n"
		"Copyright (C) 1992,1999 Bisqwit (http://iki.fi/bisqwit/)\n", ProgName);
}
static void PrintDescription(void)
{
	printf("\nGenerates XF86Config and fb.modes entries from given resolution\n");
}
static long ParamRange(long min, long max, const char **s)
{
	long tmp = strtol(*s, (char **)s, 10);
	if(tmp<min || tmp>max)
	{
		printf("%s: parameter value out of range `%ld'\n", ProgName, tmp);
		exit(EXIT_FAILURE);
	}
	return tmp;
}
static void Case(int ID, const char **dummy)
{
	switch(ID)
	{
		case 0:	/* startup */
			break;			
		case 'v':
			PrintVersionInfo();
			exit(EXIT_SUCCESS);			
		case 'x': xres=ParamRange(8,10000, dummy); break;
		case 'y': yres=ParamRange(8,10000, dummy); break;
		case 'w': xlen=ParamRange(8,10000, dummy); break;
		case 'h': ylen=ParamRange(8,10000, dummy); break;
		case 'r': refreshrate=ParamRange(1,1000, dummy); break;
		case 'b': depth=ParamRange(1,64, dummy); break;
		case 'X': xofs=ParamRange(0,10000, dummy); break;
		case 'Y': yofs=ParamRange(0,10000, dummy); break;
		case 'H': hslen=ParamRange(1,10000, dummy); break;
		case 'V': vslen=ParamRange(1,10000, dummy); break;
		case 'm': vidmemsize=ParamRange(1,1000000, dummy)*1024; break;		
		case 'f': hfreq=ParamRange(100,1000000, dummy); break;
		case '1': fontxres=ParamRange(4,32, dummy); break;
		case '2': fontyres=ParamRange(1,32, dummy); break;
		case '?': Heelp  = 1; break;
		case -1: /* finish args, set default values if necessary */
			if(!xres)xres = 256;
			if(!yres)yres = 256;
			if(!hfreq)hfreq = 31500;
			if(!refreshrate && !ylen)refreshrate = 120;
			if(!xlen)xlen = xres * pow(1950.0 / xres, 0.2);
			if(!ylen)ylen = hfreq/refreshrate > yres ? hfreq/refreshrate : yres*9/8;
			if(!refreshrate)refreshrate = hfreq / ylen;
			if(!depth)depth = 8;
			if(!xofs)xofs = (xlen-xres)/2;
			if(!yofs)yofs = (ylen-yres)/3;
			if(!hslen)hslen = min(40,(xlen-xres)/2-1);
			if(!vslen)vslen = min(10,(ylen-yres)/2-1);
			if(!vidmemsize)vidmemsize = 1024 * 4000;
			if(!fontxres)fontxres = 8;
			if(!fontyres)fontyres = 8;
			
			#define fatal(ehto) \
				if(ehto)fprintf(stderr, \
					"*** THIS MODE IS IMPOSSIBLE! %s\a\n", #ehto);
			
			fatal(ylen < yres);
			fatal(xlen < xres);
			fatal(xofs < 0);
			fatal(yofs < 0);
			fatal(xofs+hslen > xlen-xres);
			fatal(yofs+vslen > ylen-yres);
			
			#undef fatal

			break;
	}
	/* Ensure no warnings about unused args */
	dummy = dummy;
}
static struct
{
	int ID;
	char c, c2, *txt, *descr;
} Options[] =
{
	/* ID-----c--c2----txt--------descr---------------- */
	{'?',   '?',  0,"help",      "Help"},
	{'x',   'x',  0,"xres n",    "Requested horizontal resolution (default: 256)"},
	{'y',   'y',  0,"yres n",    "Requested vertical resolution (default: 256)"},
	{'f',   'f',  0,"hfreq n",   "Horizontal pixel clock/Hz (default: 31500)"},
	{'r',   'r',  0,"refresh n", "Specify (vertical) display refreshment rate/Hz\n"
	       "                       (default: hfreq/ylen or 120)"},
	{'w',   'x','l',"xlen n",    "Specify video line width/pixels (default: xres*3/2)"},
	{'h',   'y','l',"ylen n",    "Specify number of scanlines (default: hfreq/refresh)"},
	{'b',   'd',  0,"depth n",   "Specify bitness (used in fb.modes) (default: 8)"},
	{'X',   'X',  0,"xofs n",    "Specify hsyncstart-xres (default: (xlen-xres)/2)"},
	{'Y',   'Y',  0,"yofs n",    "Specify vsyncstart-yres (default: (ylen-yres)/3)"},
	{'H',   'x','s',"hslen n",   "Specify hsync length/pixels\n"
	       "                       (default: min(40,(xlen-xres)/2-1))"},
	{'V',   'x','s',"vslen n",   "Specify vsync length/pixels\n"
	       "                       (default: min(10,(ylen-yres)/2-1))"},
	{'1',   'f','x',"fontxres n","Specify fontxres (used in TextConfig) (default: 8)"},
	{'2',   'f','y',"fontyres n","Specify fontyres (used in TextConfig) (default: 8)"},
	{'m',   'm',  0,"mem n",     "Video memory size/kB (default: 4000)"},
	{'v',   'V',  0,"version",   "Version information"},
	{0,0,0,NULL,NULL}
};
static void ArgError(int a, const char *b)
{
	if(a)
		printf("%s: unrecognized option `--%s'", ProgName, b);
	else
	{
		printf("%s: illegal option -- %c", ProgName, *b);
		for(a=0; Options[a].c; a++)
			if(*b == Options[a].c)
			{
				putchar(b[1]);
				break;
			}
	}
	printf("\nTry `%s --help' for more information.\n", ProgName);
	exit(EXIT_FAILURE);
}
static void ReadArgs(int argc, const char *const *argv)
{
	int a;
	
	Case(0, NULL);

	for(a=1; a<argc; a++)
	{
		const char *s = argv[a];

ReArg:	if(!s)continue;
		while(*s==' ' || *s=='\t')s++;
		if(!*s)continue;

		if(*s == '-' || (*s=='/'&&s[1]=='?'))
		{
			if(*++s == '-')
			{
				int b=0;
				for(s++; Options[b].c; b++)
				{
					const char *t = Options[b].txt;
					const char *q = strchr(t, ' ');
					if(!q)q = strchr(t, 0);
					if(!strncmp(s, t, q-t) && !s[q-t])
					{
						s = argv[++a];
						Case(Options[b].ID, &s);
						goto ReArg;
					}
				}
				ArgError(1, s);
			}
			while(s && *s)
			{
				int b,c;
				for(b=c=0; Options[b].c; b++)
					if(s[0]==Options[b].c && s[1]==Options[b].c2)
						c=1, s += 2, Case(Options[b].ID, &s), s--;
				if(!c)
					for(b=0; Options[b].c; b++)
						if(s[0]==Options[b].c && !Options[b].c2)
							c=1, s++, Case(Options[b].ID, &s), s--;
					
				if(!c)ArgError(0, s);
				if(s)s++;
			}
		}
	}
	
	if(Heelp)
	{
		PrintVersionInfo();
		PrintDescription();
		
		printf("\nUsage: %s [-", ProgName);
		for(a=0; Options[a].c; a++)if(!Options[a].c2)printf("%c", Options[a].c);
		printf("]\n\n");

		for(a=0; Options[a].c; a++)
			printf("  -%c%c%c--%-14s%s\n",
				Options[a].c,
				Options[a].c2?Options[a].c2:',',
				Options[a].c2?',':' ',
				Options[a].txt,
				Options[a].descr);

		printf(
			"\n"
			"The order of the parameter elements is not important.\n"
			"Also any of them can be omitted.\n"
			"\n"
			"Pparameter translation algorithm:\n"
			" If hfreq was specified and refresh was not specified,\n"
			"     refresh gets calculated from hfreq/ylen.\n"
			" Else if refresh was not specified, it is assumed as 120.\n"
			" Next if ylen was not specified, it is calculated from hfreq/refresh.\n"
			" If ylen, refresh and hfreq were specified, ignore hfreq.\n"
			" Next, if hslen and vslen were not specified, calculates them as documented.\n"
		);
		
		exit(EXIT_SUCCESS);
	}
	Case(-1, NULL);
}

int main(int argc, const char *const *argv)
{
	ReadArgs(argc, argv);
	
	GenMode();
	
	return 0;
}