#!/usr/bin/env perl
use v5.24;
use warnings;
use experimental 'signatures';
no warnings 'experimental::signatures';

use FindBin '$Bin';
use lib "$Bin/local/lib/perl5";

use constant LIMIT => 1268;
use constant PAGE_SIZE => 'A4';
use constant X_PAGE_SIZE => 595;
use constant Y_PAGE_SIZE => 842;
use constant MIN_MARGIN => 30;
use constant BASE64_LINE_LENGTH => 76;
use constant LINES_PER_SLICE => 16;

use Imager::QRCode;
use Image::Magick;
use Barcode::ZBar;
use PDF::API2;
use Path::Tiny;
use Compress::Zlib qw< compress uncompress >;
use MIME::Base64 qw< encode_base64 decode_base64 >;

help_die() unless @ARGV == 3;
my ($command, $input, $output) = @ARGV;

if ($command eq 'encode') {
   encode($input, $output);
}
elsif ($command eq 'decode') {
   decode($input, $output);
}
else {
   help_die();
}

sub help_die {
   die "$0 <encode|decode> <input-file> <output-file>\n";
}

sub encode ($input, $output) {
   my $data = compress(path($input)->slurp_raw, 9) or die "compress()\n";
   assemble_pdf(qrcoder_it(slicer_it($data)))->save($output);
   return 0;
}

sub decode ($input, $output) {
   my $data = assemble_data(slice_reader_it(pdf_reader_it($input)));
   path($output)->spew_raw(uncompress($data));
   return 0;
}

sub assemble_pdf ($it) {
   my $x_margin = MIN_MARGIN;
   my $size = X_PAGE_SIZE - 2 * MIN_MARGIN;
   my $y_margin = int((Y_PAGE_SIZE - $size) / 2);
   my $pdf = PDF::API2->new;
   $pdf->default_page_size(PAGE_SIZE);
   while (my $png = $it->()) {
      print {*STDERR} '.';
      open my $fh, '<:raw', \$png or die "open(): $!\n";
      my $image = $pdf->image($fh);
      $pdf->page->object($image, $x_margin, $y_margin, $size, $size);
   }
   print {*STDERR} "\n";
   return $pdf;
}

sub qrcoder_it ($it) {
   my $qrcode = Imager::QRCode->new(
      size          => 8,
      margin        => 2,
      mode          => '8-bit',
      version       => 1,
      level         => 'H',
      casesensitive => 1,
      lightcolor    => Imager::Color->new(255, 255, 255),
      darkcolor     => Imager::Color->new(0, 0, 0),
   );
   return sub {
      my $data = $it->() // return;
      my $img = $qrcode->plot($data)->to_paletted;
      my $retval;
      $img->write(data => \$retval, type => 'png')
        or die "Failed to write: " . $img->errstr;
     return $retval;
   }
}

sub slicer_it ($data) {
   my @encoded = split m{\n}mxs, encode_base64($data);
   my $n_slice = 0;
   return sub {
      return unless @encoded;
      my @payload = splice @encoded, 0, LINES_PER_SLICE;
      my $header = $n_slice++ . (@encoded ? '+' : '.');
      return join "\n", $header, @payload, '';
   };
}

sub assemble_data ($it) {
   my @slices;
   while (my $slice = $it->()) {
      print {*STDERR} '.';
      push @slices, $slice;
   }
   print {*STDERR} "\n";
   @slices = sort { $a->{n} <=> $b->{n} } @slices;
   for my $n (0 .. $#slices) {
      die "missing slice $n\n" if $slices[$n]{n} != $n;
   }
   die "missing trailing slices\n" unless $slices[-1]{last};
   my $data = join '', map { $_->{data} } @slices;
   return decode_base64($data);
}

sub slice_reader_it ($it) {
   my $scanner = Barcode::ZBar::ImageScanner->new();
   $scanner->parse_config("enable");
   return sub {
      my $page = $it->() or return;

      my $image = Barcode::ZBar::Image->new();
      $image->set_format('Y800');
      $image->set_size($page->Get(qw(columns rows)));
      $image->set_data($page->ImageToBlob(magick => 'GRAY', depth => 8));

      my $n = $scanner->scan_image($image);

      return map {
         my ($header, $data) = split m{\n}mxs, $_->get_data, 2;
         my ($n, $more) = $header =~ m{\A (\d+) ([+.]) \z}mxs;
         return {
            n => $n,
            last => ($more eq '.' ? 1 : 0),
            data => $data,
         };
      } $image->get_symbols;
   }
}

sub pdf_reader_it ($file) {
   my $magick = Image::Magick->new();
   die if $magick->Read($file); # returns 0 on success
   my $n = 0;
   return sub {
      return if $n > $magick->$#*;
      return $magick->[$n++];
   };
}