"""
FindWords
  by Caligari
  with mods by Chuck

This tool can be used to find which files in a directory tree contain any
of a list of words.

The list of words to search for is provided by default in a file called
"wordlist.txt" (located in the same directory as the executable) with one
regular expression per line.

A list of filename extensions to ignore can also be provided, if needed.
That list has one extension per line (not including the "."), and is
not a regular expression.

A description of further options is available using the "-help" command-line argument.

Comments in the code explain the use of regular expressions.
"""

use System.Text.RegularExpressions


class FindWords

	var wordsFilename = ''
	var ignoreFilename = ''
	var searchDirectory = ''
	var onlyNames as bool
	var showLines as bool
	var words = SortedDictionary<of String, Regex>()
	var ignoreExtensions = List<of String>()
	var startDir as DirectoryInfo?
	var listFile as FileInfo?

	
	def main
		.wordsFilename = Path.combine(Path.getDirectoryName(CobraCore.exePath), "wordlist.txt")
		.ignoreFilename = ""
		.searchDirectory = Path.getFullPath(".")
		.onlyNames = false
		.showLines = true

		.processCommandLine
		.readRegExList
		.readExtToIgnore
		
		.listFile = FileInfo(.wordsFilename)
		.startDir = DirectoryInfo(.searchDirectory)
		
		.checkDirectory(.startDir to !)
		
		print "\nDone."


	def showSyntax
		appName = CobraCore.commandLineArgs[0]
		if appName.lastIndexOf(Path.directorySeparatorChar) > 0
			appName = appName[appName.lastIndexOf(Path.directorySeparatorChar)+1:]
		if appName.lastIndexOf(".") > 0
			appName = appName[:appName.lastIndexOf(".")]
		print "Syntax:\n[appName] \[searchDirectory\] \[-l|list listFilename\] \[-i|ignore ingorelistFilename\] \[-n|-names] \[-s|-summary] \[-h|-help]"
		print "  -l|list file    filename of the list of words to search for"
		print "  -i|ignore file  filename of an optional list of extensions for files to ignore"
		print "  -n|names        only check file and directory names"
		print "  -s|summary      only show files, not lines within files"
		print "  -h|help         show this help text"		
		CobraCore.exit(0)


	def processCommandLine
		args = CobraCore.commandLineArgs

		listArgs    = ["-l", "-list"]
		ignoreArgs  = ["-i", "-ignore"]
		nameArgs    = ["-n", "-name", "-names"]
		summaryArgs = ["-s", "-summary"]
		helpArgs    = ["-h", "-help"]
		allArgs     = listArgs.concated(ignoreArgs).concated(nameArgs).concated(summaryArgs).concated(helpArgs)
		
		lookingForIgnore = false
		lookingForList = false
		foundDir = false
		argError = false
		
		if args.count > 1
			for arg in args[1:]
				if arg in allArgs and lookingForList
					print "unable to determine filename for list of words, expected '-l filename'"
					lookingForList = false
					argError = true
				if arg in allArgs and lookingForIgnore
					print "unable to determine filename for list of ignore extensions, expected '-i filename'"
					lookingForIgnore = false
					argError = true
				
				if arg in helpArgs
					.showSyntax
				else if arg in nameArgs
					.onlyNames = true
				else if arg in summaryArgs
					.showLines = false
				else if arg in ignoreArgs
					lookingForIgnore = true
				else if arg in listArgs
					lookingForList = true
				else if arg[0] == "-"
					print "unrecognized argument [arg]"
					argError = true
				else
					if lookingForIgnore
						.ignoreFilename = arg.toString
						lookingForIgnore = false
					else if lookingForList
						.wordsFilename = arg.toString
						lookingForList = false						
					else if not foundDir  # must be the directory to look in
						.searchDirectory = arg.toString
						foundDir = true
					else  # already found directory
						print "more than one directory provied on commandline, expected 'directory'"
						argError = true

		if argError
			print
			.showSyntax


	def readRegExList		
		try
			using wordsFile = StreamReader(.wordsFilename)

				wordLine = wordsFile.readLine
				
				while wordLine
					# We can tell if there is a word on a line using an
					# inline regular expression:
					#   Regex.match(textToSearch, regularExpression)
					# The textToSearch can be a hard-coded string,
					# but most often it will be a String.
					# The regularExpression is a string (hard-coded
					# or not) that follows the regular expression
					# syntax.
					wordMatch = Regex.match(wordLine, r".+")
					
					# The return from a match() call is a Match class
					# object. The success property tells us whether the
					# search located what we were looking for.
					# The toString method gives us the resulting subString.
					if wordMatch.success
						# We can create a Regex object which can later be
						# used to execute a search with a given regular
						# expression. In this case we are setting two
						# options (ignoring case in the search we are
						# creating, and pre-compiling the search, as we
						# may be using it many times).
						# Note that here we are saving the resulting
						# Regex object to a Dictionary for later use.
						# We could just as easily save the string itself,
						# but this way we only pay the Regex creation cost
						# once, rather than every time we carry out the
						# search.
						.words[wordMatch.toString] = Regex(wordMatch.toString, RegexOptions(Compiled, IgnoreCase))
						
					wordLine = wordsFile.readLine
		catch ioe as IOException
			.reportError(.wordsFilename, ioe)
			return
		print "\nFound [.words.count] search words.\n"


	def readExtToIgnore
		# optionally find extensions to ignore
		if .ignoreFilename.length > 0
			try
				using ignoreFile = StreamReader(.ignoreFilename)
					ignoreLine = ignoreFile.readLine					
					while ignoreLine
						if ignoreLine.length > 0
							.ignoreExtensions.add("." + ignoreLine.trim)
						ignoreLine = ignoreFile.readLine
			catch ioe as IOException
				.reportError(.ignoreFilename, ioe)
				return
			print "\nFound [.ignoreExtensions.count] ignored extenstions.\n"


	def checkDirectory(curDir as DirectoryInfo)
		if not curDir.exists
			print "Unable to find search directory [curDir.fullName]"
			return
		
		# print "Checking [curDir.fullName]..."
		
		foundWords = List<of String>()

		for word, wordMatch in .words
			# check directory name
			# Here we use a regular expression match
			# to determine whether the directory names have
			# any of the words we are looking for.
			# Each directory name is passed to the match
			# method call made on each of the Regex objects
			# in the dictionary we created earlier.
			dirNameCheck = wordMatch.match(curDir.name) 

			if dirNameCheck.success
				foundWords.add(word) 
				
		if foundWords.count
			print "[curDir.fullName]: directory name may have [foundWords]"
						
		# check files
			
		for subFile in curDir.getFiles
			# Note that here we check if the file we are about
			# to look at has a name which matches our list of words
			# or an extension we are ignoring. Neither of these
			# tests use regular expressions, although we could
			# use the same scheme for the ignore extensions, if
			# we wanted to support regular expressions there as well.
			if subFile.fullName == .listFile.fullName or subFile.extension in .ignoreExtensions
				continue
			.checkFile(subFile, curDir)

		for subDir in curDir.getDirectories
			.checkDirectory(subDir)


	def checkFile(curFile as FileInfo, curDir as DirectoryInfo)
		if not curFile.exists
			print "Unable to find file [curFile.fullName]"
			return
			
		# check filename
		foundWords = List<of String>()

		for word, wordMatch in .words
			# Here we use a regular expression match
			# to determine whether the filename has
			# any of the words we are looking for.
			# The name is passed to the match method
			# call made on each of the Regex objects
			# in the dictionary we created earlier.
			fileNameCheck = wordMatch.match(curFile.name) 

			if fileNameCheck.success
				foundWords.add(word) 
				
		if foundWords.count
			print "[curFile.fullName]: file name may have [foundWords]"
			
		if .onlyNames
			return
			
		# check contents
		try
			openFile = StreamReader(curFile.fullName)
		catch ioe as IOException
			.reportError(curFile.fullName, ioe)
			return
		
		if .showLines
			try
				lineNum, curLine = 1, openFile.readLine
				while curLine
					foundWords = List<of String>()
	
					for word, wordMatch in .words
						# Finally, we use a regular expression match
						# on the contents of each file for each
						# of the words we want to find. We do this
						# check for each line in the file, so that
						# we can report the findings by line, if we
						# want to do so.
						curLineCheck = wordMatch.match(curLine)
	
						if curLineCheck.success
							foundWords.add(word) 
	
					if foundWords.count
						print "[curFile.fullName]([lineNum]) has [foundWords]"
	
					curLine = openFile.readLine
					lineNum += 1
			catch ioe as IOException
				.reportError(curFile.fullName, ioe)
				return
		else  # not show lines
			# When we don't need to report each line in a file
			# we read the entire contents into a "line" and
			# run the same regular expression match on it.
			try
				curLine = openFile.readToEnd
			catch ioe as IOException
				.reportError(curFile.fullName, ioe)
				return
			foundWords = List<of String>()
			for word, wordMatch in .words
				curLineCheck = wordMatch.match(curLine)
				if curLineCheck.success
					foundWords.add(word) 
			if foundWords.count
				print "[curFile.fullName] has [foundWords]"

		openFile.close


	def reportError(fileName, exc as Exception)
		print 'Error reading "[fileName]":'
		print exc.message
		print 'Run with -h for options.'