#!/usr/bin/perl
# Author: Alan J. Pippin
# Description: Find videos from a temporary dropbox location and merge and move them into their final destination.

use File::Copy;
use File::Basename;
use Getopt::Std;
use File::stat;
use Time::localtime;
use File::Pid;

####################################################################################################
# Configuration parameters
$mydir = `cd \$(dirname $0) 2>/dev/null; pwd`; chomp($mydir); unshift @INC,("$mydir");
# Default configuration values
require "organize_videos.conf";
# Override defaults with local customizations
if( -f "$mydir/organize_videos.conf.local") { require "organize_videos.conf.local"; }

####################################################################################################

# Sanity check
if(! -d $srcpathname) { print "-E- Can't find srcpath: $srcpathname\n"; exit 1; }
if(! -d $dstpathname) { print "-E- Can't find dstpath: $dstpathname\n"; exit 1; }
if(! -x $merge_videos_by_day) { print "-E- Can't find required script: $merge_videos_by_day\n"; exit 1; }

my %monthname2month = (
		       "Jan" => "01",
		       "Feb" => "02",
		       "Mar" => "03",
		       "Apr" => "04",
		       "May" => "05",
		       "Jun" => "06",
		       "Jul" => "07",
		       "Aug" => "08",
		       "Sep" => "09",
		       "Oct" => "10",
		       "Nov" => "11",
		       "Dec" => "12"
		       );

my %month2monthname = (
		       "01" => "Jan",
		       "02" => "Feb",
		       "03" => "Mar",
		       "04" => "Apr",
		       "05" => "May",
		       "06" => "Jun",
		       "07" => "Jul",
		       "08" => "Aug",
		       "09" => "Sep",
		       "10" => "Oct",
		       "11" => "Nov",
		       "12" => "Dec"
		       );

getopts("htvnkpfd:");

sub usage {
    print "usage: $0 [-v] [-t] [-r] [-p] [-f] [-d <dir>]\n";
    print "   -v        verbose; print file being moved (to).\n";
    print "   -t        test; print what will happen, but don't do anything\n";
    print "   -f        force it to run by ignoring the \$minage setting in organize_videos.conf\n";
    print "   -n        do not copy to dest; do not copy the resultant video files to the destination dir\n";
    print "   -k        keep the individual video files that are merged. By default, after a merge, individual video files that were merged are removed\n";
    print "   -p        only recreate video playlists, do not process any video files. Do this for each year & month of video clips in the directory specified by -d <dir>.\n";
    print "   -d <dir>  directory to recreate the playlists in. Only needed if -p option is given\n";
    return 1;
}
$SIG{'INT'} = sub {die "-E- Killed by CTRL-C\n"};

sub is_folder_empty {
    my $dirname = shift;
    opendir(my $dh, $dirname) or die "Not a directory";
    return scalar(grep { $_ ne "." && $_ ne ".." } readdir($dh)) == 0;
}

sub create_playlists {
    my ($dstdirs) = @_;
    
    foreach $dstdir (keys %{$dstdirs}) {
	print "-> Recreating playlists in: $dstdir\n";
	print "-> Creating playlists for each month & year of clips from this directory: $video_directory\n";
	opendir(VIDEODIR, "$dstdir") or die "-E- could not open: $dstdir\n";
	chdir "$dstdir" || die "-E- Unable to change directory to the dstdir: $dstdir\n";
	
	my @all_files = readdir VIDEODIR;
	closedir(VIDEODIR);
	@all_files = sort @all_files;

	print "   Removing all existing playlists from the directory\n";
	if(! defined $opt_t) { system("rm *.$playlist_extension > /dev/null 2>&1"); }
    
	foreach $file (@all_files) {
	    next if -d $file;
	    next if ($file !~ /\.avi$/i && $file !~ /\.mpg$/i && $file !~ /\.mkv$/i && $file !~ /\.3gp$/i && $file !~ /\.mov$/i && $file !~ /\.mts$/i);
	    if($file =~ /(\d\d\d\d)-(\d\d)-(\d\d)/) {
		$year = $1; $month = $2;
		print "   Adding $file to $year.$playlist_extension & $year-$month.$playlist_extension\n";
		if(! defined $opt_t) { system("echo \"$file\" >> $year.$playlist_extension"); }
		if(! defined $opt_t) { system("echo \"$file\" >> $year-$month.$playlist_extension"); }
	    } else {
		print "   Skipping $file since we can't extract the year and month from it\n"; 
	    }
	}

        # Fix the permissions
        system("chown $owner \"$dstdir/\"*.$playlist_extension");
        system("chgrp $group \"$dstdir/\"*.$playlist_extension");
        system("chmod $mode \"$dstdir/\"*.$playlist_extension");
   } 
}

# Sanity checks / Option processing
if(defined $opt_h) { usage(); exit 1; }
if(defined $opt_p) {
    if(defined $opt_d) {
	my %dstdirs = ("$opt_d",1); 
	create_playlists(\%dstdirs);
    } else {
	die "-E- You must specify the -d <dir> option when using the -p option\n"; 
    }
    exit 0;
}

# Only proceed if there are video files to organize
$video_files_found=`$find_cmd_with_mkv`;
if(!$video_files_found) { exit 0; }

# Only proceed if we are skipping this check or if the $srcpathname dir hasn't been modified in the last $minage minutes
if(! $opt_f && ((time - (stat("$srcpathname"))->mtime) < ($minage * 60))) {
  exit 0;
}

# Only one instance of this script running at a time
my $pidfile = File::Pid->new({file => "$pid_file", pid => "$$"});
exit if $pidfile->running();
$pidfile->write();

# Print the date
system("date");

# Merge videos prior to copying them over to the destination path
my $errno = 0;
my $merge_opts = "";
if(defined $opt_t) { $merge_opts .= "-t "; }
if(defined $opt_k) { $merge_opts .= "-k "; }
if(defined $opt_v) { $merge_opts .= "-v "; }
if($requantize_input_video) { $merge_opts .= ' -q'; }
if($recompress_input_video) { $merge_opts .= ' -z'; }
$errno=system("$merge_videos_by_day -s \"$srcpathname\" $merge_opts");
$errno = $errno >> 8;
if($errno) { die "-E- $merge_videos_by_day encountered some errors with exit code $errno\n"; }

# Exit now if we are not supposed to copy the resultant video files to the destination path
if(defined $opt_n) {
    $pidfile->remove();
    print "\n\n";
    exit 0;
}

# Copy the videos over to the destination path
my %dstdirs;
chdir "$srcpathname";
print "$find_mkv\n" if($opt_v);
foreach $file (`$find_mkv`) {

    chomp($file);
    $srcdir = dirname($file);
    $file = basename($file);
    $srcfile = $file;
    $ext = $file; $ext =~ s/.*\.(\S+)$/$1/; $ext = lc($ext);
    
    # Throw out files not in the current srcpath
    if((! -f "$srcfile") && (! -f "$srcdir/$srcfile")) { next; }

    # Throw out encoded files left over from a previous run
    print "srcfile: $srcfile\n";
    if($srcfile =~ /.hb.mp4/) { next; }
    
    print "Found video: srcdir: $srcdir srcfile: $srcfile ext: $ext\n" if($opt_v);

    # From the modification time of the file since we couldn't find it in the filename
    $date_modified = ctime(stat("$srcdir/$srcfile")->mtime);

    # NOTE: This file matching algorithm only applies to videos produced by merge_videos_by_day called by this script earlier
    # We just need to take those merged videos, and extract what date to call the video by under HomeVideos

    # Get the date taken from the filename
    if($srcfile =~ /^(\d+)-(\d+)-(\d+)/) {
	$year = $1;
	$month = $2;
	$day = sprintf("%02d",$3);
	$monthnum = $month;
	$monthname = lc($month2monthname{$month});
    }
    elsif($srcfile =~ /^(\d\d\d\d)(\d\d)(\d\d)/) {
        $year = $1;
        $month = $2;
        $day = sprintf("%02d",$3);
        $monthnum = $month;
        $monthname = lc($month2monthname{$month});
    }
    # Get the date taken from the source directory
    elsif($srcdir =~ /(\d+)-(\d+)-(\d+)/) {
	$year = $1;
	$month = $2;
	$day = sprintf("%02d",$3);
	$monthnum = $month;
	$monthname = lc($month2monthname{$month});
    }
    # Get the date taken from the modification time
    elsif($date_modified =~ /\S+\s+(\S+)\s+(\d+)\s+\S+\s+(\d+)/) {
	$year = $3;
	$month = $1;
	$day = sprintf("%02d",$2);
	$monthnum = $monthname2month{$month};
	$monthname = lc($month);
    } else {
	print "-E- Unable to parse year and month from this file: $srcdir/$srcfile\n";
	next;
    }

    # We are ready to pick a destination folder to put the video in
    $dstdir = $dstpathname . "/" . $year;
    $dstdirs{$dstdir} = 1;
    $dstfile = $dstdir . "/" . $year . "-" . $monthnum . "-" . $day;

    # Check for duplicate filenames at the destination
    $newfile = $dstfile . "." . $video_suffix;
    if(-e "$newfile.$ext") {
	foreach $i ($video_suffix+1 .. '999') {
	    $newfile = $dstfile . "." . sprintf("%03d",$i);;
	    if(! -e "$newfile.$ext") { last; }
	}
	$dstfile = $newfile;
    }
    $dstfile = "$newfile.$ext";

    if(defined $opt_t) {
	print "-> Moving \"$srcdir/$srcfile\" to \"$dstfile\"\n";
    } else {
	# Make sure the destination directories exist
	$errno=system("mkdir -p -m $dirmode \"$dstdir\"");
	if($errno) { print "-E- Error creating dstdir: $dstdir\n"; next; }
	# Perform the move operation from $srcdir/$srcfile -> $dstfile
	print "-> Moving \"$srcdir/$srcfile\" to \"$dstfile\"\n";
	# Make sure the dstfile doesn't exist, if it does, don't do the move
	if(! -f "$dstfile") {
	    $errno=system("mv \"$srcdir/$srcfile\" \"$dstfile\" 2>/dev/null");
	    if($errno) { print "-E- Error moving srcfile to dstfile: $srcdir/$srcfile -> $dstfile\n"; next; }
	} else {
	    print "-> Skipping \"$srcdir/$srcfile\". Destfile \"$dstfile\" already exists.\n";
	}
	# Fix the permissions
	system("chown $owner \"$dstfile\"");
	system("chgrp $group \"$dstfile\"");
	system("chmod $mode \"$dstfile\"");
    }
    
    # Check to see if there is an empty sub directory to remove
    if(($srcdir ne $srcpathname) && ($srcpathname ne ".")) { 
	if(is_folder_empty($srcdir)) { 
	    print "-> Subdir detected for videos ($srcdir != $srcpathname)\n" if($opt_v);
	    if(! defined $opt_t) { 
		$tmpdir=`mktemp`;
		system("rm $tmpdir");
		system("cp -R \"$srcdir\" $tmpdir > /dev/null 2>/dev/null");
		system("rm -rf \"$srcdir\"");
		print "-> Moved empty subdir $srcdir to $tmpdir\n" if($opt_v);
	    }
	}
    }
}

# For each destination dir we copied new content into, recreate the playlists
create_playlists(\%dstdirs);

$pidfile->remove();

print "\n\n";