/***********************************************************************************
 * File:	pro.c
 * Created:	19 NO 2000
 * Author:	R. DeArmond
 * Date modified: xx NO 2000
 *
 * This file contains the proform (pronoun et al) struct and array declaration for the lexicon, and
 * the prototypes for all of the functions specific to pronouns, to be used with the 
 * grammars one through eight. The functions are used to manipulate the proforms in
 * an array of proforms, which represents the proform portion of a lexicon.
 *
 * The current implementation, using an array to store the lexical entries for each 
 * type of word is adequate for now, but if the lexicon is to be allowed to grow to 
 * any size, this will have to change. In that case, the lexicon will have to be 
 * used in the file, and file access performed whenever the lexicon is to be used.
 * Currently, a maximum number of proforms (MAX_PRONOUNS = 16) is imposed so that the 
 * array can be declared.
 ***********************************************************************************/

/***********************************************************************************
 * includes		
 ***********************************************************************************/

#include <stdio.h>
#include <string.h>
#include "pro.h"
#include "lib.h"
#include "lexicon.h"
#include "functions.h"

int		pro_cat;
int		proplural;
int		propersonal;
int		profirst;
int		proanimate;
int		profem;
int		prohuman;
int		prowh;
int		proloc;
int		protemp;
int		prowhy;
int		prohow;
int		prorel;
int 		procase;
int		anaphor;
int		reflex;
int		proposs;
int		proposs_s;
int		prodef;

char pro_cat_form[STRING_SIZE];
char proform[STRING_SIZE];

//struct psuffix_struct psuff;
struct pro_struct pro1, pro2;

/***********************************************************************************
 * local function prototypes
 ***********************************************************************************/
void print_pro_features(struct pro_struct* p);

/***********************************************************************************
 * input:		a proform struct for which the features are to be displayed.
 * description:	uses printf to display the features to stdout.
 ***********************************************************************************/


/***********************************************************************************
 * extern function implementations
 ***********************************************************************************/
int find_pro_index(char *s)
// iterate through the list_pros, comparing the string passed in via the parameter
// to each proform, until the proform is found, or the end of the list is reached.
{
	int i;
	for(i=0;i<pronouns;i++)
		if(strcmp(s,list_pros[i].proform)==0)
			return(i);
	return(-1);
}


void enter_pro(char *s)
// copy the proform into the first empty struct in the array, then call get_n to fill
// the features. Sort the array.
{
	int pro_index;
	if(s[0]!=0)	
	{
		pro_index=pronouns;
		pronouns++;
		strcpy(list_pros[pro_index].proform, s);
		get_pro(&list_pros[pro_index]);
	}
	sort_pros();
}

void sort_pros(void)
// bubblesort
{
	int i,j;
	struct pro_struct temp_pro;
	for(i=pronouns-1;i>=0;i--)
		for(j=0;j<i;j++) 
		{
			if(strcmp(list_pros[j].proform,list_pros[j+1].proform)>0) 
			{
				memmove(&temp_pro,&list_pros[j],sizeof(struct pro_struct));
				memmove(&list_pros[j],&list_pros[j+1],sizeof(struct pro_struct));
				memmove(&list_pros[j+1],&temp_pro,sizeof(struct pro_struct));
			}
		}
}

void list_pros()
{
	int i;
	printf("There are %d proforms.\n",pronouns);
	for(i=0;i<pronouns;i++)
	{
		// print 5 proforms on a line.
		printf("%-15s",list_pros[i].proform);
		if(!((i+1)%5))
			printf("\n");
	}
	printf("\n");
}


int delete_pro(void)
// prompt for the proform, find it in the array. copy the last element in the array
// over the one to be deleted. decrement proforms (since we copied the last one 
// over the one we are deleting, we don't need to keep it at the end of the array anymore.
// sort.
{
	char	pro_entered[32];
	int index;

	printf("\tEnter the proform you want to delete: ");
	scanf("%s", pro_entered);

	index = find_pro_index(pro_entered);
	if (index == -1){
		printf("That proform is not in the lexicon.\n");
		return -1;
	}

	memcpy(&list_pros[index], &list_pros[pronouns-1], sizeof(struct pro_struct));
	pronouns--;
	sort_pros();
	save_lexicon(0);
	printf("%s has been deleted.\n", pro_entered);
	return 0;
}

void display_pro()
// prompt for the proform to be displayed, call print_pro_features.
{
	char pro_entered[32];	// for searching for a proform
	int index;

	printf("Enter the proform you are looking for: ");
	scanf("%s", pro_entered);
	index = find_pro_index(pro_entered);
	if (index == -1)
		printf("That proform is not in the lexicon.\n");
	
		print_pro_features(&list_pros[index]);
}

void new_pro()
// prompt for the new proform. If it doesn't already exist, call enter_noun
{
	char pro_entered[32];	// for searching for a proform
	int index;

	printf("Enter the new proform: ");
	scanf("%s", pro_entered);
	while(upper_word(pro_entered)!=0){
		printf("\nThis is not the lexical representation of the proform (a lexeme).\nRetype your proform in uppercase:  ");
		scanf(" %s",pro_entered);
	}
	index = find_pro_index(pro_entered);
	if (index == -1){
		enter_noun(pro_entered);
		save_lexicon(0);
	}
	else 
		printf("%s is already in the lexicon.\n", pro_entered);
}

void edit_pro()
// prompt for the proform to be edited. display its features. prompt for the new proform
// if it exists, and is not the one we are editing, stop. else call get_n to get
// the new features, then sort and get the new index for the proform.
{
	char pro_entered[32];	// for searching for a proform
	int index, index2;

	printf("Enter the proform to be edited: ");
	scanf("%s", pro_entered);
	index = find_pro_index(pro_entered);
	if (index == -1)
		printf("That proform is not in the lexicon.\n");
	else {
		print_pro_features(&list_pros[index]);

		printf("\n\nType in the correct proform:  ");
		scanf(" %s",pro_entered);
		//check to see if this profom already exists, if it isn't the same as the original being edited
		index2 = find_pro_index(pro_entered);
		if((index2==-1)||(index2==index)) {
			strcpy(list_pros[index].proform,pro_entered); //so we can find the new index for the proform.
			get_pro(&list_pros[index]);
			sort_nouns();
			// get the new index
			index = find_pro_index(pro_entered);
			save_lexicon(0);

			printf("The new features of the proform are: \n");
			print_pro_features(&list_pros[index]);
		}
		else
			printf("That proform already exists in the lexicon\n");
	}
}

void get_pro(struct pro_struct *p)
// blank out the old values (except the proform itself), then prompt for features using Dr DeArmond's rules.
{
	printf("What is the categorial symbol of the proform? Answer with 'N', 'V', 'A' and so forth: ",p->pro_cat_form);
	scanf("%s",p->pro_cat_form);
	printf("\n[%s %s ] is a proform.\n\n",p->pro_cat_form,p->proform);
}

void print_pro_features(struct pro_struct* p)
{
	printf("\t\tProform:\t\t\t\t\t\t\t\t\t%s\n",p->proform);
	printf("\t\tCategory of Proform:\t\t\t\t\t\t%s\p", p->pro_cat_form);
}

//#endif