#!/usr/bin/perl
use strict;
use warnings;

my $file = $ARGV[0] or die "No file specified";
my $outdir = $ARGV[1] or die "no outdir specified";
my $weighted = (exists $ARGV[2] && $ARGV[2]) ? 1 : 0;
mkdir $outdir unless (-e $outdir);


my %scores = ();
my %power = ();
my %weird = ();
my %teamCnt = ();
my %volatile = ();

printf "Weighted\n" if ($weighted);
printf "Unweighted\n" unless ($weighted);

open(DELTAS, '>', "$outdir/deltas.txt") or die "Failed to open deltas.txt";

sub read_csv($) {
	my $file = shift;
	open(DATA, '<', $file) or die "could not open $file";
	my $header = <DATA>;
	chomp $header;
	my ($homeTeam, $homeScore, $awayTeam, $awayScore) = (0, 0, 0, 0);
	my @fields = split(/,\s*/, $header);
	for my $i (0 .. $#fields) {
		if ($fields[$i] =~ /home_team/i) {
			$homeTeam = $i;
		}
		if ($fields[$i] =~ /away_team/i) {
			$awayTeam = $i;
		}
		if ($fields[$i] =~ /home_points/i) {
			$homeScore = $i;
		}
		if ($fields[$i] =~ /away_points/i) {
			$awayScore = $i;
		}
	}
	my $i = 0;
	while (my $line = <DATA>){
		chomp $line;
		@fields = split(/,\s*/, $line);
		next if ($fields[$homeScore] eq '');
		$scores{$i}{'t1'} = $fields[$homeTeam];
		$scores{$i}{'t1s'} = $fields[$homeScore];
		$teamCnt{$fields[$homeTeam]} = (exists $teamCnt{$fields[$homeTeam]}) ? $teamCnt{$fields[$homeTeam]} + 1 : 1;

		$scores{$i}{'t2'} = $fields[$awayTeam];
		$scores{$i}{'t2s'} = $fields[$awayScore];
		$teamCnt{$fields[$awayTeam]} = (exists $teamCnt{$fields[$awayTeam]}) ? $teamCnt{$fields[$awayTeam]} + 1 : 1;

		$i++;
	}

	#foreach my $tm (sort { $teamCnt{$b} <=> $teamCnt{$a} } (keys %teamCnt)){
		# DBG missing data issues
		#print "$teamCnt{$tm} $tm\n";
	#}

	open(REMOVED, '>', "$outdir/removed.txt") or die "couldn't open removed.";
	# Remove teams who have too few connections to the dataset (2 or fewer)
	my $removed;
	do {
		$removed = 0;
		foreach my $team (keys %teamCnt) {
			if ($teamCnt{$team} <= 3) {
				#Debug print to let us know if any team has 3 or fewer
				if ($teamCnt{$team} >= 3) {
					print "$team\n";
					next;
				}
				foreach my $matchup (keys %scores) {
					#next unless (exists $scores{$matchup});
					if ($scores{$matchup}{'t1'} eq $team or $scores{$matchup}{'t2'} eq $team) {
						$teamCnt{$scores{$matchup}{'t2'}}--;
						$teamCnt{$scores{$matchup}{'t1'}}--;
						delete $scores{$matchup};
						$removed++;
					}				}
				delete $teamCnt{$team} unless ($teamCnt{$team} >= 1);
				print REMOVED "Removed $team\n";
			}
		}
	} while ($removed > 0);
	close(REMOVED);

	#foreach my $tm (sort { $teamCnt{$b} <=> $teamCnt{$a} } (keys %teamCnt)){
		# DBG missing data issues
		#print "$teamCnt{$tm} $tm\n";
	#}

}

sub calculate_importance($$) {
	my ($powerDiff, $scoreDiff) = @_;
	return 1 unless ($weighted);
	if ($scoreDiff < 0) {
		# It's easier to think from the perspective of the winner
		$powerDiff = 0 - $powerDiff;
		$scoreDiff = 0 - $scoreDiff;
	}
	# upsets of a certain caliber are always of normal importance.
	# NOTE! This can cause flip-flopping behavior, check deltas.txt to ensure it resolves to 0.
	#if ($powerDiff < -5) {
	#	return 1;
	#}
	# by capping at this point value we ensure nobody will get fewer power for scoring more.
	if ($scoreDiff >= 50){
		return .5;
	}
	# Calculate importance of game which decreases as blowout status goes up.
	return (1 - (($scoreDiff)/100));
}

sub calculate_deltas($$$$){
	my ($t1Power, $t2Power, $scoreDiff, $velocity) = @_;
	# scoreDiff = t1 - t2, so t1 should go up if they win big
	my $t1Target = $t2Power + $scoreDiff;
	my $t2Target = $t1Power - $scoreDiff;
	$velocity = $velocity* calculate_importance($t1Power - $t2Power, $scoreDiff);
	return ((($t1Target-$t1Power)*$velocity),(($t2Target-$t2Power)*$velocity));
}

sub init_power() {
	foreach my $i (keys %scores) {
		$power{$scores{$i}{'t1'}} = 100;
		$power{$scores{$i}{'t2'}} = 100;
	}
}

sub run_round($) {
	my ($velocity) = @_;
	my %new_power = %power;
	foreach my $i (keys %scores) {
		my $t1p = $power{$scores{$i}{'t1'}};
		my $t2p = $power{$scores{$i}{'t2'}};
		my $diff = $scores{$i}{'t1s'} - $scores{$i}{'t2s'};
		my ($d1, $d2) = calculate_deltas($t1p, $t2p, $diff, $velocity);
		$new_power{$scores{$i}{'t1'}} += $d1;
		$new_power{$scores{$i}{'t2'}} += $d2;
	}
	my $delta = 0;
	foreach my $tm (keys %power) {
		my $tmdelta = abs($power{$tm} - $new_power{$tm});
		$delta += $tmdelta;
		if ($tmdelta > 1) {
			printf DELTAS "$tm %.03f\n", $tmdelta;
		}
	}
	printf DELTAS "%.03f\n", $delta;
	%power = %new_power;
}

sub print_sorted_power(%){
	my %pwr = @_;
	my @sorted = sort {$pwr{$b} <=> $pwr{$a}} (keys %pwr);
	open (RESULTS, '>', "$outdir/results.txt") or die "Couldn't open results";
	foreach my $team (@sorted) {
		printf RESULTS "$team: %.03f\n", $pwr{$team};
	}
}


read_csv($file);
init_power();
my $roundMax = 100;
my $velConst = 0.1;
for (my $r = 0; $r < $roundMax; $r++) {
#	my $velocity = $velConst - $velConst*($r/$roundMax);
#	run_round($velocity);
	run_round($velConst);
}


print_sorted_power(%power);

foreach my $tm (keys %teamCnt) {
	$volatile{$tm} = 0;
}

foreach my $i (keys %scores) {
	my $t1p = $power{$scores{$i}{'t1'}};
	my $t2p = $power{$scores{$i}{'t2'}};
	my $diff = ($scores{$i}{'t1s'} - $scores{$i}{'t2s'}) - ($t1p -$t2p) ;
	my $name = $scores{$i}{'t1'} . '-' . $scores{$i}{'t2'};
	$weird{$name} = $diff;
	$volatile{$scores{$i}{'t1'}} += abs($diff);
	$volatile{$scores{$i}{'t2'}} += abs($diff);
}

open (WEIRD_GAMES, '>', "$outdir/weird_games.txt") or die "Couldn't open weird games";
foreach my $wtf (sort {abs($weird{$b}) <=> abs($weird{$a})} (keys %weird)) {
	print WEIRD_GAMES "$wtf $weird{$wtf}\n";
}
close (WEIRD_GAMES);


open (WEIRD_TEAMS, '>', "$outdir/weird_teams.txt") or die "Couldn't open weird teams";
foreach my $v (sort {$volatile{$b} / $teamCnt{$b} <=> $volatile{$a} / $teamCnt{$a}} (keys %volatile)) {
	my $volAve = $volatile{$v} / $teamCnt{$v};
	print WEIRD_TEAMS "$v  $volAve\n";
}
close(WEIRD_TEAMS);