#!/usr/bin/perl -w
# NAME: fgtsdir.pl
# AIM: Given an input directory, scan, and report per age
# 2016-08-06 - FIrst cur
use strict;
use warnings;
use File::Basename;  # split path ($name,$dir,$ext) = fileparse($file [, qr/\.[^.]*/] )
use File::stat;
use Cwd;
my $os = $^O;
my $perl_dir = '/home/geoff/bin';
my $PATH_SEP = '/';
my $temp_dir = '/tmp';
if ($os =~ /win/i) {
    $perl_dir = 'C:\GTools\perl';
    $temp_dir = $perl_dir;
    $PATH_SEP = "\\";
}
unshift(@INC, $perl_dir);
require 'lib_utils.pl' or die "Unable to load 'lib_utils.pl' Check paths in \@INC...\n";
# log file stuff
our ($LF);
my $pgmname = $0;
if ($pgmname =~ /(\\|\/)/) {
    my @tmpsp = split(/(\\|\/)/,$pgmname);
    $pgmname = $tmpsp[-1];
}
my $outfile = $temp_dir.$PATH_SEP."temp.$pgmname.txt";
open_log($outfile);

# user variables
my $VERS = "0.0.5 2015-01-09";
my $load_log = 0;
my $in_file = '';
my $verbosity = 0;
my $out_file = '';
my $out_csv = $temp_dir.$PATH_SEP."tempterr.csv";
my $in_dir = '';

# ### DEBUG ###
my $debug_on = 1;
my $def_dir = 'D:\FG\terrasync';

### program variables
my @warnings = ();
my $cwd = cwd();

sub VERB1() { return $verbosity >= 1; }
sub VERB2() { return $verbosity >= 2; }
sub VERB5() { return $verbosity >= 5; }
sub VERB9() { return $verbosity >= 9; }

sub show_warnings($) {
    my ($val) = @_;
    if (@warnings) {
        prt( "\nGot ".scalar @warnings." WARNINGS...\n" );
        foreach my $itm (@warnings) {
           prt("$itm\n");
        }
        prt("\n");
    } else {
        prt( "\nNo warnings issued.\n\n" ) if (VERB9());
    }
}

sub pgm_exit($$) {
    my ($val,$msg) = @_;
    if (length($msg)) {
        $msg .= "\n" if (!($msg =~ /\n$/));
        prt($msg);
    }
    show_warnings($val);
    close_log($outfile,$load_log);
    exit($val);
}


sub prtw($) {
   my ($tx) = shift;
   $tx =~ s/\n$//;
   prt("$tx\n");
   push(@warnings,$tx);
}

sub process_in_file($) {
    my ($inf) = @_;
    if (! open INF, "<$inf") {
        pgm_exit(1,"ERROR: Unable to open file [$inf]\n"); 
    }
    my @lines = <INF>;
    close INF;
    my $lncnt = scalar @lines;
    prt("Processing $lncnt lines, from [$inf]...\n");
    my ($line,$inc,$lnn);
    $lnn = 0;
    foreach $line (@lines) {
        chomp $line;
        $lnn++;
        if ($line =~ /\s*#\s*include\s+(.+)$/) {
            $inc = $1;
            prt("$lnn: $inc\n");
        }
    }
}

# ================================
# Airports
#   with A B ... Y Z
# Directory of D:\FG\terrasync\Airports\A\0\1
#
#2016-08-06  20:32    <DIR>          .
#2016-08-06  20:32    <DIR>          ..
#2016-04-13  14:45               278 A010.groundnet.xml
#2016-04-13  14:45             1,360 A010.threshold.xml
#2016-04-13  14:45               205 A010.twr.xml
#2016-04-13  14:45               278 A011.groundnet.xml

# Models
#  with Agriculture Aircraft Airport ... Trees

# Objects
#  with e000n40 e070n30 e080n20 e080n30 e110n20 e140s40 e150s40 ...

# Terrain
#  with CHUNKS 10x10 labelled by lower left like e000n40 e070n30 e080n20 e080n30 e110n20 e140s40 e150s40 e160s50 w010n50 ...

sub bget_bucket_ll($$$) {
    my ($txt,$rlat,$rlon) = @_;
    my ($ew,$lon,$ns,$lat);
    my $res = 0;    # assume FAILED
    if ($txt =~ /^(e|w)(\d{3})(n|s)(\d{2})$/) {
        $ew = $1;
        $lon = $2;
        $ns = $3;
        $lat = $4;
        if ($ew eq 'w') {
            $lon *= -1;
        }
        if ($ns eq 's') {
            $lat *= -1;
        }
        ${$rlat} = $lat;
        ${$rlon} = $lon;
        $res = 1;   # SUCCESS
    }
    return $res;
}

###sub is_terrain_bucket($) {


my @file_array = ();
my %done_dirs = ();
my $tot_dirs = 0;
my $tot_files = 0;
my $tot_size = 0;
my $oldest_time = time();
my $youngest_time = 0;
my $oldest_file = -1;
my $youngest_file = -1;
my $max_name = 0;
sub process_in_dir($$);

sub process_in_dir($$) {
    my ($dir,$lev) = @_;
    return if (defined $done_dirs{$dir});
    if (! opendir(DIR, "$dir") ) {
        pgm_exit(1,"ERROR: Unable to open dir [$dir]\n"); 
    }
    my @files = readdir(DIR);
    closedir(DIR);
    $done_dirs{$dir} = 1;
    $tot_dirs++;
    ut_fix_directory(\$dir);
    my $isterr = ($dir =~ /(\\\/)Terrain(\\\/)/);
    my ($ff,$file,$sb,$tm,$sz,$len,$off,$ra);
    my @dirs = ();
    foreach $file (@files) {
        next if ($file eq '.');
        next if ($file eq '..');
        $ff = $dir.$file;
        if (-d $ff) {
            push(@dirs,$ff);
        } elsif (-f $ff) {
            if ($sb = stat($ff)) {
                $tm = $sb->mtime;
                $sz = $sb->size;
                $off = scalar @file_array;
                $ra = [$ff,$file,$tm,$sz];
                push(@file_array,$ra);
                $tot_size += $sz;
                $tot_files++;
                if ($tm < $oldest_time) {
                    $oldest_time = $tm;
                    $oldest_file = $off;
                }
                if ($tm > $youngest_time) {
                    $youngest_time = $tm;
                    $youngest_file = $off;
                }
                if (($tot_files % 10000) == 0 ) {
                    prt("Processed $tot_dirs dirs, got $tot_files files, ".get_nn($tot_size)." bytes...\n");
                }
                $len = length($ff);
                $max_name = $len if ($len > $max_name);
            } else {
                prtw("WARNING: Unable to stat file $ff!\n");
            }
        } else {
            prtw("WARNINGS: What is this '$ff'?\n");
        }
    }
    foreach $ff (@dirs) {
        process_in_dir($ff,$lev+1);
    }

}

sub mycmp_ascend_n2 {
   return -1 if (${$a}[2] < ${$b}[2]);
   return  1 if (${$a}[2] > ${$b}[2]);
   return  0;
}

sub get_file_line($) {
    my $ra = shift;
    my $ff = ${$ra}[0];
    my $fil = ${$ra}[1];
    my $tm = ${$ra}[2];
    my $sz = ${$ra}[3];

    $tm = lu_get_YYYYMMDD_hhmmss($tm);
    $sz = get_nn($sz);
    $sz = ' '.$sz while (length($sz) < 12);
    $ff .= ' ' while (length($ff) < $max_name);
    return "$ff $sz $tm";
}

my $head_cnt = 10;
my $tail_cnt = 10;

sub show_info() {
    my ($tm1,$tm2);
    my ($ra,$ff,$fil,$tm,$sz,$max,$cnt,$show);
    prt("Done: Got ".get_nn($tot_dirs)." dirs, ".get_nn($tot_files)." files, ".get_nn($tot_size)." bytes...\n");
    my $epock = time();
    #$tm1 = lu_get_YYYYMMDD_hhmmss($oldest_time);
    #$tm2 = lu_get_YYYYMMDD_hhmmss($youngest_time);
    $tm1 = secs_HHMMSS($epock - $oldest_time);
    $tm2 = secs_HHMMSS($epock - $youngest_time);
    $ff  = get_file_line($file_array[$oldest_file]);
    $fil = get_file_line($file_array[$youngest_file]);
    prt("From oldest: $tm1,\n$ff\nto youngest $tm2\n$fil\n");

    ##############################################
    ### Sort the array
    @file_array = sort mycmp_ascend_n2 @file_array;
    $max = scalar @file_array;
    $show = 0;
    $cnt = 0;
    my $csv = "file,size,time\n";
    foreach $ra (@file_array) {
        $ff = ${$ra}[0];
        $fil = ${$ra}[1];
        $tm = ${$ra}[2];
        $sz = ${$ra}[3];
        $csv .= "$ff,$sz,$tm\n";

        $cnt++;
        $show = 0;
        $show = 1 if ($cnt < $head_cnt);
        $show = 1 if (($max - $cnt) < $tail_cnt);
        if (VERB9() || $show) {
            $fil = get_file_line($ra);
            prt("$fil\n");
        }
    }
    rename_2_old_bak($out_csv);
    write2file($csv,$out_csv);
    prt("Written CSV list to $out_csv\n");

    #$load_log = 1;

}


#########################################
### MAIN ###
parse_args(@ARGV);
process_in_dir($in_dir,0);
show_info();
pgm_exit(0,"");
########################################

sub need_arg {
    my ($arg,@av) = @_;
    pgm_exit(1,"ERROR: [$arg] must have a following argument!\n") if (!@av);
}

sub parse_args {
    my (@av) = @_;
    my ($arg,$sarg);
    my $verb = VERB2();
    while (@av) {
        $arg = $av[0];
        if ($arg =~ /^-/) {
            $sarg = substr($arg,1);
            $sarg = substr($sarg,1) while ($sarg =~ /^-/);
            if (($sarg =~ /^h/i)||($sarg eq '?')) {
                give_help();
                pgm_exit(0,"Help exit(0)");
            } elsif ($sarg =~ /^v/) {
                if ($sarg =~ /^v.*(\d+)$/) {
                    $verbosity = $1;
                } else {
                    while ($sarg =~ /^v/) {
                        $verbosity++;
                        $sarg = substr($sarg,1);
                    }
                }
                $verb = VERB2();
                prt("Verbosity = $verbosity\n") if ($verb);
            } elsif ($sarg =~ /^l/) {
                if ($sarg =~ /^ll/) {
                    $load_log = 2;
                } else {
                    $load_log = 1;
                }
                prt("Set to load log at end. ($load_log)\n") if ($verb);
            } elsif ($sarg =~ /^o/) {
                need_arg(@av);
                shift @av;
                $sarg = $av[0];
                $out_file = $sarg;
                prt("Set out file to [$out_file].\n") if ($verb);
            } else {
                pgm_exit(1,"ERROR: Invalid argument [$arg]! Try -?\n");
            }
        } else {
            $in_dir = $arg;
            prt("Set input to [$in_dir]\n") if ($verb);
        }
        shift @av;
    }

    if ($debug_on) {
        prtw("WARNING: DEBUG is ON!\n");
        if (length($in_dir) ==  0) {
            $in_dir = $def_dir;
            prt("Set DEFAULT input to [$in_dir]\n");
        }
    }
    if (length($in_dir) ==  0) {
        pgm_exit(1,"ERROR: No input directory found in command!\n");
    }
    if (! -d $in_dir) {
        pgm_exit(1,"ERROR: Unable to find in dir [$in_dir]! Check name, location...\n");
    }
}

sub give_help {
    prt("$pgmname: version $VERS\n");
    prt("Usage: $pgmname [options] in-file\n");
    prt("Options:\n");
    prt(" --help  (-h or -?) = This help, and exit 0.\n");
    prt(" --verb[n]     (-v) = Bump [or set] verbosity. def=$verbosity\n");
    prt(" --load        (-l) = Load LOG at end. ($outfile)\n");
    prt(" --out <file>  (-o) = Write output to this file.\n");
}

# eof - template.pl