#!/vol/local/perl

# compare duplicate files in different directories
# gss.tar, gss.red, gssa.log (GSS) on dka200,300,400,600,700
# compare all.tar, bck.lst, bcka.log (BCK) on dka400,500

# setenv INV $MDOCS/census/tar2seedis/inventory

# $MDOCS/census/tar2seedis/inventory/dupfile.pl 2/25/97
# $INV/dupfile.pl

# make dupfile.txt from dka*.lst
# example:
#	rlogin parep2.lbl.gov -l merrill
#	cd $MDOCS/census/tar2seedis/inventory
#	dupfile.pl >dupfile.txt

# output format:
# seq	tapeno	format	tarfile	lstfile	logfile		ndisks	nfiles
# 1	12345	gss	gss.tar	gss.red	gssa.log	2	8
# 1	12345	dka200	m nnn	m nnn	m nnn
# 1	12345	dka300	m nnn	m nnn	m nnn
#
# 2	56789	bck	all.tar	bck.lst	bcka.log 	2	8
# 2	56789	dka400	m nnn	m nnn	m nnn
# 2	56789	dka500	m nnn	m nnn	m nnn
#
# data structures:
# $tapeno e.g. "12345" = tape number
# $format{$tapeno} e.g. "gss" or "tar" or "unk"
# $ndisks{$tapeno} e.g. 2 = number of disks for this tapeno (should be <=3)
# $nfiles{$tapeno} e.g. 8 = number of ordinary files for this tapeno

# $disk1{$tapeno} e.g. "dka200" first disk for this tapeno
# $disk2{$tapeno} e.g. "dka300" second disk for this tapeno

# $tarfile{$tapeno} e.g. "gss.tar" or "all.tar"
# $lstfile{$tapeno} e.g. "gss.red" or "bck.lst"
# $logfile{$tapeno} e.g. "gssa.log" or "bcka.log"

# $tapedisk e.g. "12345_dka200" = concatenated tapeno and disk

# number of VMS file versions
# $tarversions{$tapedisk} e.g. m
# $lstversions{$tapedisk} e.g. m
# $logversions{$tapedisk} e.g. m

# $tarblocks{$tapedisk} e.g. nnn
# $lstblocks{$tapedisk} e.g. nnn
# $logblocks{$tapedisk} e.g. nnn

#--------------------------------------------
# logic flow:
# 1. read disks in turn. store everything{$tapedisk},  everything{$tapeno}
# 2. loop over tapeno
#	{
#	print title line: $tapeno, $format{$tapeno}, $...file{$tapeno}
#	loop over $ndisks{$tapeno}
#		{
#		get $disk = $diski{$tapeno}
#		calculate $tapedisk = $tapeno . ' ' . $disk
#		get and print everything{$tapedisk}
#		}
#	}
#--------------------------------------------

#output on STDOUT

foreach $i (2..7)
	{
	$disk = 'dka' . $i . '00' ;
	$file = 'dka' . $i . '00.lst' ;
	open (INFILE, $file);
	# read input file completely
	while (<INFILE>)
		{
		chop;

		# contents of input line

		# directory file
		if (/^DKA/ && /\[SEEDIS.MSS\]\d\d\d\d\d\.DIR/)
			{
			$dirfile = $_ ;
			$dirfiles++ ;
			$ordfile = '' ;
			$tapeno = substr ($dirfile, 19, 5);
			$tapedisk = $tapeno . '_' . $disk ;
			# increment counter $ndisks{$tapeno} 
			$ndisks{$tapeno}++ ;
			# store $disk1{$tapeno} and $disk2{$tapeno}
			if ($ndisks{$tapeno}==1)
				{
				$disk1{$tapeno} = $disk ;
				}
			elsif ($ndisks{$tapeno}==2)
				{
				$disk2{$tapeno} = $disk ;
				}
			}
		# ordinary file
		elsif (/^DKA/ && /\[SEEDIS.MSS.\d\d\d\d\d\]/)
			{
			$dirfile = '' ;
			$ordfile = $_ ;
			$tapeno = substr ($ordfile, 19, 5);
			$tapedisk = $tapeno . '_' . $disk ;
			# increment counter $nfiles{$tapeno} 
			$nfiles{$tapeno}++ ;

			if ($ordfile =~ /GSS/)
				{
				$format{$tapeno} = 'gss' ;
				$tarfile{$tapeno} = 'gss.tar' ;
				$lstfile{$tapeno} = 'gss.red' ;
				$logfile{$tapeno} = 'gssa.log' ;
				}
			elsif ($ordfile =~ /BCK/ || $ordfile =~ /ALL.TAR/)
				{
				$format{$tapeno} = 'bck' ;
				$tarfile{$tapeno} = 'all.tar' ;
				$lstfile{$tapeno} = 'bck.lst' ;
				$logfile{$tapeno} = 'bcka.log' ;
				}
			}
		# directory total, or blank line
		elsif (/^Total of/ || /^$/)
			{
			$dirfile = '' ;
			$ordfile = '' ;
			$tapedisk = '' ;
			}
		# neither - a line with number of blocks
		else
			{
			if ($ordfile ne '')
				{
				($blocks, $date, $time) = split(' ', $_) ;
				#print $tapedisk . ' '
				#. $ordfile . ' '
				#. $blocks . ' '
				#. $date . ' '
				#. $time . ' '
				#. "\n" ;

				if ($ordfile =~ /GSS.TAR/ ||
				    $ordfile =~ /ALL.TAR/ )
					{
					$tarversions{$tapedisk}++;
					$tarblocks{$tapedisk} += $blocks;
					}
				elsif ($ordfile =~ /GSS.RED/ ||
				       $ordfile =~ /BCK.LST/ )
					{
					$lstversions{$tapedisk}++;
					$lstblocks{$tapedisk} += $blocks;
					}
				elsif ($ordfile =~ /GSSA.LOG/ ||
				       $ordfile =~ /BCKA.LOG/ )
					{
					$logversions{$tapedisk}++;
					$logblocks{$tapedisk} += $blocks;
					}
				}
			}
		}
	close (INFILE);
	}

# if $ndisks > 1, print % format, %ndisks and %nfiles, sorted by key $tapeno

foreach $key (sort(keys %ndisks))
	{
	if ($ndisks{$key} > 1)
		{
		$i++ ;
		print $i . ' ' . $key
		. ' ' . $format{$key}
		. ' ' . $tarfile{$key}
		. ' ' . $lstfile{$key}
		. ' ' . $logfile{$key}
		. ' ' . $ndisks{$key} 
		. ' ' . $nfiles{$key}
		. "\n" ;

		$tapedisk1 = $key . '_' . $disk1{$key} ;
		$tapedisk2 = $key . '_' . $disk2{$key} ;

		#replace blanks with zero
		if ($tarversions{$tapedisk1} eq '')
			{
			$tarversions{$tapedisk1} = 0 ;
			}
		if ($tarblocks{$tapedisk1} eq '')
			{
			$tarblocks{$tapedisk1} = 0 ;
			}
		if ($lstversions{$tapedisk1} eq '')
			{
			$lstversions{$tapedisk1} = 0 ;
			}
		if ($lstblocks{$tapedisk1} eq '')
			{
			$lstblocks{$tapedisk1} = 0 ;
			}
		if ($logversions{$tapedisk1} eq '')
			{
			$logversions{$tapedisk1} = 0 ;
			}
		if ($logblocks{$tapedisk1} eq '')
			{
			$logblocks{$tapedisk1} = 0 ;
			}
		if ($tarversions{$tapedisk2} eq '')
			{
			$tarversions{$tapedisk2} = 0 ;
			}
		if ($tarblocks{$tapedisk2} eq '')
			{
			$tarblocks{$tapedisk2} = 0 ;
			}
		if ($lstversions{$tapedisk2} eq '')
			{
			$lstversions{$tapedisk2} = 0 ;
			}
		if ($lstblocks{$tapedisk2} eq '')
			{
			$lstblocks{$tapedisk2} = 0 ;
			}
		if ($logversions{$tapedisk2} eq '')
			{
			$logversions{$tapedisk2} = 0 ;
			}
		if ($logblocks{$tapedisk2} eq '')
			{
			$logblocks{$tapedisk2} = 0 ;
			}

		print ' ' . $tapedisk1 .
		' ' . $tarversions{$tapedisk1} .
		' ' . $tarblocks{$tapedisk1} .
		' ' . $lstversions{$tapedisk1} .
		' ' . $lstblocks{$tapedisk1} .
		' ' . $logversions{$tapedisk1} .
		' ' . $logblocks{$tapedisk1} .
		"\n" ;

		print ' ' . $tapedisk2 .
		' ' . $tarversions{$tapedisk2} .
		' ' . $tarblocks{$tapedisk2} .
		' ' . $lstversions{$tapedisk2} .
		' ' . $lstblocks{$tapedisk2} .
		' ' . $logversions{$tapedisk2} .
		' ' . $logblocks{$tapedisk2} .
		"\n" ;

		print "\n" ;
		}
	}