#!/usr/bin/perl

use strict;
use warnings;

use File::Find;
use Getopt::Long;

my $review_all = 0;
my $verbose = 0;
my $pattern;

GetOptions ('all!' => \$review_all,
            'verbose!' => \$verbose,
            'pattern=s' => \$pattern);

my $wb_dir = "bogus"

my $wordpress_api_key = "bogus"

my $akismet = Net::Akismet->new(KEY => $wordpress_api_key,
                                URL => "bogus");

my @deletes = ();
my @renames = ();

find(\&process_wb_file, ($wb_dir));

print ("DELETES: \n  ", join("\n  ", @deletes), "\n\n");
print ("RENAMES: \n  ", join("\n  ", @renames), "\n\n");

unlink($_) for @deletes;
rename($_.".new", $_) for @renames;

sub process_wb_file {
  return unless m/\.wb$/;

  if (defined $pattern) {
    return unless m/$pattern/;
  }

  open (my $fh, "<", $File::Find::name)
      or (warn("Can't open $File::Find::name: $!"), return);

  my %param;
  my $good_stuff = "";
  my $current = "";
  my $spammed = 0;

  foreach my $line (<$fh>) {
    $current .= $line;

    $line =~ /^(.+?): (.*)$/ and $param{$1} = $2;

    if ( $line =~ /^-----$/ ) {

      my %fields = (USER_IP => $param{'ip'});
      if ($param{'excerpt'}) {
        $fields{COMMENT_TYPE} = 'trackback';
        $fields{COMMENT_CONTENT} = $param{'title'} . "\n" . $param{'excerpt'};
        $fields{COMMENT_AUTHOR} = $param{'blog_name'};
        $fields{COMMENT_AUTHOR_URL} = $param{'url'};
      } else {
        $fields{COMMENT_TYPE} = 'comment';
        $fields{COMMENT_CONTENT} = $param{'title'} . "\n" . $param{'comment'};
        $fields{COMMENT_AUTHOR} = $param{'name'};
        $fields{COMMENT_AUTHOR_URL} = $param{'url'};
      }
      # REFERRER, PERMALINK, COMMENT_AUTHOR_EMAIL

      my $verdict = $akismet->check(%fields);

      if ('true' eq $verdict) {
        print "Found spam in $File::Find::name\n";
        use Data::Dumper;
        print Data::Dumper->Dump([\%fields]);
        print "Verify as spam and remove? [yn] ";
        my $answer = <STDIN>;
        if ($answer !~ /[yY]/) {
          $akismet->ham(%fields);
          $good_stuff .= $current;
        } else {
          $spammed = 1;
        }
      } else {
        if ($review_all) {
          print Data::Dumper->Dump([\%fields]);
          print "Is this spam? [yn] ";
          my $answer = <STDIN>;
          if ($answer !~ /[yY]/) {
            $good_stuff .= $current;
          } else {
            $akismet->spam(%fields);
            $spammed = 1;
          }
        } else {
          $good_stuff .= $current;
        }
      }

      $current = "";
    }
  }

  close ($fh);

  if ($verbose) {
    print "\n\nGood stuff in $File::Find::name is\n$good_stuff\n\n";
  }

  if ($good_stuff eq "") {
    push @deletes, $File::Find::name;
  } elsif ($spammed) {
    push @renames, $File::Find::name;
    open (my $new, ">", $File::Find::name . ".new");
    print $new $good_stuff;
    close $new;
  }
}



package Net::Akismet;

use 5.006;
use warnings;
use strict;
use integer;

use LWP::UserAgent;
use HTTP::Request::Common;

our $VERSION    = '0.01';

#
#       my $akismet = Net::Akismet->new(
#                       KEY => 'secret-baba-API-key',
#                       URL => 'http://example.blog.net/',
#               ) or die('Key verification failure!');
#
#       my $verdict = $akismet->check(
#                       USER_IP                 => '10.10.10.11',
#                       COMMENT_CONTENT         => 'Run, Lola, Run, the spam will catch you!',
#                       COMMENT_AUTHOR          => 'dosser',
#                       COMENT_AUTHOR_EMAIL     => 'dosser@subway.de',
#                       REFERRER                => 'http://lola.home/',
#               ) or die('Is the server here?');
#
#       if ('true' eq $verdict) {
#
#               print "I found spam. I am a spam-founder!\n";
#       }
#

sub new {

  my $that  = shift;
  my $class   = ref $that || $that;
  my %params  = @_;

  my $self = \%params;

  my $UA_SUFFIX = "Akismet Perl/$VERSION";

  $self->{ua} = LWP::UserAgent->new() or return undef;

  my $key   = $self->{KEY} or return undef;
  my $url   = $self->{URL} or return undef;

  my $agent = $params{USER_AGENT}? "$params{USER_AGENT} | " : '';

  $self->{ua}->agent($agent.$UA_SUFFIX);

  bless $self, $class;

  return $self->_verify_key()? $self : undef;
}

sub _verify_key {

  my $self  = shift;


  my $response = $self->{ua}->request(
    POST 'http://rest.akismet.com/1.1/verify-key',
    [
     key   => $self->{KEY},
     blog  => $self->{URL},
    ]
  );

  ($response && $response->is_success() && 'valid' eq $response->content()) or return undef;

  return 1;
}


sub check {

  my $self = shift;

  $self->_submit('comment-check', {@_}) or return undef;

  ('true' eq $self->{response} || 'false' eq $self->{response}) or return undef;

  return $self->{response};
}

sub spam {

  my $self = shift;

  return $self->_submit('submit-spam', {@_});
}

sub ham {

  my $self = shift;

  return $self->_submit('submit-ham', {@_});
}

sub _submit {

  my $self = shift;

  my $action = shift || 'comment-check';

  my $comment = shift;

  $comment->{USER_IP}   || return undef;

  my $response = $self->{ua}->request(
    POST "http://$self->{KEY}.rest.akismet.com/1.1/$action",
    [
     blog                  => $self->{URL},
     user_ip               => $comment->{USER_IP},
     user_agent            => $self->{ua}->agent(),
     referrer              => $comment->{REFERRER},
     permalink             => $comment->{PERMALINK},
     comment_type          => $comment->{COMMENT_TYPE},
     comment_author        => $comment->{COMMENT_AUTHOR},
     comment_author_email  => $comment->{COMMENT_AUTHOR_EMAIL},
     comment_author_url    => $comment->{COMMENT_AUTHOR_URL},
     comment_content       => $comment->{COMMENT_CONTENT},
    ]
  );

  ($response && $response->is_success()) or return undef;

  $self->{response} = $response->content();

  return 1;
}

1;