tp.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "trees.h"
#include "linkedList.h"
#include "sumTools.h"
#include "strs.h"



//this treats the blank line as a seperator between paragrahps 
//Im using it in the extractiion operation to since my sets are built this way 
void populateTheStructure9dima(char *fileLocation, node **listHead) {
    node *paragraph = NULL;
    cell *paragraphTree = NULL;
    FILE *file = fopen(fileLocation, "r");
    char line[256];
    char copy[256];        
  
    if (file == NULL) {
		printf("Error: failed to open file.\n");
        return;
    }


   while (fgets(line, sizeof(line), file) != NULL) {
        if (isBlankLine(line)) {
            continue;
        }
		paragraph = NULL;
    	paragraphTree = NULL;
	
       do{
            strcpy(copy, line);                         
			
            char *word = strtok(copy, " \t\r\n,.?!;:\"()");
            while (word != NULL) {
				toLowerCase(word);
                insert(&paragraphTree, word);
                word = strtok(NULL, " \t\r\n,.?!;:\"()");
            }
            fgets(line, sizeof(line), file);
               
        } while (!isBlankLine(line) && !feof(file)) ;
		if(paragraphTree != NULL){
		insertNewParagraph(listHead , paragraph , paragraphTree);
		}
		
       
    }
   

    fclose(file);
}

//this treat each \n as the end of paragraph 
void populateTheStructure(char *fileLocation, node **listHead) {
	node *paragraph = NULL;
	cell *paragraphTree = NULL;
	FILE *file = fopen(fileLocation, "r");
	char line[10000];
	char copy[10000];        
	int numberOfParagraphs = 0 ;
	if (file == NULL) {
		printf("Error: failed to open file.\n");
		return;
	}

    while(fgets(line, sizeof(line), file) != NULL) {
		
		if (isBlankLine(line)) {
			continue;
		}
		numberOfParagraphs++;
		paragraph = NULL;
		paragraphTree = NULL;
		
			strcpy(copy, line);                         
			
			char *word = strtok(copy, " \t\r\n,.?!;:\"()");
			while (word != NULL) {
				toLowerCase(word);
				insert(&paragraphTree, word);
				word = strtok(NULL, " \t\r\n,.?!;:\"()");
			}
			if(paragraphTree != NULL && paragraphTree->word != NULL){
			insertNewParagraph(listHead , paragraph , paragraphTree);
			}
		}
	if(numberOfParagraphs == 0){
		node * vide = malloc(sizeof(node));
		cell * emptyParagraph = malloc(sizeof(cell));
		emptyParagraph->word = malloc(sizeof(char) * 20);
		vide->pragraph = emptyParagraph ;
		
		strcpy(vide->pragraph->word, "empty file");
		vide->next = NULL ;
		insertNewParagraph(listHead, vide , vide->pragraph);
	}
	fclose(file);
	
}


//check the existence of a word in a tree 
int exist(cell* root , char * word , int (*comparision)(const char * a ,const  char * b) , char * similarword ){
	if(root == NULL ){
		return 0 ; 
	}else{
		if(comparision == NULL){
			comparision = strcmp ; //this means we will do literal coomparision not similarity based
		}
		if(comparision(word , root->word ) == 0 ) {
			if(similarword != NULL){
			strcpy(similarword , root->word ); 
			}
		    return 1 ;
		}else  if(strcmp(word , root->word) > 0){
			return exist(root->rightC , word , comparision , similarword);
		
		}else{
			return exist(root->leftC , word , comparision , similarword);
		}
   }
}

void insertAll(cell * tree1 , cell ** tree2){
	if(tree1 == NULL){
		return ; 
	}else{
		insertAll(tree1->leftC , tree2 );
		insert(tree2, tree1->word); 
		insertAll(tree1->rightC ,	tree2 ) ;
	}
	return ;
}

void  setsUnion(cell * tree1 , cell * tree2 ,cell ** tree3 ,  int (*comparision)(const char * a ,const  char * b) ){ //i made this to contain the return pointer and save the initial states of the two sets 
	
	if(tree1 != NULL){
		insertAll(tree1 , tree3);
	} 
	if(tree2 != NULL){
		insertAll(tree2 , tree3);
	}

	 
}

// i build this to take build the intersection from the both sets taking the longest word in the case of similarity based comparision 

void  setsIntersection(cell * tree1 , cell * tree2 ,cell **tree3 ,  int (*comparision)(const char * a ,const  char * b) ){
char * word = NULL ;
word = malloc(sizeof(char) * 20); 
if(tree1 == NULL){
	return ;
}else{
	setsIntersection(tree1->leftC , tree2 , tree3, comparision);

	if(exist(tree2 ,  tree1->word , comparision, word) ){ 
		if(strlen(word) > strlen(tree1->word)){
			insert(tree3 , word);
		}else{
			insert(tree3,tree1->word);
		}
		
	}
	setsIntersection(tree1->rightC , tree2 , tree3, comparision);
}
}
// i build this to take build the intersection from the first sets not the longest word as in the first sets interection 
void  setsIntersection2(cell * tree1 , cell * tree2 ,cell **tree3 ,  int (*comparision)(const char * a ,const  char * b) ){
if(tree1 == NULL){
	return ;
}else{
	setsIntersection2(tree1->leftC , tree2 , tree3, comparision);
	
	if(exist(tree2 ,  tree1->word , comparision, NULL) ){ 
			insert(tree3,tree1->word);
	}
	setsIntersection2(tree1->rightC , tree2 , tree3, comparision);
}
}
void  difference(cell * tree1 , cell * tree2 ,cell **tree3 ,  int (*comparision)(const char * a ,const  char * b)){
char * word = NULL ;
word = malloc(sizeof(char) * 20); 

if(tree1 == NULL){
	return ;
}else{
	difference(tree1->leftC , tree2 , tree3 , comparision);
	if(!exist(tree2 ,  tree1->word , comparision, word )){
		insert(tree3,tree1->word);
		
	}
	difference(tree1->rightC , tree2 , tree3, comparision);
}

}

// i leave this function to gard the int type to do the recusive call condition even when the outer function is of void type 
// all of this so i can use it directly in the menu procedure directly 

int includeInner(cell * tree1 , cell * tree2 , cell **tree3 ,  int (*comparision)(const char * a ,const  char * b)){
	if(tree1 == NULL){
		return 1 ;
		 strcpy((*tree3)->word ,"included" ) ; 
	}else if (tree1->leftC == NULL && tree1->rightC == NULL){
		if(exist(tree2 , tree1->word , comparision , NULL )){
			strcpy((*tree3)->word ,"included" ); 
			return 1 ;	
		}else{
		 	strcpy((*tree3)->word ,"not included");
			return 0 ; 
		}
	}else{
		 if(includeInner(tree1->leftC , tree2, tree3 , comparision ) && includeInner(tree1->rightC , tree2 , tree3 , comparision) &&  exist(tree2 , tree1->word , comparision , NULL )) {
			strcpy((*tree3)->word ,"included" );
			return 1 ;
		 }else{
			strcpy((*tree3)->word ,"not included");
			return 0 ; 
		 }

	}
	
}

void include(cell * tree1 , cell * tree2 , cell **tree3 ,  int (*comparision)(const char * a ,const  char * b)){
	includeInner(tree1 , tree2 , tree3 , comparision); 
}

void printMainStructure(node * head){ //print the list of trees 
	while(head != NULL){
		
		printTree(head->pragraph);
	
		
		
		head = next(head); 
	}
}
// this count the number of files entered by the user 

int filesNumber(char * fileNamesString){
	int count = 0 ;
	for(int i = 0 ; fileNamesString[i] != '\0' ; i++){
		if(fileNamesString[i] == ' ' || fileNamesString[i] == '\t' || fileNamesString[i] == '\n'){
			count++;
		}
	}
	return count + 1 ;
}

void askforfiles(node *** filesHeader , int mode ){ 
	int n = 0 ;
	char fileNamesString[256] ;
	int i = 0 ;
	if(mode==1){
	printf("Enter file paths separated by spaces (absolute or relative):\n");

	}
	fgets(fileNamesString, 256, stdin);

	char * copy = malloc(sizeof(char) * 256);
	strcpy(copy , fileNamesString);

	char * fileName = malloc(sizeof(char)*50);
 	char ** list = malloc(sizeof(char * ) *  filesNumber(fileNamesString));

	fileName = strtok(copy , " \t\n");
		
	while(fileName != NULL){
		list[i] = fileName;
		fileName = strtok(NULL , " \t\n");
		i++;
	}
	
								
	
	(*filesHeader) = malloc((i + 1) * sizeof(node *)) ; //list of the headers of the linked list of each file

	for (int j = 0; j <= i; j++) {
		(*filesHeader)[j] = NULL;
	}

	for(int k = 0 ; k < i ; k++){
		populateTheStructure(list[k] , &(*filesHeader)[k]);
	}
	
	
}
node * getParagraph(node * file , int index ){
int i = 0 ; 
while(file != NULL && i < index){
	file = file->next ; 
	i++;
}

	return file ;
}
//MENU PROCEDURE
//i build one big procedue because the process of intersection and union and difference is almost the same with a few details that i handle with conditions inside the procedure 
void operationSelected(cell ** result , node ** filesHeader , void (*operation)(cell * tree1 , cell * tree2 , cell ** tree3 , int (*comparision)(const char * a ,const  char * b))    , int mode ){
    int k = 0 ;
	int selectedParagraphs = 0 ;
	int (*comparisionFun)(const char * a ,const  char * b);
	char operationName[20];  
	if(operation == setsIntersection){
		strcpy(operationName , "intersection");
	}else if(operation == difference){
		strcpy(operationName , "difference");
	}else if(operation == setsUnion){
		strcpy(operationName , "union");
	}else if(operation == include){
		strcpy(operationName , "inclusion test");
	}
	int selection ;
	selection = 0 ;
	while(selection < 1 || selection > 3){
		if(operation == include){
			selection = 2;
			break;
		}
		printf("Choose how to select paragraphs:\n");
		printf("1) Select by order in each file\n");
		printf("2) Select by file:number pairs\n");
		printf("3) Select all paragraphs in order\n");

		scanf("%d" , &selection);
		while(getchar() != '\n');
		if(selection < 1 || selection > 3){
			printf("Invalid selection. Try again.\n");
		}
	}
	
	

	if(mode == 1 ){
		printf("Choose comparison method:\n");
		printf("1) Literal comparison\n");
		printf("2) Similarity-based comparison\n");
		int comparisionMethod ;
		comparisionMethod= 0 ;
		while(comparisionMethod < 1 || comparisionMethod > 2){
		scanf("%d" , &comparisionMethod);
		while(getchar() != '\n');
		if(comparisionMethod > 2 || comparisionMethod <  1){
			printf("Invalid option. Try again.\n");
		}
		}
		if(comparisionMethod == 1){
			comparisionFun = strcmp  ; //this means we will do literal coomparision not similarity based
		}else if(comparisionMethod == 2){
			comparisionFun = similarWords ;
		}
	}else{
		comparisionFun = strcmp; //  here we are using the strcmp to hide unecessary details from the user when extracting a set from the other 
	}
	
	switch (selection)
	{
	case 1: {
		int vide  = 0 ;

		printf("which paragraphs from which files you want to do the %s on ? \n", operationName);
		printf("say y or Y to select a paragraph toinclude in the operation \n");

		while(filesHeader[k] != NULL){
			node * current = filesHeader[k]; 
			int j = 0 ;
			printf("the file %d \n" ,  k);

			while(current != NULL){
				printf("Paragraph %d\n" ,  j);
				
				char answer ;
				
				scanf("%c" , &answer);
				while(getchar() != '\n');
				
				if(answer == 'y' || answer == 'Y'){
					selectedParagraphs++;
					if(selectedParagraphs==1&& k==0){
						if(strcmp(current->pragraph->word , "empty file")==0 && operation == setsIntersection){
							printf("Intersection result is empty.\n");
							*result =filesHeader[k]->pragraph;
							break;
						
						}else{
							*result = malloc(sizeof(cell));
						*result = (current->pragraph) ;
						printf("First paragraph selected.\n");
						}
						
							
					}else{
						printf("Paragraph selected.\n");
						cell * curr = *result ;
						*result = NULL ;
						if(strcmp(current->pragraph->word , "empty file")==0 && operation == setsIntersection){
							printf("Intersection result is empty.\n");
							*result = current->pragraph  ;
							break;
						
						}else{
							if(curr != NULL){
								operation(curr , current->pragraph , result , comparisionFun);
							}

						}
					}
				}
				
				j++ ; 
			current = current->next ; 
			}
			k++;
			if(vide == 1){
				break;
			}
		}
		
		break;
	}
	case 2: {
		printf("Enter paragraphs as file:paragraph (e.g., 0:1), separated by spaces:\n");
		char input[256];
		
		fgets(input, 256, stdin);
		input[strcspn(input , "\n")] = '\0'; 

		int i = 0; 
		char copy[256];  
		int inc = 0 ;
		strcpy(copy , input); 
		char * paragraph =  strtok(copy , " ");
		int pNumber = 0 ; 
		int fNumber = 0 ; 
		int f = 0 ;
		cell * first = NULL ;
		cell * second = NULL ;
		while(paragraph !=NULL){
			fNumber = fileNumber(paragraph);  
			pNumber = paragraphNumber(paragraph);
			if(operation != include){
				printf("\nParagraph %d of file %d\n" , pNumber , fNumber);
				if(getParagraph(filesHeader[fNumber],pNumber) != NULL){
					
					if(getParagraph(filesHeader[fNumber],pNumber)->pragraph != NULL){
						
						printTree(getParagraph(filesHeader[fNumber] , pNumber)->pragraph);

						if(*result == NULL ){
							
							*result = malloc(sizeof(cell)); 
							*result = getParagraph(filesHeader[fNumber] , pNumber)->pragraph ;
							 if(strcmp((*result)->word , "empty file")==0 && operation == setsIntersection){
								printf("Intersection result is empty.\n");
								break;
							 }

						}
						if(f != 0){
							cell * curr = *result ;
						
							*result = NULL ;
							if(strcmp( getParagraph(filesHeader[fNumber] , pNumber)->pragraph->word , "empty file")==0 && operation == setsIntersection){
							printf("Intersection result is empty.\n");
							*result =  getParagraph(filesHeader[fNumber] , pNumber)->pragraph  ;
							break;
						
						}else{
							if(curr != NULL){
								operation(curr , getParagraph(filesHeader[fNumber] , pNumber)->pragraph , result , comparisionFun);
							}

						}
							
						}
						

					}else{
						printf("Paragraph %d in file %d does not exist.\n" , pNumber ,fNumber );
					}
				}else{
					printf("Paragraph %d in file %d does not exist.\n" ,  pNumber , fNumber );
					if(operation == setsIntersection){
						printf("Intersection result is empty.\n");
						*result = NULL ;
					}
					break;
				}
			}else{ // case of inclusion operation 
				if(getParagraph(filesHeader[fNumber],pNumber) != NULL){
					if(inc > 2){
						printf("You can select at most 2 paragraphs for inclusion test.\n");
					}else{
						if(first == NULL){
							first = getParagraph(filesHeader[fNumber] , pNumber)->pragraph ;
							inc++;
						}else{
							inc ++;
							second = getParagraph(filesHeader[fNumber] , pNumber)->pragraph ;
						}
					}
					
					operation(first , second , result , comparisionFun); 
				}else{
					printf("Paragraph %d in file %d does not exist.\n" ,  pNumber , fNumber );
				}
				
			}
			
			paragraph = strtok(NULL , " ");
			f ++ ; 
		}
		
		break ; 
	}
	case 3: {
		while(filesHeader[k] != NULL){
			int j = 0 ;
			node * current = filesHeader[k]; 

			while(current != NULL){
				selectedParagraphs++;
				if(selectedParagraphs==1&& k==0){
					*result = malloc(sizeof(cell)); 
					*result = (filesHeader[k]->pragraph) ;
					if(strcmp((*result)->word , "empty file")==0 && operation == setsIntersection){
						printf("Intersection result is empty.\n");
						break;
					}
				}else{
					cell * curr = *result ;
					*result = NULL ;
					if(strcmp(current->pragraph->word , "empty file")==0 && operation == setsIntersection){
							printf("the intersection result is empty\n");
							*result = current->pragraph  ;
							break;
						
						}else{
							if(curr != NULL){
								operation(curr , current->pragraph , result , comparisionFun);
							}

						}
					
				}
				j++ ; 
				current = current->next ; 
			}
			k++;
		}
		
		break;
	}
	default:
		break;

	}
	if(mode == 1){
		system("clear");

		printf("Final %s result:\n", operationName);
		if(operation != include){
			if(*result == NULL){
				printf("Result is empty.\n");
			}else{
				printTree(*result);
			}
		}else{
			printf("%s " , (*result)->word);
		}
		
		printf("\n");
	}
}
//this is the same as set intersection but its build to extract from sets ordered alphabitacally to reduce the search time 
void checkSets(cell * tree , node * set , cell ** result) {
	if(tree == NULL){
		return;	
	}else{
		checkSets(tree->leftC , set , result);
		char first = tree->word[0];
		if(first >= 'A' && first <= 'Z'){
			first = (char)(first + ('a' - 'A'));
		}
		if(first >= 'a' && first <= 'z'){
			int number = first - 'a';
			node *paragraph = getParagraph(set , number);//our data sets are build in alphabitic order so we can search directlythe corresponding paragraph for the first letter of the word we want to extract from the set
			if(paragraph != NULL && paragraph->pragraph != NULL){
				if(exist(paragraph->pragraph , tree->word , NULL , NULL)){
					insert(result , tree->word);
				}
			}
		}
		checkSets(tree->rightC , set , result);
	}
}
//this procedure is used in the menu procedure to extract a set of words from the other based on the user selection of the set and the files to extract from and the operation to do on them
void extractingOperation(node *** filesHeader , char * operands){
	char *target = malloc(sizeof(char) * 60) ;
	strcpy(target , "dataSets/") ;

	int i = 0 ;
	while(operands[i] != '\0') {
		target[i+9] = operands[i];
		i++;
	}
	target[i + 9] = '\0';
	
	cell * unionResultFor = NULL ;
			askforfiles(filesHeader , 1 ); 
			if(*filesHeader == NULL){
				printf("No files selected.\n");
				return ;
			}else{
			printf("Select paragraphs to extract %s from:\n" , operands);

			operationSelected(&unionResultFor, *filesHeader, setsUnion , 2);
			node * verbs = NULL ;
			

			populateTheStructure(target , &verbs);
			
			
			cell   * resulting = NULL ;
				if(unionResultFor == NULL){
					printf("No paragraphs selected.\n");
					return ;
				}else if(verbs == NULL || verbs->pragraph == NULL ){
					printf("The %s set is empty.\n" , operands);
					return ;
				}else{ 

						if(strcmp(operands , "verbs.txt")==0 || strcmp(operands , "stopWords.txt")==0 ){
						checkSets( unionResultFor , verbs   , &resulting );

						}else{
							setsIntersection2(verbs->pragraph , unionResultFor , &resulting , similarWords ); 
						}


						
				}
			 printf("Extracted %s:\n" , operands);
			printTree(resulting);
			printf("What next?\n");
			}
}

int main(){

	int m = 0 ; 
	do{
	node ** filesHeader = NULL ; 
	printf("=== Document Processing Program ===\n");
	printf("Choose an option:\n");
	printf("1) Union on selected files\n");
	printf("2) Intersection on selected files\n");
	printf("3) Difference on selected files\n");
	printf("4) Check if a paragraph is included in another\n");
	printf("5) Extract special words\n");
	printf("6) Summarize file\n");
	printf("7) Check plagiarism between two files\n");
	printf("8) Exit\n");
	m=10 ;
	while(m > 8 || m < 1){
	printf("Your choice: ");

		scanf("%d" , &m);
		while(getchar() != '\n');
		if(m > 8 || m < 1){
			printf("Invalid choice. Try again.\n");
		}
	}
	system("clear");
	switch(m){
		case 1:
			// Union operation
			
			cell * unionResult = NULL ;

			askforfiles(&filesHeader , 1 );
			
			if(filesHeader == NULL){
				printf("No files selected.\n");
				return 0 ;
			}else{
			operationSelected(&unionResult, filesHeader, setsUnion , 1 );
			printf("What next?\n");
			}
			break;
		case 2:
			// Intersection operation
			cell * intersectionResult = NULL ;
			askforfiles(&filesHeader , 1 ); 
			operationSelected(&intersectionResult, filesHeader, setsIntersection , 1);
			
			break;
		case 3:
			// Difference operation
			cell * differenceResult = NULL ;
			askforfiles(&filesHeader , 1 );
			operationSelected(&differenceResult, filesHeader, difference , 1);
			break;
		case 4:
			// test the inclusion 
			cell * inclusionRes = NULL ; 
			inclusionRes = malloc(sizeof(cell));
			inclusionRes->word = malloc(sizeof(char) * 20);
			askforfiles(&filesHeader , 1 );
			operationSelected(&inclusionRes, filesHeader , include , 1);
			break;
		case 5:
			//extract verbs operation
			printf("Extract verbs/stop words or a custom set.\n");
			printf("1) Extract verbs\n");
			printf("2) Extract stop words\n");
			printf("3) Extract a custom set\n");
			
			int extractSelection ;
			extractSelection = 0 ;
			while(extractSelection < 1 || extractSelection > 3){
				printf("Your selection: \n");
				scanf("%d" , &extractSelection);
			while(getchar() != '\n');
				
				if (extractSelection < 1 || extractSelection > 3)
				{
					printf("Invalid selection. Try again.\n");
				}
				
			}
			switch(extractSelection){
				case 1:
				extractingOperation(&filesHeader , "verbs.txt");
				break; 
				case 2:
				extractingOperation(&filesHeader , "stopWords.txt");
				break;
				case 3:
				printf("Define a new set in the terminal or from a file in dataSets.\n");
				printf("1) Define in terminal\n");
				printf("2) Use a file from dataSets\n");

				int setDefSelection ;
				setDefSelection = 0 ;
				while(setDefSelection < 1 || setDefSelection > 2){
					printf("Your selection: \n");
					scanf("%d" , &setDefSelection);
					if (setDefSelection < 1 || setDefSelection > 2)
					{
						printf("Invalid selection. Try again.\n");
					}
				}
				

				
				switch (setDefSelection)
				{
				case 1://asking for the set items in the terminal write it in a file and extract from it 
					{
						
						FILE * file = fopen( "dataSets/sets.txt" , "w");
						if(file == NULL){
							printf("Error: file creation failed.\n");
							return 0 ;
						}
						char item[20] ;
						printf("Enter set items one per line; type 'done' to finish.\n");
						while(1){
							fgets(item , 20 , stdin);
							item[strcspn(item , "\n")] = '\0';
							if(strcmp(item , "done") == 0){
								break;
							}
							fprintf(file , "%s\n" , item);
						}
						fclose(file);
						extractingOperation(&filesHeader ,  "sets.txt");
					}
					
					break;
				case 2:
					char setFileName[256];
					printf("Enter file name (ending with .txt): ");
					fgets( setFileName , 256, stdin); 
					setFileName[strcspn(setFileName , "\n")] = '\0';
					extractingOperation(&filesHeader , setFileName);
			     break ;
				default:
					break;
				}
				break;
				default:
				printf("Invalid selection.\n");
			} 
			
			
			break;
		
		case 6:
				
				printf("Enter path of file to summarize:\n");
				int n = 0 ;
				char fileNamesString[256] ;
				fgets(fileNamesString, 256, stdin);
				fileNamesString[strcspn(fileNamesString , "\n")] = '\0';

				node * fileBysentences = NULL ; 
				populSentences(fileNamesString , &fileBysentences);
				node * byWords = NULL ; 
				populateTheStructure(fileNamesString , &byWords);

				node * stopWords = NULL ;
				node * verbs = NULL ;
				populateTheStructure("dataSets/stopWords.txt" , &stopWords);
				populateTheStructure("dataSets/verbs.txt" , &verbs);

				node * sentHeader = fileBysentences;
				node * wordsHeader = byWords;
				int index = 0;
				while (sentHeader != NULL && wordsHeader != NULL) {
					cell * extractedStops = NULL;
					cell * extractedVerbs = NULL;
					cell * filt= NULL;
					cell * filt2 = NULL;
					//extract the stop words and verbs 
					checkSets(paragraph(wordsHeader), stopWords , &extractedStops);
					checkSets(paragraph(wordsHeader), verbs , &extractedVerbs);
					//remove them 
					difference(paragraph(wordsHeader), extractedVerbs , &filt, NULL);
					difference(filt , extractedStops , &filt2 , NULL);

					//give each sentence a score based of the repition of its words in the paragraph

					scoringSentence(&sentHeader->pragraph , filt2);
					cell * best = mostRepeated(sentHeader->pragraph);
					if (best != NULL && best->word != NULL) {
						printf("Paragraph %d idea: %s\n" , index , best->word);
					} else {
						printf("Paragraph %d has no main idea \n" , index);
					}

					freeTree(extractedVerbs);
					freeTree(extractedStops);
					freeTree(filt);
					freeTree(filt2);
					

					sentHeader = sentHeader->next;
					wordsHeader = wordsHeader->next;
					index++;
				}

				freeList(stopWords);
				freeList(verbs);

	

			
				
				
			break;
		case 7:
			// check plagiarism between two files 
			printf("Enter paths of two files to compare, separated by space:\n");
			char input[256];
			fgets(input, 256, stdin);
			input[strcspn(input , "\n")] = '\0';
			char copy[256];
			strcpy(copy , input);
			char * file1 = strtok(copy , " ");
			char * file2 = strtok(NULL , " ");
			while(file1 == NULL || file2 == NULL){
				printf("Invalid input. Please provide two file paths.\n");
				fgets(input, 256, stdin);
				input[strcspn(input , "\n")] = '\0';
				strcpy(copy , input);
				file1 = strtok(copy , " ");
				file2 = strtok(NULL , " ");
			}
			node * file1ngrams = NULL ;
			node * file2ngrams = NULL ;
			popStructNgram(&file1ngrams , file1 ,   2);
			popStructNgram(&file2ngrams , file2 , 2);
			cell * shared = NULL ;
			
			cell * allFile1 = NULL ;
			cell * allFile2 = NULL ;
			while(file1ngrams != NULL){
				insertAll(file1ngrams->pragraph , &allFile1);
				file1ngrams = file1ngrams->next ;
			}
			while(file2ngrams != NULL){
				insertAll(file2ngrams->pragraph , &allFile2);
				file2ngrams = file2ngrams->next ;
			}
			setsIntersection(allFile1 , allFile2 , &shared , NULL);

			cell * all = NULL; 
			setsUnion(allFile1 , allFile2 , &all , NULL);
			int sharedCount = countNodes(shared);
			int allCount = countNodes(all);
			float similarity = (allCount == 0) ? 0 : ((float)sharedCount / allCount) * 100;
			printf("Shared bi-grams: %d\n", sharedCount);
			printf("Total bi-grams: %d\n", allCount);
			printf("Similarity: %.2f%%\n", similarity);
			freeTree(shared);
			freeTree(all);
			freeTree(allFile1);
			freeTree(allFile2);


			break;
	case 8:
			printf("Exiting program... Goodbye! \n");
			break;
		default:
			printf("Invalid option.\n");
	}
	if(filesHeader != NULL){
	freeFile(filesHeader);
	}
	}while(m != 8);
    return 1 ;

}