/*
Program: FAKETEXT.C
Author : Kim Moser
Date   : 6 August, 1990
System : IBM PC / Borland Turbo C 2.0
Descrip: Analyzes text files for frequency of all "windows" of
	 text of a given size, then creates an output file
	 based on the frequencies of all "windows" found.

Usage  : FAKETEXT -w<window_width> -i<textfile> -t<tmpPATH> [-c]
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <io.h>
#include <time.h>

typedef struct windowrec {
	long int window;
};

static int WIDTH=0;  /* Width of window */

static char *WINDOW1 = NULL, *WINDOW2 = NULL;
static long int NUMWINDOWS;

static char *INFILENAME=NULL, *TMPFILENAME=NULL;

static FILE *fin, *ftmp;

static int CONT;  /* Whether we should use existing TMP file */

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

static void halt(void);
static void halt(void)
{
	fcloseall();
	exit(-1);
}

static int seekwindow(long int i);
static int seekwindow(long int i)
{
	return (!fseek(fin, i, SEEK_SET));
}

static void readwindow(long int i, char *dest);
static void readwindow(long int i, char *dest)
{
#ifdef NOT_DEFINED
	if ((p = ftell(fin)) == -1L) {
		fprintf(stderr, "readwindow(): ftell() failed.\n");
		halt();
	}
#endif
	if (!seekwindow(i)) {
		fprintf(stderr, "readwindow(): seekwindow() failed (i=%ld)\n", i);
		halt();
	}

	if (fread(dest, (size_t) WIDTH, (size_t) 1, fin) != 1) {
		fprintf(stderr, "readwindow(): fread() failed.\n");
		halt();
	}
	dest[WIDTH] = '\0';

#ifdef NOT_DEFINED
	/* Dump window: */
	printf("window='");
	for (i=0; i<WIDTH; i++) putchar(dest[i]);
	printf("'  ");
#endif

#ifdef NOT_DEFINED
	/* Reset file pointer: */
	if (fseek(fin, p, SEEK_SET)) {
		fprintf(stderr, "readwindow(): fseek(%ld) failed.\n", p);
		halt();
	}
#endif
}

static int readwindowrec(long int i, struct windowrec *w);
static int readwindowrec(long int i, struct windowrec *w)
/* Attempts to read i'th window offset from tmpfile.
   Returns whether successful. */
{
	if (fseek(ftmp, i*sizeof(struct windowrec), SEEK_SET) != 0) {
		return 0;
	}
	return (fread((void*)w, (size_t)sizeof(struct windowrec), (size_t)1, ftmp) == (size_t)1);
}

static int writewindowrec(long int i, struct windowrec *w);
static int writewindowrec(long int i, struct windowrec *w)
/* Attempts to write i'th window record to tmpfile.
   Returns whether successful. */
{
	if (fseek(ftmp, i*sizeof(struct windowrec), SEEK_SET) == -1L) {
		return 0;
	}
	return (fwrite((void*)w, (size_t)sizeof(struct windowrec), (size_t)1, ftmp) == (size_t)1);
}

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

static void usage(void);
static void usage(void)
{
	fputs("FAKETEXT  v1.0 (08/06/1990)  Copyright (C) Kim Moser  All Rights Reserved\n", stderr);
	fputs("Usage: FAKETEXT -w<window_width> -i<textfile> -o<outfile> -t<tmpPATH> [-c]\n", stderr);
	halt();
}

static void parse(char *s);
static void parse(char *s)
{
	if ((s[0]=='-') || (s[0]=='/')) {
		switch (toupper(s[1])) {
			case 'W':
				if ((WIDTH = atoi(s+2)) == 0) usage();
				break;
			case 'I':
				INFILENAME = s+2;
				break;
			case 'T':
				TMPFILENAME = s+2;
				break;
			case 'C':
				CONT = 1;
				break;
			default:
				usage();
		}
	}
}

static void buildndx(void);
static void buildndx(void)
{
	long int i, p=0, prev=100;
	struct windowrec rec;

	fprintf(stderr, "   %% done%c%c%c%c%c%c%c%c%c", 8,8,8,8,8,8,8,8,8);
	for (i=0; i<NUMWINDOWS; i++) {
		p = ((100 * i) / NUMWINDOWS);
		if ((prev != (p%10)) && (!(p % 10))) {
			fprintf(stderr, "%3ld%c%c%c", p, 8,8,8);
		}
		prev = p;
		rec.window = i;
		if (!writewindowrec(i, &rec)) {
			fprintf(stderr, "buildndx(): writewindowrec() failed (i=%lu).\n", i);
			halt();
		}
	}
	fputc('\n', stderr);
}

static void sortndx(void);
static void sortndx(void)
{
	long int i, p=0, prev=100;
	struct windowrec rec1, rec2;
	long int swaps;

	fprintf(stderr, "         ");
	do {
		swaps = 0;  /* Assume */
		for (i=0; i<NUMWINDOWS-2; i++) {
			p = ((100 * i) / NUMWINDOWS);
			if ((prev != (p%10)) && (!(p % 10))) {
				fprintf(stderr, "%c%c%c%c%c%c%c%c%c%3ld%% done", 8,8,8,8,8,8,8,8,8, p);
			}
			prev = p;

			if (!readwindowrec(i, &rec1)) {
				fprintf(stderr, "sortndx(): readwindowrec() failed (i=%ld).\n", i);
				halt();
			}
			if (!readwindowrec(i+1, &rec2)) {
				fprintf(stderr, "sortndx(): readwindowrec() failed (i=%ld).\n", i+1);
				halt();
			}

			readwindow(rec1.window, WINDOW1);
			readwindow(rec2.window, WINDOW2);

			if (strcmp(WINDOW1, WINDOW2) > 0) {
				swaps++;
				/* WINDOW1 > WINDOW2, so swap them: */
				if (!writewindowrec(i, &rec2)) {
					fprintf(stderr, "sortndx(): writewindowrec() failed (i=%ld).\n", i);
					halt();
				}
				if (!writewindowrec(i+1, &rec1)) {
					fprintf(stderr, "sortndx(): writewindowrec() failed (i=%ld).\n", i);
					halt();
				}
			}
		}
		fprintf(stderr, " (%9ld swaps) %c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c", swaps, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8);
	} while (swaps);
	fputc('\n', stderr);
}

#ifdef NOT_DEFINED
static void packndx(void);
static void packndx(void)
{
	struct windowrec wrec;

	for (i=0; readwindowrec(i, &wrec); i++) {
		if (!wrec.count) {
			/* This record is empty, so find next non-empty
			   record and start copying from it to here,
			   until EOF found: */
			for (j=i+1;
		}
	}
}
#endif

static long int countwindow(long int index, long int *first);
static long int countwindow(long int index, long int *first)
/* Given the index of a windowrec, count how many windows
   start with the text in WINDOW1.  Set 'first' to the index of
   the windowrec of the first one, and return the count. */
{
	long int i;
	struct windowrec wr;
	long int count=0;

	fprintf(stderr, "countwindow(): index=%ld\n", index);

	*first = index;  /* Assume */

	/* Look backwards: */
	for (i=index; i >= 0; i--) {
		if (!readwindowrec(i, &wr)) {
			fprintf(stderr, "countwindow(): readwindowrec() failed for %d'th window.\n", i);
			halt();
		}
		readwindow(wr.window, WINDOW2);
		fprintf(stderr, "Checking if '%s' begins with '%s'\n", WINDOW2, WINDOW1);
		if (strstr(WINDOW2, WINDOW1) == WINDOW2) {
			count++;
			*first = i;
		} else {
			break;
		}
	}

	/* Look forwards: */
	for (i=index+1; i < NUMWINDOWS; i++) {
		if (!readwindowrec(i, &wr)) {
			fprintf(stderr, "countwindow(): readwindowrec() failed for %d'th window.\n", i);
			halt();
		}
		readwindow(wr.window, WINDOW2);
		fprintf(stderr, "Checking if '%s' begins with '%s'\n", WINDOW2, WINDOW1);
		if (strstr(WINDOW2, WINDOW1) == WINDOW2) {
			count++;
		} else {
			break;
		}
	}

	return (count);
}

static void writefake(void);
static void writefake(void)
{
	long int i, count, first;
	struct windowrec wr;

	randomize();

	/* Pick a window and output it: */
	if (!readwindowrec(i = (long int)random((int)NUMWINDOWS), &wr)) {
		fprintf(stderr, "writefake(): readwindowrec() failed for %ld'th windowrec.\n", i);
		halt();
	}

	readwindow(wr.window, WINDOW1);

	printf("%s", WINDOW1);

	while (1) {
		/* Throw away first char of window: */
		memmove(WINDOW1, WINDOW1 + 1, strlen(WINDOW1) + 1);

		/* Count how many windows begin with this window: */
		count = countwindow(i, &first);

		printf("count=%ld\n", count);

		exit(-1);

		/* Perform weighted random selection: */
		i = (long int) random(((int)count)) + first;

		/* Read new window: */
		if (!readwindowrec(i, &wr)) {
			fprintf(stderr, "writefake(): readwindowrec() failed for %ld'th windowrec.\n", i);
			halt();
		}
		readwindow(wr.window, WINDOW1);

		/* Output last character of window: */
		printf("%c", WINDOW1[strlen(WINDOW1)-1]);

	}


#if 0
	long int i, j, r;
	struct windowrec wrec;

	randomize();

	for (i=0; i<(NUMWINDOWS/WIDTH); i++) {
		r = (long int) random((int) NUMWINDOWS);
#ifdef NOT_DEFINED
		for (j=0; 1; j++) {
			if (!readwindowrec(j, &wrec)) {
				fprintf(stderr, "writefake(): readwindowrec() failed (j=%ld, r=%ld).\n", j, r);
				halt();
			}
			if (wrec.count >= r) {
				break;
			} else {
				r -= wrec.count;
			}
		}
#endif
		readwindow(j=r);
		for (j=0; j<WIDTH; j++) {
			printf("%c", WINDOW1[j]);
		}
	}
#endif
}

void main(int argc, char **argv)
{
	int i;
	long int flen;
	long int count;
	long int total=0;  /* How many windows total
			      (including dupes) */

	/* Parse args: */
	for (i=0; i<argc; i++) parse(argv[i]);
	if ((INFILENAME == NULL) || (!WIDTH)) {
		usage();
	}

	if ((WINDOW1 = calloc(WIDTH+1, sizeof(char))) == NULL) {
		fprintf(stderr, "Error allocating %d bytes for WINDOW1.\n", WIDTH+1);
		halt();
	}
	if ((WINDOW2 = calloc(WIDTH+1, sizeof(char))) == NULL) {
		fprintf(stderr, "Error allocating %d bytes for WINDOW2.\n", WIDTH+1);
		halt();
	}

	if ((fin = fopen(INFILENAME, "rb")) == NULL) {
		fprintf(stderr, "Unable to open infile '%s'.\n", INFILENAME);
		halt();
	}

	if (!CONT) {
		if ((ftmp = fopen(TMPFILENAME, CONT ? "rb" : "wb+")) == NULL) {
			fprintf(stderr, "Error opening temp file '%s'.\n", TMPFILENAME);
			halt();
		}
	}

	if ((flen = filelength(fileno(fin))) == -1L) {
		fprintf(stderr, "filelength() failed.\n");
		halt();
	}

	if (flen < WIDTH) {
		fprintf(stderr, "WIDTH must be < file length of input file.\n");
		halt();
	}

	NUMWINDOWS = (flen - WIDTH) + 1;
	fprintf(stderr, "%3ld windows total\n", NUMWINDOWS);

	if (CONT) {
		fprintf(stderr, "Continuing...\n");
	} else {
		fprintf(stderr, "Building index: ");
		buildndx();

		fprintf(stderr, "Sorting index: ");
		sortndx();
	}
#ifdef NOT_DEFINED
	/* Pack index just created: */
	packndx();
#endif

	writefake();

	free(WINDOW1);
	free(WINDOW2);

	fcloseall();
	exit(0);
}