hs-collection-tool

#!/usr/bin/perl

use strict;
use warnings;
use Data::Dumper;
use JSON::PP;
use Term::ANSIColor;
use Getopt::Long;
use Pod::Usage;


my @collectable_sets = ('EXPERT1', 'OG', 'GANGS', 'UNGORO', 'ICECROWN','LOOTAPALOOZA');
my @release_order = ('CORE','EXPERT1',
                     'NAXX','GVG',
                     'BRM','TGT','LOE',
                     'OG','KARA','GANGS',
                     'HOF', 'UNGORO',
                     'ICECROWN', 'LOOTAPALOOZA');
my %format = ('CORE' => 'STANDARD',
              'EXPERT1' => 'STANDARD',
              'NAXX' => 'WILD',
              'GVG' => 'WILD',
              'BRM' => 'WILD',
              'TGT' => 'WILD',
              'LOE' => 'WILD',
              'OG' => 'STANDARD',
              'KARA' => 'STANDARD',
              'GANGS' => 'STANDARD',
              'HOF' => 'WILD',
              'UNGORO' => 'STANDARD',
              'ICECROWN' => 'STANDARD',
              'LOOTAPALOOZA' => 'STANDARD'
            );
my %sets_s2l = ('CORE' => 'Basic',
                'EXPERT1' => 'Classic',
                'NAXX' => 'Naxxramas',
                'GVG' => 'Goblins vs Gnomes',
                'BRM' => 'Blackrock Mountain',
                'TGT' => 'The Grand Tournament',
                'LOE' => 'League of Explorers',
                'OG' => 'Whispers of the Old Gods',
                'KARA' => 'One Night in Karazhan',
                'GANGS' => 'Mean Streets of Gadgetzan',
                'UNGORO' => 'Journey to Un\'Goro',
                'HOF' => 'Hall of Fame',
                'ICECROWN' => 'Frozen Throne',
                'LOOTAPALOOZA' => 'Kobolds and Catacombs'
               );
my %sets_l2s = ('Basic' => 'CORE',
                'Classic' => 'EXPERT1',
                'Naxxramas' => 'NAXX',
                'Goblins vs Gnomes' => 'GVG',
                'Blackrock Mountain' => 'BRM',
                'The Grand Tournament' => 'TGT',
                'League of Explorers' => 'LOE',
                'Whispers of the Old Gods' => 'OG',
                'One Night in Karazhan' => 'KARA',
                'Mean Streets of Gadgetzan' => 'GANGS',
                'Journey to Un\'Goro' => 'UNGORO',
                'Hall of Fame' => 'HOF',
                'Frozen Throne' => 'ICECROWN',
                'Kobolds and Catacombs' => 'LOOTAPALOOZA'
              );
my @classes = ('DRUID',
               'HUNTER',
               'MAGE',
               'PALADIN',
               'PRIEST',
               'ROGUE',
               'SHAMAN',
               'WARLOCK',
               'WARRIOR',
               'NEUTRAL'
              );
my @card_type = ('HERO',
                 'WEAPON',
                 'SPELL',
                 'MINION'
                );
my @rarities = ('FREE',
                'COMMON',
                'RARE',
                'EPIC',
                'LEGENDARY'
               );
my $free_not_common =  { "Ironbark Protector" => 1,
                         "Moonfire" => 1,
                         "Savage Roar" => 1,
                         "Starfire" => 1,
                         "Swipe" => 1,
                         "Animal Companion" => 1,
                         "Hunter's Mark" => 1,
                         "Kill Command" => 1,
                         "Starving Buzzard" => 1,
                         "Tundra Rhino" => 1,
                         "Flamestrike" => 1,
                         "Frost Nova" => 1,
                         "Frostbolt" => 1,
                         "Mirror Image" => 1,
                         "Water Elemental" => 1,
                         "Acidic Swamp Ooze" => 1,
                         "Archmage" => 1,
                         "Bluegill Warrior" => 1,
                         "Booty Bay Bodyguard" => 1,
                         "Chillwind Yeti" => 1,
                         "Core Hound" => 1,
                         "Dalaran Mage" => 1,
                         "Darkscale Healer" => 1,
                         "Dragonling Mechanic" => 1,
                         "Elven Archer" => 1,
                         "Frostwolf Grunt" => 1,
                         "Frostwolf Warlord" => 1,
                         "Gnomish Inventor" => 1,
                         "Goldshire Footman" => 1,
                         "Grimscale Oracle" => 1,
                         "Gurubashi Berserker" => 1,
                         "Ironforge Rifleman" => 1,
                         "Ironfur Grizzly" => 1,
                         "Kobold Geomancer" => 1,
                         "Lord of the Arena" => 1,
                         "Murloc Tidehunter" => 1,
                         "Ogre Magi" => 1,
                         "Razorfen Hunter" => 1,
                         "Shattered Sun Cleric" => 1,
                         "Silverback Patriarch" => 1,
                         "Stormpike Commando" => 1,
                         "Stormwind Champion" => 1,
                         "Stormwind Knight" => 1,
                         "War Golem" => 1,
                         "Blessing of Kings" => 1,
                         "Consecration" => 1,
                         "Guardian of Kings" => 1,
                         "Humility" => 1,
                         "Truesilver Champion" => 1,
                         "Divine Spirit" => 1,
                         "Holy Nova" => 1,
                         "Mind Control" => 1,
                         "Mind Vision" => 1,
                         "Shadow Word: Death" => 1,
                         "Assassin's Blade" => 1,
                         "Fan of Knives" => 1,
                         "Shiv" => 1,
                         "Sprint" => 1,
                         "Vanish" => 1,
                         "Bloodlust" => 1,
                         "Fire Elemental" => 1,
                         "Flametongue Totem" => 1,
                         "Totemic Might" => 1,
                         "Windspeaker" => 1,
                         "Corruption" => 1,
                         "Dread Infernal" => 1,
                         "Mortal Coil" => 1,
                         "Sacrificial Pact" => 1,
                         "Soulfire" => 1,
                         "Arcanite Reaper" => 1,
                         "Cleave" => 1,
                         "Kor'kron Elite" => 1,
                         "Shield Block" => 1,
                         "Whirlwind" => 1
                       };

my $costs = { 'FREE' => 0,
              'COMMON' => 40,
              'RARE' => 100,
              'EPIC' => 400,
              'LEGENDARY' => 1600 };
my $golden_costs = { 'FREE'      => 0,
                     'COMMON'    => 400,
                     'RARE'      => 800,
                     'EPIC'      => 1600,
                     'LEGENDARY' => 3200 };
my $de_costs = { 'FREE'   => 0,
                 'COMMON' => 5,
                 'RARE'   => 20,
                 'EPIC'   => 100,
                 'LEGENDARY' => 400 };
my $golden_de_costs = { 'FREE'      => 0,
                        'COMMON'    => 50,
                        'RARE'      => 100,
                        'EPIC'      => 400,
                        'LEGENDARY' => 1600 };

my @tsets = keys %sets_l2s;
my %labels = ( 'by_set' => \@tsets,
               'by_class' => \@classes
             );
my %labels_max = ( 'by_set' => length "by_set",
                   'by_class' => length "by_class"
                 );
foreach my $l ('by_set', 'by_class') {
  foreach my $il (@{$labels{$l}}) {
    $labels_max{$l} = length $il > $labels_max{$l} ? length $il : $labels_max{$l};
  }
}
$labels{by_set} = \@release_order;

sub fetch_json {
  my ($json_file) = @_;
  # fetch all the card data from hearthstonejson.com
  my $url = "https://api.hearthstonejson.com/v1/latest/enUS/cards.collectible.json";
  `curl -L $url > $json_file`;
}

sub dump_json {
  my ($json_file) = @_;
  my $all_sets = {};
  local $/;
  open ( my $fh, '<', $json_file );
  my $json_text = <$fh>;
  close ($fh);
  my $ref = decode_json ($json_text);
  print Dumper ($ref);
}

sub init_db {
  my ($json_file, $db_file) = @_;

  my $card_db = {
                  'order' => [],
                  'by_name' => {}
                };

  # if we have a db file load it
  if (-f $db_file ) {
    open CARDS, "< $db_file" or die "can't open $!\n";
    my $header = <CARDS>;
    while (my $line = <CARDS>) {
      chomp $line;
      my ($class, $set, $type, $number, $golden, $name) = split /\t/, $line;
      if (! exists $sets_s2l{$set}) {
        $set = $sets_l2s{$set};  # normalize on short forms
      }
      $card_db->{'by_name'}{$name} = { 'class'  => uc($class),
                                       'set'    => $set,
                                       'rarity' => uc($type),
                                       'number' => $number,
                                       'golden' => $golden
                                     };
    }
    close CARDS;
  }

  # next load and merge in the json
  local $/;
  open ( my $fh, '<', $json_file );
  my $json_text = <$fh>;
  close ($fh);
  my $ref = decode_json ($json_text);
  my $db_raw = {};
  foreach my $card (@{$ref}) {
    if (! exists $sets_s2l{$card->{set}}  # skip cards not in a known set
        or ( $card->{type} eq "HERO" and not defined $card->{cost} ) # as well as HERO cards
       ) {
      next;
    }
    # hearthstonejson lists several Free cards as Common because internally
    # the are represented as such but I want them to be Free so that
    # cost are computed accurately, so if they are in the list, make them
    # Free
    if (defined $free_not_common->{$card->{name}}) {
      $card->{rarity} = "FREE";
    }


    # add in NEUTRAL as a class
    my $class =
      defined $card->{playerClass} ? $card->{playerClass} : "NEUTRAL";
    my $name = $card->{name};
    my $entry =
      { 'class' => $class,
        'set' => $card->{set},
        'rarity' => $card->{rarity},
        'cost' => $card->{cost},
        'type' => $card->{type},
        'name' => $name,
        'dust' => defined $card->{dust} ? $card->{dust} : undef,
        'number' => 0,
        'golden' => 0,
        'health' => defined $card->{health} ? $card->{health} : "",
        'mechanics' => $card->{mechanics},
        'attack' => defined $card->{attack} ? $card->{attack} : ""
      };
    # if we read our numbers for number of regular and golden cards use them
    if (exists $card_db->{by_name}{$name}) {
      $entry->{number} = $card_db->{by_name}{$name}{number};
      $entry->{golden} = $card_db->{by_name}{$name}{golden};
    }
#    $db_raw->{$class}{$card->{cost}}{$card->{type}}{$name} = $entry;
    $db_raw->{$class}{$card->{cost}}{$name} = $entry;
    $card_db->{by_name}{$name} = $entry;
  }
  # order based on how the cards are sorted in the collection tab in
  # hearthstone for easier management
  # 1. by class
  # 2. by mana cost
  # 3. alphabetically by name (with single quotes removed and lowercased)
  foreach my $class (@classes) {
    foreach my $mana (sort {$a <=> $b} keys %{$db_raw->{$class}}) {
      if (exists $db_raw->{$class}{$mana}) {
        # normalize the key by removing single quote's (') and lowercasing,
        # but keep track of the original name by generating a hash
        my %t = map { my $t = $_; $_ =~ s/\'//g; lc($_) => $t } keys %{$db_raw->{$class}{$mana}};
        # now sort in alphabetical order
        foreach my $n (map { $t{$_} } sort { $a cmp $b } keys %t) {
          push @{$card_db->{order}}, $n;
        }
      }
    }
  }
  $db_raw = undef;
  return $card_db;
}

sub write_db {
  my ($db_name, $card_db) = @_;
  print STDERR "opening $db_name\n";
  open ( my $db, '>', $db_name) or die "Can't open $db_name : $!\n";
  print $db "Class\tSet\tRarity\tNumber\tGold\tName\n";
  foreach my $n (@{$card_db->{order}}) {
    my $e = $card_db->{by_name}{$n};
    print $db
      join ("\t", (ucfirst(lc($e->{class})),
                   $sets_s2l{$e->{set}},
                   ucfirst(lc($e->{rarity})),
                   $e->{number},
                   $e->{golden},
                   $e->{name}))."\n";
  }
  close $db;
}

sub enhance {
  my ($cards) = shift;
  my $type_counts = {'by_set' => {}, 'by_class' => {}};
  my $all_mechs = {};
  my $labels_max = { 'by_set' => 0, 'by_class' => 0, 'by_name' => 0 };
  foreach my $s (keys %sets_s2l) {
    unless (exists ($type_counts->{'by_set'}{$s})) {
      $type_counts->{'by_set'}{$s} = {};
    }
    foreach my $t (@rarities) {
      $type_counts->{'by_set'}{$s}{$t} = { 'total' => 0,
                                           'total_playable' => 0,
                                           'total_have' => 0,
                                           'have' => [ 0, 0, 0 ],
                                           'missing' => {}
                                         };
    }
  }
  foreach my $c (@classes) {
    unless (exists ($type_counts->{'by_class'}{$c})) {
      $type_counts->{'by_class'}{$c} = {};
    }
    foreach my $t (@rarities) {
      $type_counts->{'by_class'}{$c}{$t} = { 'total' => 0,
                                             'total_playable' => 0,
                                             'total_have' => 0,
                                             'have' => [ 0, 0, 0 ],
                                             'missing' => {}
                                           };
    }
  }

  foreach my $name (keys %{$cards->{'by_name'}}) {
    my $mechanics = $cards->{'by_name'}{$name}{mechanics};
    my $class     = $cards->{'by_name'}{$name}{class};
    my $set       = $cards->{'by_name'}{$name}{set};
    my $setlong   = $sets_s2l{$set};
    my $rarity    = $cards->{'by_name'}{$name}{rarity};
    my $number    = $cards->{'by_name'}{$name}{number};
    my $golden    = $cards->{'by_name'}{$name}{golden};
    my $health    = $cards->{'by_name'}{$name}{health};
    my $attack    = $cards->{'by_name'}{$name}{attack};
    my $cost      = $cards->{'by_name'}{$name}{cost};
    my $type      = $cards->{'by_name'}{$name}{type};
    my $dust      = $cards->{'by_name'}{$name}{dust};

    # determine all possible mechanics
    if (defined ($mechanics) ) {
      foreach my $mech (sort @{$mechanics}) {
        $all_mechs->{$mech} = 0;
      }
    }

    # keep track of max lengths, for later labeling
    $labels_max->{by_set} = length $setlong > $labels_max->{by_set} ? length $setlong : $labels_max->{by_set};
    $labels_max->{by_class} = length $class > $labels_max->{by_class} ? length $class : $labels_max->{by_class};
    $labels_max->{by_name} = length $name > $labels_max->{by_name} ? length $name : $labels_max->{by_name};

    # determine card counts
    my $ct = $number + $golden;

    $type_counts->{'by_set'}{$set}{$rarity}{'total'} += 1;
    $type_counts->{'by_class'}{$class}{$rarity}{'total'} += 1;
    $type_counts->{'by_set'}{$set}{$rarity}{'total_have'} += $ct > 2 ? 2 : $ct;
    $type_counts->{'by_class'}{$class}{$rarity}{'total_have'} += $ct > 2 ? 2 : $ct;

    if ($rarity eq "LEGENDARY") {
      $type_counts->{'by_set'}{$set}{$rarity}{'total_playable'} += 1;
      $type_counts->{'by_class'}{$class}{$rarity}{'total_playable'} += 1;
      if ($ct > 0) {
        $type_counts->{'by_set'}{$set}{LEGENDARY}{'have'}[1]++;
        $type_counts->{'by_class'}{$class}{LEGENDARY}{'have'}[1]++;
      } else {
        $type_counts->{'by_set'}{$set}{LEGENDARY}{missing}{$name} = 1;
        $type_counts->{'by_set'}{$set}{LEGENDARY}{'have'}[0]++;
        $type_counts->{'by_class'}{$class}{LEGENDARY}{missing}{$name} = 1;
        $type_counts->{'by_class'}{$class}{LEGENDARY}{'have'}[0]++;
      }
    } else {
      $type_counts->{'by_set'}{$set}{$rarity}{'total_playable'} += 2;
      $type_counts->{'by_class'}{$class}{$rarity}{'total_playable'} += 2;
      if ($ct >= 2 ) {
        $type_counts->{'by_set'}{$set}{$rarity}{'have'}[2]++;
        $type_counts->{'by_class'}{$class}{$rarity}{'have'}[2]++;
      } elsif ( $ct == 1) {
        $type_counts->{'by_set'}{$set}{$rarity}{missing}{$name} = 1;
        $type_counts->{'by_set'}{$set}{$rarity}{'have'}[1]++;
        $type_counts->{'by_class'}{$class}{$rarity}{missing}{$name} = 1;
        $type_counts->{'by_class'}{$class}{$rarity}{'have'}[1]++;
      } else {
        $type_counts->{'by_set'}{$set}{$rarity}{missing}{$name} = 2;
        $type_counts->{'by_set'}{$set}{$rarity}{'have'}[0]++;
        $type_counts->{'by_class'}{$class}{$rarity}{missing}{$name} = 2;
        $type_counts->{'by_class'}{$class}{$rarity}{'have'}[0]++;
      }
    }
  }
  $cards->{type_counts} = $type_counts;
  $cards->{all_mechs} = $all_mechs;
  $cards->{label_max} = $labels_max;
  return $cards;
}

sub print_de {
  my ($cards) = @_;
  my $total_de = 0;

#  print Dumper($cards);
  printf "%5s\t%-7s\t%-30s\n", "Cost", "Class", "Card";
  printf "%5s\t%7s\t%30s\n", "-"x5, "-"x7, "-"x30;
  foreach my $n (@{$cards->{order}}) {
    my $e = $cards->{by_name}{$n};
    my $rarity = $e->{rarity};
    my $number = $e->{number};
    my $golden = $e->{golden};
    my $class = ucfirst(lc($e->{class}));
#    my $dust = $e->{dust};
    if ($rarity ne 'FREE' and
         ($rarity eq 'LEGENDARY' and $number >= 1 and $golden > 0 )
         or ($number >= 2 and $golden > 0)) {
      my $de_value = $golden_de_costs->{$rarity} * $golden;
      $total_de += $de_value;
      printf "%5d\t%7s\t%s\n", $de_value, $class, $n;
    }
  }
  printf "%5s\t%7s\t%30s\n", "-"x5, "-"x7, "-"x30;
  printf "%5d\t%7s\t%s\n",$total_de,"","Total";
}

sub to_buy {
  my ($cards) = shift;

  # some numbers from
  # https://docs.google.com/spreadsheets/d/1VdqhpiremPEiIKmS1YI8_8HkdYb57wb8cD4ZLnxtffU/edit#gid=579362856
  my $occurrence_probability_normal =
    {
      'COMMON' => 69.90,
      'RARE' => 21.50,
      'EPIC' => 4.21,
      'LEGENDARY' => 1.08
    };
  my $occurrence_probability_golden =
    {
      'COMMON' => 1.51,
      'RARE' => 1.41,
      'EPIC' => 0.29,
      'LEGENDARY' => 0.11
    };
  my $occurrence_probability;
  foreach my $type (keys %{$occurrence_probability_normal}) {
    $occurrence_probability->{$type} =
      $occurrence_probability_normal->{$type}
      + $occurrence_probability_golden->{$type};
  }

  #
  # Standard Pack Value    | Classic                | Goblins vs Gnomes
  # 123456789
  # Legendary
  # Epic
  # Rare
  # Common
  printf "%9s ","";
  foreach my $cs (@collectable_sets) {
    printf " %-21s", $sets_s2l{$cs};
  }
  print "\n";

  printf "%9s ","";
  foreach my $cs (@collectable_sets) {
    printf "%4s %16s ","#","Missing Cards";
  }
  print "\n";
  my %chances;
  foreach my $type ('COMMON','RARE','EPIC','LEGENDARY') {
    if ($type eq 'RARE') {
      print color 'bold blue';
    } elsif ($type eq 'EPIC') {
      print color 'bold magenta';
    } elsif ($type eq 'LEGENDARY') {
      print color 'bold yellow';
    }
    printf "%-9s ", ucfirst(lc($type));
    print color 'reset';
    foreach my $set (@collectable_sets) {
      my $num = $cards->{type_counts}{by_set}{$set}{$type}{total_playable};
      my $have = $cards->{type_counts}{by_set}{$set}{$type}{total_have};
      my $missing = $num - $have;
      my $chance = $occurrence_probability->{$type} *
        ((($num-$missing)/$num)*$de_costs->{$type}+$missing/$num*$costs->{$type}) / 100;
      $chances{$set} += $chance;
      printf "%5d %5d %9.2f ",$num, $missing, $chance;
    }
    print "\n";
  }
  printf "%9s ","";
  my $to_buy = 0;
  my $buy_set;
  foreach my $set (@collectable_sets) {
    if ($chances{$set} > $to_buy) {
      $to_buy = $chances{$set};
      $buy_set = $set ;
    }
    print color 'bold';
    printf "%5s %5s %9.2f ","","", $chances{$set} * 5;
    print color 'reset';
  }
  print "\n";
  print "Buy -> ";
  print color 'bold red';
  print $sets_s2l{$buy_set};
  print color 'reset';
  print "\n";
}

my $curves = { 'cost'   => [ 0, 0, 0, 0, 0, 0, 0, 0 ],
               'health' => [ 0, 0, 0, 0, 0, 0, 0, 0 ],
               'attack' => [ 0, 0, 0, 0, 0, 0, 0, 0 ]
             };

my $max_curve = 0;

sub add_to_curve {
  my ($val, $curve) = @_;
  return if $val eq "";
  if ($val >= 7) {
    $val = 7;
  }
  $curves->{$curve}[$val]++;
  $max_curve =
    $curves->{$curve}[$val] > $max_curve ? $curves->{$curve}[$val] : $max_curve;
}

sub deck_from_file {
  my ($cards, $deck_file) = @_;
  my $total_cards = 0;
  my $deck = {};

  open DECK, "< $deck_file" or die "can't open $!\n";
  while (my $line = <DECK>) {
    next if $line =~ m/^#/;
    # deal with dos
    $line =~ s/([^\r\n]+)(\r|\n)$/$1/;
    chomp $line;
    # cockatrice format with or without x
    # 2 <card name>
    # or
    # 2x <card name>
    my $name = undef;
    if ($line =~ m/^\d+(x?)\s/) {
      my ($need_num, @name) = split /\s/, $line;
      $name = join (" ", @name);
      $deck->{$name} = $need_num;
      $total_cards += $need_num;
    } else {
      # just card name per line
      $name = $line;
      $deck->{$name}++;
      $total_cards++;
    }
    die "name [$name] is not in card list!\n" unless exists $cards->{'by_name'}{$name};
  }
  close DECK;
  die "not enough cards in deck $deck_file\n" if $total_cards != 30;
  $deck->{filename} = $deck_file;
  return $deck;
}

sub read_deck {
  my ($cards, $deck_file) = @_;
  my $total_cost = 0;
  my $total_cards = 0;
  my $total_needed = 0;
  my $detected_class = 'NEUTRAL';
  my $cards_needed = {};

  my $deck = deck_from_file ($cards, $deck_file);
  my $deck_name = $deck->{filename};
  foreach my $name (keys %{$deck}) {
    next if $name eq 'filename';
    $name =~ s/’/'/g;
    my $need_num = $deck->{$name};
    $total_cards += $need_num;
    my $have_number =
      ($cards->{'by_name'}{$name}{'number'}
        + $cards->{'by_name'}{$name}{'golden'});
    my $rarity = $cards->{'by_name'}{$name}{rarity};
    my $cost;
    my $need;
    if ( $have_number >= $need_num) {
      $need = 0;
      $cost = 0;
    } else {
      unless (defined $cards_needed->{$name}) {
        $cards_needed->{$name} = { 'needed' => 0, 'cost' => 0 };
      }
      $need = ($need_num - $have_number);
      $cost = $need * $costs->{$rarity};
      $cards_needed->{$name}{needed} = ($need_num - $have_number);
      $cards_needed->{$name}{cost} = $need * $costs->{$rarity};
    }
    $detected_class =
      $cards->{'by_name'}{$name}{class} ne 'NEUTRAL'
      ? $cards->{'by_name'}{$name}{class}
      : $detected_class;
    $total_needed += $need;
    $total_cost += $cost;
  }

  return ($total_needed, $total_cost, $detected_class, $cards_needed)
}

sub print_deck {
  my ($cards, $deck_file) = @_;
  my $total_cost = 0;
  my $total_cards = 0;
  my $total_needed = 0;

  my $deck = deck_from_file ($cards, $deck_file);
  my $deck_name = $deck->{filename};

  print "--------------------------------------------------\n";
  print "$deck_name\n";
  print "--------------------------------------------------\n";

  foreach my $name (@{$cards->{order}}) {
    next if not exists $deck->{$name};
    my $need_num = $deck->{$name};
    $total_cards += $need_num;
    my $have_number =
      ($cards->{'by_name'}{$name}{'number'}
        + $cards->{'by_name'}{$name}{'golden'});

    my $manacost = $cards->{'by_name'}{$name}{cost};
    my $attack = $cards->{'by_name'}{$name}{attack};
    my $health = $cards->{'by_name'}{$name}{health};
    my $type = $cards->{'by_name'}{$name}{type};
    foreach my $m (@{$cards->{'by_name'}{$name}{mechanics}}) {
      $cards->{all_mechs}{$m} += $need_num;
    }
    if ($need_num == 1) {
      add_to_curve ($cards->{'by_name'}{$name}{cost}, 'cost');
      add_to_curve ($cards->{'by_name'}{$name}{attack}, 'attack') if ($type ne "Weapon");
      add_to_curve ($cards->{'by_name'}{$name}{health}, 'health');
    } elsif ($need_num == 2) {
      add_to_curve ($cards->{'by_name'}{$name}{cost}, 'cost');
      add_to_curve ($cards->{'by_name'}{$name}{attack}, 'attack') if ($type ne "Weapon");
      add_to_curve ($cards->{'by_name'}{$name}{health}, 'health');
      add_to_curve ($cards->{'by_name'}{$name}{cost}, 'cost');
      add_to_curve ($cards->{'by_name'}{$name}{attack}, 'attack') if ($type ne "Weapon");
      add_to_curve ($cards->{'by_name'}{$name}{health}, 'health');
    }
    my $rarity = $cards->{'by_name'}{$name}{rarity};
    my $cost;
    my $need;
    if ( $have_number >= $need_num) {
      $need = 0;
      $cost = 0;
    } else {
      $need = ($need_num - $have_number);
      $cost = $need * $costs->{$rarity};
    }

    $total_needed += $need;
    $total_cost += $cost;
    printf "%4d ", $cost;
    printf "%-9s ", ucfirst(lc($rarity));
    printf "%2s ", $need;
    printf "%2s ", $need_num;
    print color 'bold blue';
    printf "%2s ", $manacost;
    print color 'bold yellow';
    printf "%2s ", $attack;
    print color 'bold red';
    printf "%2s ", $health;
    print color 'reset';
    printf "%s\n", $name;
  }
  close DECK;
  print "--------------------------------------------------\n";
  print "Total Cards:  $total_cards\n";
  print "Cards Needed: $total_needed\n";
  print "My Cost:      $total_cost\n";

  #
  #
  #
  #          1         2         3         4         5         6         7
  #01234567890123456789012345678901234567890123456789012345678901234567890123456789
  #     0 1 2 3 4 5 6 7     0 1 2 3 4 5 6 7     0 1 2 3 4 5 6 7
  #          Cost               Attack              Health
  #
  print "\n";
  for ( my $i = $max_curve + 1 ; $i >= 0 ; $i-- ) {
    printf "%2d   ", $i; #" "x5;
    foreach my $curve ('cost', 'attack', 'health') {
      if ($curve eq 'cost') {
        print color 'bold blue';
      } elsif ($curve eq 'attack') {
        print color 'bold yellow';
      } elsif ($curve eq 'health') {
        print color 'bold red';
      }
      for (my $j = 0; $j < 8; $j++ ) {
        if ($i eq 0) {
          print color 'reset';
          print "$j ";
        } elsif ($curves->{$curve}[$j] >= $i) {
          print "# ";
        } else {
          print "  ";
        }
      }
      print " "x5;
    }
    print color 'reset';
    print "\n";
  }
  print "         Cost                  Attack               Health\n";
  print "-"x72,"\n\n";

  my @all = sort keys %{$cards->{all_mechs}};
  my $len = scalar @all;
  for (my $i = 0; $i < scalar @all; $i += 3 ) {
    for (my $j = 0 ; $j <= 2 ; $j++ ) {
      if ( ($i+$j) < $len ) {
        printf "%-20s ", ucfirst(lc($all[$i+$j]));
        print color 'bright_white';
        printf "%2d  ", , $cards->{all_mechs}{$all[$i+$j]};
        print color 'reset';
      }
    }
    print "\n";
  }
}

sub print_decks {
  my ($cards, $deck_dir) = @_;
  opendir (my $DECKS, $deck_dir) or die "can't opendir deck dir $deck_dir : $!";
  my @files = readdir $DECKS;
  closedir $DECKS;
  foreach my $file (sort @files) {
    next if $file =~ /^\./;
    my ($need, $cost, $class, $cards_needed) = read_deck ($cards, "$deck_dir/$file");
    print "$file\t".ucfirst(lc($class))."\t$need\t$cost\n";
    foreach my $name (keys $cards_needed) {
      print "Card\t"
            .$sets_s2l{$cards->{by_name}{$name}{set}}."\t"
            ."$name\t"
            .$cards_needed->{$name}{needed}."\t"
            .$cards_needed->{$name}{cost}."\n";
    }
  }
}

sub print_stats {
  my ($cards, $label, $filters, $details) = @_;
  my $type_counts = $cards->{type_counts};

  my $total_missing = 0;
  my $total_for_complete = 0;
  my $total_cost = 0;

  my $label_fmt = (sprintf "%%%ds", $labels_max{$label});

  printf $label_fmt." : %10s : %3s/%3s/%3s/%3s : %6s : %5s : %6s : %6s\n",
         $label,"Rarity", "0", "1", "2", "Total", "Have%", "Need#", "Need%", "Cost";
  printf $label_fmt." : %10s : %15s : %6s : %5s : %6s : %6s\n",
         "-"x$labels_max{$label},"-"x10,"-"x17,"-"x6,"-"x5,"-"x6,"-"x6;
  foreach my $l (@{$labels{$label}}) {
    next if scalar keys %{$filters->{$label}} gt 0 and not exists $filters->{$label}{$l};
    my $total_missing_by_label = 0;
    my $total_for_complete_by_label = 0;
    my $total_cost_by_label = 0;
    foreach my $rarity (@rarities) {
      next if scalar keys %{$filters->{by_rarity}} gt 0 and not exists $filters->{by_rarity}{$rarity};
      my $still_need;
      my $total;
      if ($rarity eq 'LEGENDARY') {
        $still_need = $type_counts->{$label}{$l}{$rarity}{'have'}[0];
        $total = $type_counts->{$label}{$l}{$rarity}{'total'};
      } else {
        $still_need =
          $type_counts->{$label}{$l}{$rarity}{'have'}[0]*2
          + $type_counts->{$label}{$l}{$rarity}{'have'}[1];
        $total = $type_counts->{$label}{$l}{$rarity}{'total'}*2;
      }
      $total_missing_by_label += $still_need;
      $total_for_complete_by_label += $total;
      my $cost = $still_need > 0 ? $still_need * $costs->{$rarity} : 0;
      $total_cost_by_label += $cost;
      my $need_percent = $still_need > 0 ? $still_need/$total * 100 : 0.0;
      my $have_percent = 100-$need_percent;
      if ($total > 0) {
        printf $label_fmt." : %10s : %3d/%3d/%3d/%5d : %6.2f : %5d : %6.2f : %6d\n",
          ($label eq "by_set" ? $sets_s2l{$l} : ucfirst(lc($l))),
          ucfirst(lc($rarity)),
          $type_counts->{$label}{$l}{$rarity}{'have'}[0],
          $type_counts->{$label}{$l}{$rarity}{'have'}[1],
          $type_counts->{$label}{$l}{$rarity}{'have'}[2],
          $type_counts->{$label}{$l}{$rarity}{'total'},
          $have_percent,
          $still_need,
          $need_percent,
          $cost;
      }
    }

    if (defined ($details)) {
      printf $label_fmt." : %10s : %15s : %6s : %5s : %6s : %6s\n",
             "-"x$labels_max{$label},"-"x10,"-"x17,"-"x6,"-"x5,"-"x6,"-"x6;
      my $longest = 0;
      foreach my $rarity (@rarities) {
        my $num_missing = scalar keys %{$type_counts->{$label}{$l}{$rarity}{missing}};
        $longest = $num_missing > $longest ? $num_missing : $longest;
      }

      my $name_fmt = (sprintf "%-%%ds", $cards->{label_max}{by_name});
      for (my $i = 0; $i < $longest; $i++) {
        foreach my $rarity (@rarities) {
          next if $rarity eq 'FREE';
          my @k = keys %{$type_counts->{$label}{$l}{$rarity}{missing}};
          if (defined $k[$i]) {
            my $m = $k[$i];
            printf $name_fmt." x%1d : ",$m,$type_counts->{$label}{$l}{$rarity}{missing}{$m};
          } else {
            printf $name_fmt."    : "," ";
          }
        }
        print "\n";
      }
#      foreach my $rarity (@rarities) {
#        foreach my $m (keys %{$type_counts->{$label}{$l}{$rarity}{missing}}) {
#          printf "%2dx %".$cards->{label_max}{by_name}."s :\n",$type_counts->{$label}{$l}{$rarity}{missing}{$m},$m;
#        }
#      }
    }


    $total_missing += $total_missing_by_label;
    $total_for_complete += $total_for_complete_by_label;
    $total_cost += $total_cost_by_label;

    my $total_need_percent_by_label = $total_missing_by_label > 0
                             ? $total_missing_by_label/$total_for_complete_by_label * 100
                             : 0.0;

    printf $label_fmt." : %10s : %15s : %6s : %5s : %6s : %6s\n",
           "-"x$labels_max{$label},"-"x10,"-"x17,"-"x6,"-"x5,"-"x6,"-"x6;
    printf $label_fmt." : %10s : %4s%4s%4s%5d : %6.2f : %5d : %6.2f : %6d\n",
      ($label eq "by_set" ? $sets_s2l{$l} : ucfirst(lc($l))),
      " ",
      " ",
      " ",
      " ",
      $total_for_complete_by_label,
      100-$total_need_percent_by_label,
      $total_missing_by_label,
      $total_need_percent_by_label,
      $total_cost_by_label;

    printf $label_fmt." : %10s : %15s : %6s : %5s : %6s : %6s\n",
           "-"x$labels_max{$label},"-"x10,"-"x17,"-"x6,"-"x5,"-"x6,"-"x6;
  }
  my $total_need_percent = $total_missing > 0
                           ? $total_missing/$total_for_complete * 100
                           : 0.0;
  printf $label_fmt." : %10s : %17s : %6.2f : %5d : %6.2f : %6d\n",
      "Total",
      " ",
      $total_for_complete,
      100-$total_need_percent,
      $total_missing,
      $total_need_percent,
      $total_cost;
}


my $fetch = 0;
my $de = 0;
my $db_file = "Hearthstone-Cards.db";
my $json_file = "cards.collectible.json";
my $deck_dir = "Decks";
my $class = undef;
my $by_class = 0;
my $by_decks = 0;
my $buy = 0;
my $rebuild = 0;
my $dump = 0;
my $filters_opt = undef;
my $verbose_opt = undef;
my $details_opt = undef;

GetOptions (
  "help" => sub { pod2usage(-exitval => 1, -output => \*STDOUT, -verbose => 1); },
  "man" => sub { pod2usage(-exitval => 2, -output => \*STDOUT, -verbose => 2); },
  "verbose" => \$verbose_opt,
  "filters=s" => \$filters_opt,
  "fetch" => \$fetch,
  "details" => \$details_opt,
  "deck_dir=s" => \$deck_dir,
  "dump" => \$dump,
  "db=s" => \$db_file,
  "de" => \$de,
  "class=s" => \$class,
  "by_class" => \$by_class,
  "by_decks" => \$by_decks,
  "to_buy" => \$buy,
  "rebuild" => \$rebuild,
) or pod2usage (2);

my $deck = shift;
my $filters = { 'by_class' => {},
                'by_set' => {},
                'by_rarity' => {},
              };
if (defined ($filters_opt)) {
  foreach my $f (split /,/, $filters_opt) {
    my $n = uc($f);
    foreach my $c (@classes) {
      $filters->{by_class}{$c} = 1 if ($c eq $n);
    }
    foreach my $r (@rarities) {
      $filters->{by_rarity}{$r} = 1 if ($r eq $n);
    }
    foreach my $s (keys %sets_s2l) {
      my $l = $sets_s2l{$s};
      if (   $f eq $s
          or $n eq $s
          or $f eq $l
          or $n eq $l) {
        $filters->{by_set}{$s} = 1;
      }
    }
  }
}
# filtering by class currently disables filtering by set
if (scalar keys %{$filters->{by_class}} gt 0) {
  $by_class = 1;
  $filters->{by_set} = {};
}

if ($fetch or ! -f $json_file) {
  fetch_json ($json_file);
}
my $cards = init_db ($json_file, $db_file);
# if we haven't written our db file, or we have and are rebuilding
# write the new cards db
if (! -f $db_file
    or (-f $db_file and $rebuild)) {
  write_db ($db_file, $cards);
}
$cards = enhance ($cards);

if ($dump) {
  print Dumper($cards)."\n";
  exit 0;
}

if ($buy) {
  to_buy ($cards);
  exit 0;
}

if ($de) {
  print_de ($cards);
  exit 0;
}

if (defined ($deck)) {
  print_deck ($cards, $deck);
} elsif ($by_decks) {
  print_decks ($cards, $deck_dir);
} else {
  print_stats ($cards, $by_class ? 'by_class' : 'by_set', $filters, $details_opt);
}

exit 0;