sub BackToForwardSlash
{
	my( $path ) = shift;
	$path =~ s,\\,/,g;
	return $path;
}

sub RemoveFileName
{
	my( $in ) = shift;
	$in = &BackToForwardSlash( $in );
	$in =~ s,/[^/]*$,,;
	return $in;
}

sub RemovePath
{
	my( $in ) = shift;
	$in = &BackToForwardSlash( $in );
	$in =~ s,^(.*)/([^/]*)$,$2,;
	return $in;
}

sub MakeDirHier
{
	my( $in ) = shift;
#	print "MakeDirHier( $in )\n";
	$in = &BackToForwardSlash( $in );
	my( @path );
	while( $in =~ m,/, ) # while $in still has a slash
	{
		my( $end ) = &RemovePath( $in );
		push @path, $end;
#		print $in . "\n";
		$in = &RemoveFileName( $in );
	}
	my( $i );
	my( $numelems ) = scalar( @path );
	my( $curpath );
	for( $i = $numelems - 1; $i >= 0; $i-- )
	{
		$curpath .= "/" . $path[$i];
		my( $dir ) = $in . $curpath;
		if( !stat $dir )
		{
#			print "mkdir $dir\n";
			mkdir $dir, 0777;
		}
	}
}

sub FileExists
{
	my $filename = shift;
	my @statresult = stat $filename;
	my $iswritable = @statresult != 0;
	return $iswritable;
}

sub MakeFileWritable
{
	my $filename = shift;
	if ( &FileExists( $filename ) )
	{
		chmod 0666, $filename || die;
	}
}

sub MakeFileReadOnly
{
	my $filename = shift;
	chmod 0444, $filename || die;
}

# Run a command and get stdout and stderr to an array
sub RunCommand
{
	my $cmd = shift;
#	print STDERR "command: $cmd\n";
	system "$cmd > cmdout.txt 2>&1" || die;
	local( *FILE );
	open FILE, "<cmdout.txt" || die;
	my @output = <FILE>;
#	print STDERR "command output: @output\n";
	close FILE;
	unlink "cmdout.txt" || die;
	return @output;
}

sub PerforceEditOrAdd
{
	return;
	my $filename = shift;
	my $changelistarg = shift;

	# Is the file on the client?
	my $cmd = "p4 fstat \"$filename\"";
	my @p4output = &RunCommand( $cmd );
	my $p4output = join "", @p4output;
	if( $p4output =~ m/no such file/ )
	{
		# not on client. . add
		my $cmd = "p4 add $changelistarg $filename";
		my @p4output = &RunCommand( $cmd );
		my $p4output = join "", @p4output;
		if( $p4output =~ m/opened for add/ )
		{
			print $p4output;
			return;
		}
		print "ERROR: $p4output";
		return;
	}

	# The file is known to be on the client at this point.

	# Is it open for edit?
	if( $p4output =~ m/action edit/ )
	{
		# Is is open for edit, let's see if it's still different.
		# check for opened files that are not different from the revision in the depot.
		my $cmd = "p4 diff -sr \"$filename\"";
		my @p4output = &RunCommand( $cmd );
		my $outputstring = join "", @p4output;
		# check for empty string
		if( !( $outputstring =~ m/^\s*$/ ) )
		{
			my $cmd = "p4 revert \"$filename\"";
			my @p4output = &RunCommand( $cmd );
			my $outputstring = join "", @p4output;
			print $outputstring;
			return;
		}
	}

	# check for unopened files that are different from the revision in the depot.
	my $cmd = "p4 diff -se \"$filename\"";
	my @p4output = &RunCommand( $cmd );
	my $outputstring = join "", @p4output;
	# check for empty string
	if( $outputstring =~ m/^\s*$/ )
	{
		&MakeFileReadOnly( $filename );
		return;
	}

	# We need to edit the file since it is known to be different here.
	my $cmd = "p4 edit $changelistarg \"$filename\"";
	my @p4output = &RunCommand( $cmd );

	my $line;
	foreach $line ( @p4output )
	{
		if( $line =~ m/not on client/ )
		{
			#print "notonclient...";
			print "ERROR: @p4output\n";
			return;
		}
		if( $line =~ m/currently opened for edit/ )
		{
			return;
		}
		if( $line =~ m/opened for edit/ )
		{
			print $line;
		}
	}
}

sub FileIsWritable
{
	local( $filename ) = shift;
	local( @statresult ) = stat $filename;
	local( $mode, $iswritable );
	$mode = oct( $statresult[2] );
	$iswritable = ( $mode & 2 ) != 0;
	return $iswritable;
}

sub TouchFile
{
	my $filename = shift;
	if( !&FileExists( $filename ) )
	{
		if( !open FILE, ">$filename" )
		{
			die;
		}
		close FILE;
	}
	my $now = time;
	local( *FILE );
	utime $now, $now, $filename;
}

sub FileExistsInPerforce
{
	my $filename = shift;
	my @output = &RunCommand( "p4 fstat $filename" );
	my $line;
	foreach $line (@output)
	{
		if( $line =~ m/no such file/ )
		{
			return 0;
		}
	}
	return 1;
}

sub PerforceWriteFile
{
	my $filename = shift;
	my $filecontents = shift;
#	my $changelistname = shift;
	
	# Get the changelist number for the Shader Auto Checkout changelist. Will create the changelist if it doesn't exist.
#	my $changelistnumber = `valve_p4_create_changelist.cmd . \"$changelistname\"`;
	# Get rid of the newline
#	$changelistnumber =~ s/\n//g;

#	my $changelistarg = "";
#	if( $changelistnumber != 0 )
#	{
#		$changelistarg = "-c $changelistnumber"
#	}

	# Make the target vcs writable if it exists
	MakeFileWritable( $filename );

	# Write the file.
	local( *FP );
	open FP, ">$filename";
	print FP $filecontents;
	close FP;

	# Do whatever needs to happen with perforce for this file.
#	&PerforceEditOrAdd( $filename, $changelistarg );
}

sub WriteFile
{
	my $filename = shift;
	my $filecontents = shift;
	
	# Make the target vcs writable if it exists
	MakeFileWritable( $filename );

	# Write the file.
	local( *FP );
	open FP, ">$filename";
	print FP $filecontents;
	close FP;
}

sub PrintCleanPerforceOutput
{
	my $line;
	while( $line = shift )
	{
		if( $line =~ m/currently opened/i )
		{
			next;
		}
		if( $line =~ m/already opened for edit/i )
		{
			next;
		}
		if( $line =~ m/also opened/i )
		{
			next;
		}
		if( $line =~ m/add of existing file/i )
		{
			next;
		}
		print $line;
	}
}

# HACK!!!!  Need to pass something in to do this rather than hard coding.
sub NormalizePerforceFilename
{
	my $line = shift;

	# remove newlines.
	$line =~ s/\n//;
	# downcase.
	$line =~ tr/[A-Z]/[a-z]/;
	# backslash to forwardslash
	$line =~ s,\\,/,g;

	# for inc files HACK!
	$line =~ s/^.*(fxctmp9.*)/$1/i;
	$line =~ s/^.*(vshtmp9.*)/$1/i;

	# for vcs files. HACK!
	$line =~ s,^.*game/platform/shaders/,,i;

	return $line;
}

sub MakeSureFileExists
{
	local( $filename ) = shift;
	local( $testexists ) = shift;
	local( $testwrite ) = shift;

	local( @statresult ) = stat $filename;
	if( !@statresult && $testexists )
	{
		die "$filename doesn't exist!\n";
	}
	local( $mode, $iswritable );
	$mode = oct( $statresult[2] );
	$iswritable = ( $mode & 2 ) != 0;
	if( !$iswritable && $testwrite )
	{
		die "$filename isn't writable!\n";
	}
}

sub LoadShaderListFile_GetShaderType
{
	my $shadername = shift;
	my $shadertype;
	if( $shadername =~ m/\.vsh/i )
	{
		$shadertype = "vsh";
	}
	elsif( $shadername =~ m/\.psh/i )
	{
		$shadertype = "psh";
	}
	elsif( $shadername =~ m/\.fxc/i )
	{
		$shadertype = "fxc";
	}
	else
	{
		die;
	}
	return $shadertype;
}

sub LoadShaderListFile_GetShaderSrc
{
	my $shadername = shift;
	if ( $shadername =~ m/^(.*)-----/i )
	{
		return $1;
	}
	else
	{
		return $shadername;
	}
}

sub LoadShaderListFile_GetShaderBase
{
	my $shadername = shift;
	if ( $shadername =~ m/-----(.*)$/i )
	{
		return $1;
	}
	else
	{
		my $shadertype = &LoadShaderListFile_GetShaderType( $shadername );
		$shadername =~ s/\.$shadertype//i;
		return $shadername;
	}
}

sub LoadShaderListFile
{
	my $inputbase = shift;

	my @srcfiles;
	&MakeSureFileExists( "$inputbase.txt", 1, 0 );

	open SHADERLISTFILE, "<$inputbase.txt" || die;
	my $line;
	while( $line = <SHADERLISTFILE> )
	{
		$line =~ s/\/\/.*$//;	# remove comments "//..."
		$line =~ s/^\s*//;		# trim leading whitespace
		$line =~ s/\s*$//;		# trim trailing whitespace
		next if( $line =~ m/^\s*$/ );
		if( $line =~ m/\.fxc/ || $line =~ m/\.vsh/ || $line =~ m/\.psh/ )
		{
			my $shaderbase = &LoadShaderListFile_GetShaderBase( $line );
			
			if( $ENV{"DIRECTX_FORCE_MODEL"} =~ m/^30$/i )	# forcing all shaders to be ver. 30
			{
				my $targetbase = $shaderbase;
				$targetbase =~ s/_ps2x/_ps30/i;
				$targetbase =~ s/_ps20b/_ps30/i;
				$targetbase =~ s/_ps20/_ps30/i;
				$targetbase =~ s/_vs20/_vs30/i;
				$targetbase =~ s/_vsxx/_vs30/i;
				push @srcfiles, ( $line . "-----" . $targetbase );
			}
			else
			{
   				if( $shaderbase =~ m/_ps2x/i )
				{
					my $targetbase = $shaderbase;
					$targetbase =~ s/_ps2x/_ps20/i;
					push @srcfiles, ( $line . "-----" . $targetbase );
					
					$targetbase = $shaderbase;
					$targetbase =~ s/_ps2x/_ps20b/i;
					push @srcfiles, ( $line . "-----" . $targetbase );
				}
				elsif( $shaderbase =~ m/_vsxx/i )
				{
					my $targetbase = $shaderbase;
					$targetbase =~ s/_vsxx/_vs20/i;
					push @srcfiles, ( $line . "-----" . $targetbase );
				}
				else
				{
					push @srcfiles, ( $line . "-----" . $shaderbase );
				}
			}
		}
	}
	close SHADERLISTFILE;
	return @srcfiles;
}

sub ReadInputFileWithIncludes
{
	local( $filename ) = shift;
#	print STDERR "ReadInputFileWithIncludes: $filename\n";

	local( *INPUT );
	local( $output );

#	print STDERR "before open\n";
	open INPUT, "<$filename" || die;
#	print STDERR "after open\n";

	local( $line );
	while( $line = <INPUT> )
	{
#		print STDERR $line;
		if( $line =~ m/\#include\s+\"(.*)\"/i )
		{
			$output.= ReadInputFileWithIncludes( $1 );
		}
		else
		{
			$output .= $line;
		}
	}

	close INPUT;
	return $output;
}

sub GetCRCFromSourceFile
{
	my $filename = shift;
	my $data = &ReadInputFileWithIncludes( $filename );
#	print STDERR $data;
	$crc = crc32( $data );
#	print STDERR "GetCRCFromSourceFile: $crc\n";
	return $crc;
}

sub GetCRCFromVCSFile
{
	my $filename = shift;
#	print STDERR "GetCRCFromVCSFile $filename\n";
	local( *FP );
	open FP, "<$filename" || die "GetCRCFromVCSFile: can't open file $filename\n";
	binmode( FP );

	# unpack arguments
	my $sInt = "i";
	my $uInt = "I";
	if ( ( $filename =~ m/\.360\./ ) || ( $filename =~ m/\.ps3\./ ) )
	{
		# Change arguments to "big endian long"
		$sInt = "N";
		$uInt = "N";
	}

	my $header;
	read FP, $header, 7 * 4 || die "updateshaders.pl:GetCRCFromVCSFile: can't read header for $filename\n";
	my $version,$numCombos,$numDynamicCombos,$flags,$centroidMask,$refSize,$crc;
	($version,$numCombos,$numDynamicCombos,$flags,$centroidMask,$refSize,$crc) = unpack "$sInt$sInt$sInt$uInt$uInt$uInt$uInt", $header;
	unless( $version == 4 || $version == 5 || $version == 6 )
	{
		print STDERR "ERROR: GetCRCFromVCSFile: $filename is version $version\n";
		return 0;
	}
#	print STDERR "version: $version\n";
#	print STDERR "numCombos: $numCombos\n";
#	print STDERR "numDynamicCombos: $numDynamicCombos\n";
#	print STDERR "flags: $flags\n";
#	print STDERR "centroidMask: $centroidMask\n";
#	print STDERR "refSize: $refSize\n";
#	print STDERR "GetCRCFromVCSFile: $crc\n";
	close( FP );
	return $crc;
}

sub CheckCRCAgainstTarget
{
	my $srcFileName = shift;
	my $vcsFileName = shift;
	my $warn = shift;
	
	# Make sure both files exist.
#	print STDERR "$srcFileName doesn't exist\n" if( !( -e $srcFileName ) );
#	print STDERR "$vcsFileName doesn't exist\n" if( !( -e $vcsFileName ) );
	if( !( -e $srcFileName ) )
	{
		if( $warn )
		{
			print "$srcFileName missing\n";
		}
		return 0;
	}
	if( !( -e $vcsFileName ) )
	{
		if( $warn )
		{
			print "$vcsFileName missing\n";
		}
		return 0;
	}
#	print STDERR "CheckCRCAgainstTarget( $srcFileName, $vcsFileName );\n";
#	print STDERR "vcsFileName: $vcsFileName\n";
#	print STDERR "vcsFileName: $srcFileName\n";
	my $vcsCRC = &GetCRCFromVCSFile( $vcsFileName );
	my $srcCRC = &GetCRCFromSourceFile( $srcFileName );
	if( $warn && ( $vcsCRC != $srcCRC ) )
	{
		print "$vcsFileName checksum ($vcsCRC) != $srcFileName checksum: ($srcCRC)\n";
	}
	
#	return 0; # use this to skip crc checking.
#	if( $vcsCRC == $srcCRC )
#	{
#		print STDERR "CRC passed for $srcFileName $vcsFileName $vcsCRC\n";
#	}
	return $vcsCRC == $srcCRC;
}

1;