#!/usr/local/bin/perl5.7.1 -w

use File::PathConvert 'realpath';
use Digest::MD5;
use strict;

use constant NONE       => 0x00;
use constant REPORT     => 0x01;
use constant TRAVERSE   => 0x02;
use constant DIDX       => 0x04;

### set this as needed
# examples:
# use constant DEBUG => DIDX;
# use constant DEBUG => TRAVERSE;
# use constant DEBUG => TRAVERSE | DIDX;
# use constant DEBUG => REPORT | DIDX;
use constant DEBUG => TRAVERSE;

my %ignore = qw(
  .xvpics 1
  .didx   1
);

my (@craps,@incs, %opts, %crap, %dirs, %sums, %cache, %meta, $temp);


for (@ARGV) {
  if ($opts{crap}) {
    delete $opts{crap};
    push @craps, $_;
  }
  elsif (/^\//) {
    push @incs, realpath($_) if !-l $_ && -d _ && -r _ && -x _;
  }
  elsif (/^--(crap|norecurse|fixdev|fixino|fixtim|moresync)$/) {
    $opts{$1} = 1;
  }
  elsif ($_ eq "--fixall") {
    @opts{'fixdev','fixino'} = (1,1);
  }
  elsif (/^--crap=(.*)/) {
    push @craps,$1 if !-l $1 && -r _ && -w _;
  }
  elsif (!-l $_ && -d _ && -r _ && -x _) {
    push @incs, $_;
  }
}

die "$#incs(@incs) Please specify some directories\n" if ($#incs == -1);

# # # # # # # # # # # # # # # # # # # # 
# Main program code

lcrap($_) for @craps;

lookat(realpath($_)) for @incs;

unless ($opts{'moresync'}) {
  loadix($_) for keys %dirs;
  foreach my $dir (keys %dirs) {
    for (keys %{ $dirs{$dir} }) {
      gonkulate($dir,$_) if $dirs{$dir}{$_}[0] eq '0';
    }
    rend_thee($dir);
  }
}

unlink_by_key($_,"crapper") for keys %crap;
rend_thee($_) for keys %dirs;

unlink_by_key($_,"dups") for (find_md5ups());
rend_thee($_) for keys %dirs;

checkstuff();


exit;
# # # # # # # # # # # # # # # # # # # # 

sub rend_thee {
  my ($dir) = @_;
  my $name = "rend_thee";

  if (exists($dirs{$dir}) &&
      exists($meta{$dir}{nuptdate})) {
    if (!-l $dir && -d _ && -w _ && -x _ && -r _) {
      if (!-l "$dir/.didx" && -e _) {
        return unless (-f _ && -r _ && -w _);
      }
    }
    open DIDXF, ">$dir/.didx" or die "cannot open $dir/.didx: $!\n";
    print "\t$name -> SYNC $dir NUPT ($meta{$dir}{nuptdate})\n";
    for (sort keys %{ $dirs{$dir} }) {
      print DIDXF "$_\t" for (@{ $dirs{$dir}{$_} });
      print DIDXF "$_\n";
    }
  }
  delete $meta{$dir}{nuptdate};
}

sub lookat {
  my ($entry) = @_;
  my $name = "lookat";
  my (@files);

  return if exists($dirs{$entry});

  print "\t$name -> traversing $entry\n" if DEBUG & TRAVERSE;
  $dirs{$entry} = {};

  opendir DIR, $entry or die "can't open $entry: $!\n";
  for (grep !/^\.\.?$/, readdir DIR) {
    next if exists($ignore{$_});

    my $file = "$entry/$_";
    $file =~ s!//!/!g;
    
    my @stats = ( '0', (lstat $file)[0,1,7,9] );

    if (-r _ && -f _) {
      print "\t\t$name -> F $file\n" if DEBUG & REPORT;
      $dirs{$entry}{$_} = \@stats;
    }
    elsif (-r _ && -d _ && -x _) {
      print "\t\t$name -> D $file\n" if DEBUG & REPORT;
      lookat($file) unless exists($opts{norecurse});
    } 
  }
  closedir(DIR);

  if ($opts{'moresync'}) {
    loadix($entry);
    for (keys %{ $dirs{$entry} }) {
      gonkulate($entry,$_) if $dirs{$entry}{$_}[0] eq '0';
    }
    rend_thee($entry) if exists($meta{$entry}{nuptdate});
  }
}

sub lcrap {
  my ($crap) = @_;
  my $name = "load_crap";

  print "\t$name -> load ($crap)\n";
  if (! -l $crap && -e _) {
    if (-f _ && -r _) {
      #open and read, because you were given a file
      open C,"<$crap" || die "Can't open $crap: $!\n";
      while (<C>) {
        if (/^([A-Fa-f0-9]{32})\s+(\-?\d+)$/) {
          $crap{"$1:$2"}=1;
        } elsif (/^([A-Fa-f0-9]{32})\s+\d+\s+\d+\s+(\d+)\s+\d+\s+.*$/) {
          $crap{"$1:$2"}=1;
        }
      }
    } elsif (-d _ && -r _ && -w _ && -x _) {
      lcrap("$crap/.didx");
    }
  }
}

sub loadix {
  my ($dir) = @_;

  my $name="loadix";

  if (! -l "$dir/.didx" && -f _ && -r _ && -w _) {
    print "\t$name -> Loading $dir/.didx\n";

    open DIDXF, "< $dir/.didx" or die "can't open $dir/.didx: $!\n";
    #while (<DIDXF>) {
    my @didx=<DIDXF>; close DIDXF; for (@didx) {
      chomp;

      # md5sum device inode size mtime filename
      # assumes the filename does not have \n in it... ;)

      #my @line = /^([A-Fa-f0-9]+)\t(\d+)\t(\d+)\t(\d+)\t(\d+)\t(.+)$/;
      if (/^([A-Fa-f0-9]{32})\t(\d+)\t(\d+)\t(\d+)\t(\d+)\t(.+)$/) {

        unless ($dirs{$dir}{$6}) {
          # lookat() did not find the file
          # cache its didx data and move on

          print "\t$name -> (GONE) $dir/$6\n" if DEBUG & DIDX;

          $meta{$dir}{moved_to_cache}++;
          $meta{$dir}{nuptdate} = 0;

          # $2 is device, $3 is inode

          @{ $cache{$2}{$3} } = ($1,$2,$3,$4,$5,$6);
          next;
        }

        # @$rline is the stat data gotten via lookat
        my $rline = $dirs{$dir}{$6};
        my @chd;

        if ($2 != $rline->[1]) {
          if (exists($opts{fixdev})) {
            $dirs{$dir}{$6}[1] = $rline->[1];
            $meta{$dir}{fix_dev}++;
            $meta{$dir}{nuptdate} = 0;
          }
          else { push @chd, "device" }
        }

        if ($3 != $rline->[2]) {
          if (exists($opts{fixino})) {
            $dirs{$dir}{$6}[2] = $rline->[2];
            $meta{$dir}{fix_ino}++;
            $meta{$dir}{nuptdate} = 0;
          }
          else { push @chd, "inode" }
        }

        if ($5 != $rline->[4]) {
          if (exists($opts{fixtim})) {
            $dirs{$dir}{$6}[4] = $rline->[4];
            $meta{$dir}{fix_tim}++;
            $meta{$dir}{nuptdate} = 0;
          }
          else { push @chd, "mode_time" }
        }

        # We kept strings in @chd describing what all changed.

        if (@chd) {
          print "\t$name -> (CHD) $dir/$6\n" if DEBUG & DIDX;
          gonkulate($dir,$6,\@chd);
        }

        else {
          # Entry has not changed, so, update it's md5sum from cache
          print "\t$name -> (DIDX_HIT) $dir/$6\n" if DEBUG & DIDX;

          $dirs{$dir}{$6}[0] = $1;
          $sums{"${1}:${4}"}{$dir}{$6} = 1;
        }
        ############################################
        ############################################
        ############################################

      } else {
        print qq{\t$name -> CANT_PARSE($.) "$_"\n};
        $meta{$dir}{nuptdate} = 0;
        $meta{$dir}{cant_parse_line}++;
        next;
      }
    }
  }
}


sub gonkulate {
  my ($dir, $file, $comment) = @_;

  my $name = "gonkulate";
  my $f = "$dir/$file";
  my $rec = $dirs{$dir}{$file};
  my $sum;

  $meta{$dir}{nuptdate} = 0;

  if ($comment) { $name .= " reason(@$comment) " }
  else { $name .= " reason(new) " }

  if ($cache{$rec->[1]}{$rec->[2]}) {
    print "\t$name -> $f cached(${ $cache{$rec->[1]}{$rec->[2]} }[0])\n";
    $meta{$dir}{added_from_cache}++;

    ${ $dirs{$dir}{$file} }[0] = ${ $cache{$rec->[1]}{$rec->[2]} }[0];
    $sums{"$rec->[0]:$rec->[3]"}{$dir}{$file} = 1;

    return;
  }

  $meta{$dir}{indexed_new}++;

  #  Get the MD5 checksum
  print "\t$name -> $f\n";

  open FILE, $f or die "can't open $f: $!";
  binmode FILE;
  $sum = Digest::MD5->new->addfile(*FILE)->hexdigest;
  close FILE;

  $dirs{$dir}{$file}[0] = $sum;
  $sums{"${sum}:$rec->[3]"}{$dir}{$file} = 1;
}

sub unlink_by_key {
  my ($key,$act) = @_;
  my (%h,$keep);
  my $name = "unlink_by_key";

  return if (!exists($sums{$key}));

  foreach my $dir (keys %{ $sums{$key} }) {
    $h{$dirs{$dir}{$_}->[4]}{$_}{$dir}=1 for keys %{ $sums{$key}{$dir} };
  }

  foreach my $t (sort keys %h) {
    foreach my $f (sort keys %{ $h{$t} }) {
      for (sort keys %{ $h{$t}{$f} }) {
        if ($act eq "crapper" || $keep) {
          print "\t$name -> ($act) $_/$f ($t)\n";
	  unlink ("$_/$f");
          delete $sums{$key}{$_}{$f};
          delete $dirs{$_}{$f};
          $meta{$_}{nuptdate}=1;
        } else {
          print "\t$name -> (keep) $_/$f ($t)\n";
          $keep="$_/$f";
        }
        delete $h{$t}{$f}{$_};
      }
      delete $h{$t}{$f};
    }
    delete $h{$t};
  }
  undef %h;
}

sub find_md5ups {
  my @mrs;
  for my $key (keys %sums) {
    my $k;
    $k += keys %$_ for values %{ $sums{$key} };
    push @mrs,$key if $k gt 1;
  }
  return @mrs;
}

sub checkstuff {
  my ($umd5, $md5, $dirs);
  my $name = "checkstuff";

  $umd5=0;
  for (values %sums) {
    $umd5++;
    for (values %$_) {
      $md5 += values %$_;
    }
  }

  $dirs += keys %$_ for values %dirs;

  $dirs = 0 unless ($dirs);
  $md5 = 0 unless ($md5);
  print "\t$name -> MD5sums($umd5,$md5) FileDirs($dirs)\n";
}
