#!/usr/bin/perl -w -s

use Crypt::Classics;

my $nops =
  (defined($help     )?1:0) +

  (defined($caesar   )?1:0) +
  (defined($ucaesar  )?1:0) +
  (defined($acaesar  )?1:0) +

  (defined($linear   )?1:0) +
  (defined($ulinear  )?1:0) +
  (defined($alinear  )?1:0) +

  (defined($generic  )?1:0) +
  (defined($ugeneric )?1:0) +
  (defined($genericf )?1:0) +
  (defined($ugenericf)?1:0) +

  (defined($vigenere )?1:0) +
  (defined($uvigenere)?1:0) +

  (defined($transpose)?1:0) +
  (defined($utranspose)?1:0) +

  (defined($charOccurrence)?1:0) +
  (defined($nOccurrence)?1:0) +
  (defined($coincidenceIndex)?1:0) +

  0;

if ($nops != 1 || defined($help)) {
  if ($nops > 1) {
    print "\nOnly one codification method is available at a time\n\n";
  }
  print <<"HELP";

--[ ccrypt ]---[ classics cryptography methods ]--------------------------

 usage:

  -help           prints this help screen

 ---( Caesar codification )---

  -caesar=n       codifies using caeser method. n is the rotation size;
  -ucaesar=n      uncodifies using caesar method, for a message
                  codified with rotation size n;
  -acaesar        uses brute force to uncode a caesar codified message;

 ---( Linear codification )---

  -linear=ax+b    codifies using linear method for a x + b (mod 26);
  -ulinear=ax+b   uncodifies using linear method for a x + b (mod 26)
                  codification;
  -alinear        uses brute force to uncode a linear codified message;

 ---( Generic codification )---

  -generic=KEY    codifies using generic crypt with supplied key;
  -ugeneric=KEY   uncodifies using generic crypt method;

  -genericf=file  codifies using generic crypt where file contains the
                  key. See the POD to check the syntax;
  -ugenericf=file uncode using generic crypt where file contains the key

 ---( Vigenère codification )---

  -vigenere=KEY   codifies using Vigenère crypt method;
  -uvigenere=KEY  uncode using Vigenère crypt method;

 ---( Transposition codification )--

  -transpose=n    transpose with n columns;
  -utranspose=n   un-code using transpose codification with n columns

 ---( Miscellaneous tools )---

  -charOccurrence              counts how many times each character appears
  -nOccurrence=n               counts how many times each n length strings
                               appear
  -coincidenceIndex=tableFile  calculates the coincidence index

------------------------------------[ (c)2002 Alberto M. B. Simões ]-----

HELP
} else {

  if (defined($coincidenceIndex)) {
    if (-f $coincidenceIndex) {
      print Crypt::Classics::coincidenceIndex($coincidenceIndex),"\n";
    } else {
      open TMP, ">/tmp/_${$}_" or die "Cannot create temporary file";
      while(<>) {
	print TMP;
      }
      close TMP;
      print Crypt::Classics::coincidenceIndex("/tmp/_${$}_"),"\n";
      unlink "/tmp/_${$}_";
    }
    exit;
  }

  my %table;

  %table = Crypt::Classics::tableFromString(uc($generic)) if ($generic);
  %table = Crypt::Classics::tableFromString(uc($ugeneric)) if ($ugeneric);

  %table = Crypt::Classics::loadSubsTable($genericf) if ($genericf);
  %table = Crypt::Classics::loadSubsTable($ugenericf) if ($ugenericf);

  my %occur = ();

  undef $/;
  my $text = <>;
  for ($text) {

    ###
    #
    #  Caesar methods
    #
    if (defined($caesar)) {
      print Crypt::Classics::Caesar($caesar,$_);
    }

    elsif (defined($ucaesar)) {
      print Crypt::Classics::uCaesar($ucaesar,$_);
    }

    elsif (defined($acaesar)) {
      my %d = Crypt::Classics::aCaesar($_);
      for (my $x=0; $x<26; $x++) {
	print "$x:$d{$x}\n";
      }
    }

    ###
    #
    #  Linear methods
    #
    elsif (defined($linear)) {
      $linear =~ /^(\d+)x\+(\d+)$/;
      my ($a,$b) = ($1,$2);
      print Crypt::Classics::Linear($a,$b,$_);
    }

    elsif (defined($ulinear)) {
      $ulinear =~ /^(\d+)x\+(\d+)$/;
      my ($a,$b) = ($1,$2);
      print Crypt::Classics::uLinear($a,$b,$_);
    }

    elsif (defined($alinear)) {
      my $data = Crypt::Classics::aLinear($_);
      for my $x (sort { $a <=> $b } keys %$data) {
	for my $y (sort { $a <=> $b } keys %{$data->{$x}}) {
	  print sprintf("(%2d,%2d) %s\n", $x, $y, $data->{$x}{$y});
	}
      }
    }

    ####
    #
    # Generic methods
    #
    elsif (defined($generic) || defined($genericf)) {
      print Crypt::Classics::GenericCrypt($_,%table);
    }

    elsif (defined($ugeneric) || defined($ugenericf)) {
      print Crypt::Classics::uGenericCrypt($_,%table);
    }

    ####
    #
    # Vigenère methods
    #
    elsif (defined($vigenere)) {
      print Crypt::Classics::Vigenere($_, uc($vigenere));
    }

    elsif (defined($uvigenere)) {
      print Crypt::Classics::uVigenere($_, uc($vigenere));
    }

    ####
    #
    # Tranpose methods
    #
    elsif (defined($transpose)) {
      print Crypt::Classics::Transpose($_, $transpose);
    }

    elsif (defined($utranspose)) {
      print Crypt::Classics::uTranpose($_, $utranspose);
    }

    ####
    #
    # Occurrence counter tool
    elsif (defined($charOccurrence)) {
      my %tmp = Crypt::Classics::charOccurrence($_);
      # I thinks this line can be removed... but we never know
      for (keys %tmp) { $occur{$_} += $tmp{$_} };
    }
    elsif (defined($nOccurrence)) {
      my %tmp = Crypt::Classics::nOccurrence($_,$nOccurrence);
      # I thinks this line can be removed... but we never know
      for (keys %tmp) { $occur{$_} += $tmp{$_} };
    }


  }

  if (defined($charOccurrence) || defined($nOccurrence)) {
    for (sort {$occur{$b} <=> $occur{$a}} keys %occur) {
      print "$_ $occur{$_}\n";
    }
  }




}