#!/usr/bin/env perl

use v5.34;
use warnings;
use feature 'signatures';
no warnings ('experimental::signatures');
use Scalar::Util qw(looks_like_number);
use Getopt::Std ();

use JSON ();

use File::Basename ();
use File::Temp ();
use File::Fetch ();

use Digest::MD5 ();
use Digest::SHA ();
use MIME::Base64 ();

sub usage($fh) {
	print $fh <<~'EOF'
		Usage:
		  paku [-f FILE] ACTION
		  paku [-f FILE] -C CONFIG_PATH
		  paku -h
		EOF
}

sub help($fh) {
	print $fh <<~'EOF'


		Options:
		  -f FILE       use data from FILE (default: paku.lock)
		  -C CONFIG     get the final value of CONFIG_PATH
		  -h, --help    show this message

		  ACTION        what to emit, one of:
		                - guix
		                - debian
		                - alpine
		                - nix
		                - html
		                - guix-channel-key


		Generate package definitions for different package managers.


		Examples:

		  Emit Guix package definitions using all defaults:

		    $ paku guix > packages.scm
		    $ guix build -f packages.scm


		  Emit Debian build recipes from "debian.json", and execute
		  them as is:

		    $ paku -f debian.json debian | make -f-


		  Find out what is the final value of "datadir":

		    $ paku -C 'datadir'
		EOF
}


for (@ARGV) {
	last if $_ eq '--';
	if ($_ eq '--help') {
		usage *STDOUT;
		help *STDOUT;
		exit;
	}
}

my %opts;
if (!Getopt::Std::getopts('f:C:h', \%opts)) {
	usage *STDERR;
	exit 2;
}

if ($opts{h}) {
	usage *STDOUT;
	help *STDOUT;
	exit;
}


my $fname = $opts{f} || 'paku.lock';


sub load_json() {
	my $json_str = do {
		open my $fh, $fname or die "Failed opening \"$fname\"";
		local $/;
		<$fh>;
	};
	return JSON::decode_json($json_str);
}



sub get_in($j, @l) {
	my ($head, @tail) = @l;
	if (!defined $head) {
		return ref $j ?
			JSON::encode_json $j :
			$j;
	} elsif (looks_like_number($head)) {
		return get_in($j->[$head], @tail);
	} else {
		return get_in($j->{$head}, @tail);
	}
}

if ($opts{C}) {
	say get_in(load_json(), split(/\./, $opts{C}));
	exit;
}


my $licenses = {
	guix => {
		'AGPL-3.0-or-later' => 'agpl3+',
	},
	nix => {
		'AGPL-3.0-or-later' => 'agpl3Plus',
	},
};
sub license_for($target, $mappings, $id) {
	return $mappings->{$id} || $licenses->{$target}->{$id} || $id;
}

sub inputs_for($mappings, @inputs) {
	my @out = ();
	for (@inputs) {
		if (!$mappings->{$_}) {
			push @out, $_;
		} else {
			push @out, @{$mappings->{$_}};
		}
	}
	return @out;
}

sub emit_packages() {
	for (@ARGV) {
		my $fh;
		my $size = (stat($_))[7];

		open ($fh, '<', $_) or die "Can't open \"$_\": $!";
		my $md5  = Digest::MD5->new->addfile($fh)->hexdigest;
		close $fh;

		open ($fh, '<', $_) or die "Can't open \"$_\": $!";
		my $sha1 = Digest::SHA->new(1)->addfile($fh)->hexdigest;
		close $fh;

		open ($fh, '<', $_) or die "Can't open \"$_\": $!";
		my $sha256 = Digest::SHA->new(256)->addfile($fh)->hexdigest;
		close $fh;

		open ($fh, '<', $_) or die "Can't open \"$_\": $!";
		my $sha512 = Digest::SHA->new(512)->addfile($fh)->hexdigest;
		close $fh;

		print `ar -p $_ control.tar.xz | tar -xJO ./control`;
		say "Filename: ./$_";
		say "Size: $size";
		say "MD5sum: $md5";
		say "SHA1: $sha1";
		say "SHA256: $sha256";
		print "\n";
	}
}

sub emit_release() {
	my $f = $ARGV[0] or die 'Missing "Packages" file';
	my $name = File::Basename::basename $f;
	my $size = (stat($f))[7];

	my $now = `env LANG=POSIX.UTF-8 date -u '+%a, %d %b %Y %H:%M:%S +0000'`;
	chomp $now;

	my $fh;

	open ($fh, '<', $f) or die "Can't open \"$f\": $!";
	my $md5  = Digest::MD5->new->addfile($fh)->hexdigest;
	close $fh;

	open ($fh, '<', $f) or die "Can't open \"$f\": $!";
	my $sha1 = Digest::SHA->new(1)->addfile($fh)->hexdigest;
	close $fh;

	open ($fh, '<', $f) or die "Can't open \"$f\": $!";
	my $sha256 = Digest::SHA->new(256)->addfile($fh)->hexdigest;
	close $fh;

	open ($fh, '<', $f) or die "Can't open \"$f\": $!";
	my $sha512 = Digest::SHA->new(512)->addfile($fh)->hexdigest;
	close $fh;

	print <<~EOF;
		Date: $now
		MD5Sum:
		 $md5             $size $name
		SHA1:
		 $sha1             $size $name
		SHA256:
		 $sha256             $size $name
		SHA512:
		 $sha512             $size $name
		EOF
	exit;
}

sub emit_build_nix() {
	my $json = load_json();
	my $ns = $json->{namespace};
	$ns =~ s/\./-/g;
	print <<~EOF;
		{ pkgs ?
		  import <nixpkgs> { overlays = [ (import ./default.nix { inherit pkgs; }) ]; }
		}:

		map (name: pkgs.$ns."\${name}")
		    (builtins.attrNames pkgs.$ns)
		EOF
}

sub emit_nix() {
	my $json = load_json();
	my $ns = $json->{namespace};
	$ns =~ s/\./-/g;
	print <<~EOF;
		{ pkgs }:
		self: super: {
		  $ns = rec {
		EOF
	my $license_mapping = $json->{mappings}{nix}{licenses};
	for my $pkg (@{$json->{pkgs}}) {
		my $long = $pkg->{'long-description'};
		$long =~ s/^(.)/          $1/gm;
		my $license = license_for 'nix', $license_mapping, $pkg->{license};

		print <<~EOF;
		    $pkg->{'full-name'} = pkgs.stdenv.mkDerivation rec {
		      name = "$pkg->{name}";
		      version = "$pkg->{vlabel}";

		      src = fetchTarball {
		        url =
		          "$pkg->{url}";
		        sha256 = "$pkg->{sha256nix}";
		      };

		      nativeBuildInputs = with pkgs; [
		EOF

		for my $input (@{$pkg->{'native-inputs'}}) {
			print <<~EOF;
			        $input
			EOF
		}
		print <<~EOF;
		      ];

		      buildInputs = with pkgs; [
		EOF
		for my $input (@{$pkg->{inputs}}) {
			print <<~EOF;
			        $input
			EOF
		}
		print <<~EOF;
		      ];

		      makeFlags = [ "PREFIX=\$(out)" ];

		      doCheck = true;
		      enableParallelBuilding = true;

		      meta = with pkgs.lib; {
		        description = "$pkg->{description}";
		        longDescription = ''
		$long
		        '';
		        homepage = "$pkg->{homepage}";
		        changelog = "$pkg->{changelog}";
		        downloadPage = "$pkg->{'downloads-page'}";
		        license = licenses.$license;
		        platforms = platforms.unix;
		      };
		    };
		EOF
	}
	print <<~EOF;
	  };
	}
	EOF
}

sub emit_guix() {
	my $json = load_json();
	my $ns = $json->{namespace};
	$ns =~ s/\./ /g;
	print <<~EOF;
		(define-module ($ns packages)
		EOF
	for my $module (@{$json->{guix}{'module-use'}}) {
		print <<~EOF;
		  #:use-module (gnu packages $module)
		EOF
	}
	print <<~EOF;
	  #:use-module ((guix licenses) #:prefix licenses:)
	  #:use-module (guix gexp)
	  #:use-module (guix packages)
	  #:use-module (guix download)
	  #:use-module (guix build-system gnu))

	EOF

	my $pkg_mapping     = $json->{mappings}{guix}{packages};
	my $license_mapping = $json->{mappings}{guix}{licenses};
	my @pkgs = ();
	for my $pkg (@{$json->{pkgs}}) {
		my $long = $pkg->{'long-description'};
		$long =~ s/^(.)/          $1/gm;
		my $license = license_for 'guix', $license_mapping, $pkg->{license};

		push @pkgs, $pkg->{'full-name'};
		print <<~EOF;
		(define-public $pkg->{'full-name'}
		  (package
		    (name "$pkg->{name}")
		    (version "$pkg->{vlabel}")
		    (source
		      (origin
		        (method url-fetch)
		        (uri "$pkg->{url}")
		        (sha256
		          (base32 "$pkg->{sha256guix}"))))
		    (build-system gnu-build-system)
		    (native-inputs
		EOF

		print '      (list';
		for (inputs_for $pkg_mapping, @{$pkg->{'native-inputs'}}) {
			print "\n       $_";
		}
		print "))\n";

		print "    (inputs\n";
		print '      (list';
		for (inputs_for $pkg_mapping, @{$pkg->{inputs}}) {
			print "\n       $_";
		}
		print "))\n";

		print <<~EOF;
		    (arguments
		      (list
		       #:make-flags #~(list (string-append "PREFIX=" #\$output))
		       #:phases
		       #~(modify-phases %standard-phases
		           (delete 'configure))))
		    (synopsis "$pkg->{description}")
		    (description
		      "$pkg->{'long-description'}")
		    (home-page "$pkg->{homepage}")
		    (license licenses:$license)))

		EOF
	}
	print '(list';
	for (@pkgs) {
		print "\n $_";
	}
	print ")\n";
}

sub emit_guix_channel_key() {
	my $json = load_json();
	my $name = $json->{maintainer}{name};
	my $id   = $json->{maintainer}{email};
	print <<~EOF;
		.POSIX:

		$name.key:
			gpg --armour --export $id > \$\@
		EOF
}

sub emit_debian() {
	my $json = load_json();
	my @debs    = ();
	my @targets = ();

	for my $pkg (@{$json->{pkgs}}) {
		push @targets, <<~EOF;
			\$(DIR)/debian/tarballs/$pkg->{fname}:
				mkdir -p \$(\@D)
				wget -O \$\@ \\
					'$pkg->{url}'

			\$(DIR)/debian/builddirs/$pkg->{name}-$pkg->{vversion}: \$(DIR)/debian/tarballs/$pkg->{fname}
				mkdir -p \$(\@D)
				tar -C \$(\@D) -xf \$(DIR)/debian/tarballs/$pkg->{fname}
				touch \$\@

			EOF


		next if $pkg->{architectures} ne 'any';


		my $deb_name = "$pkg->{name}_" . (
			$pkg->{label} eq 'latest' ? 'latest' : $pkg->{vversion}
		) . "_all.deb";
		my $deb_path = "\$(DIR)/debian/public/$deb_name";

		push @debs, "\t$deb_path \\\n";

		my $ver = $pkg->{label} eq 'latest' ? '0.' . $pkg->{vversion} . '.latest' : $pkg->{vversion};
		$ver =~ s/^v//;

		push @targets, <<~EOF;
			\$(DIR)/debian/destdirs/$pkg->{name}-$pkg->{vversion}/DEBIAN: \$(DIR)/debian/builddirs/$pkg->{name}-$pkg->{vversion}
				\$(MAKE) \\
					-C \$(DIR)/debian/builddirs/$pkg->{name}-$pkg->{vversion} \\
					install \\
					PREFIX=/usr \\
					DESTDIR="\$\$PWD"/\$(\@D)
				mkdir -p \$\@
				touch \$\@

			\$(DIR)/debian/destdirs/$pkg->{name}-$pkg->{vversion}/DEBIAN/control: \$(DIR)/debian/destdirs/$pkg->{name}-$pkg->{vversion}/DEBIAN
				printf '' > \$\@
				printf 'Package: $pkg->{name}\\n'              >> \$\@
				printf 'Version: $ver\\n'                      >> \$\@
				printf 'Section: custom\\n'                    >> \$\@
				printf 'Depends:\\n'                           >> \$\@
				printf 'Priority: optional\\n'                 >> \$\@
				printf 'Architecture: all\\n'                  >> \$\@
				printf 'Essential: no\\n'                      >> \$\@

				printf 'Maintainer: '                          >> \$\@
				printf '$pkg->{"maintainer-b64"}' | base64 -d  >> \$\@
				printf '\\n'                                   >> \$\@

				printf 'Description: '                         >> \$\@
				printf '$pkg->{"description-b64"}' | base64 -d >> \$\@
				printf '\\n'                                   >> \$\@

				printf '$pkg->{'long-description-b64'}' | \\
					base64 -d |    \\
					sed 's|^\$\$|.|' | \\
					sed 's|^| |'                           >> \$\@
				printf '\\n'                                   >> \$\@

			\$(DIR)/debian/destdirs/$pkg->{name}-$pkg->{vversion}.deb: \$(DIR)/debian/destdirs/$pkg->{name}-$pkg->{vversion}/DEBIAN/control
				dpkg-deb --build \$(DIR)/debian/destdirs/$pkg->{name}-$pkg->{vversion}

			$deb_path: \$(DIR)/debian/destdirs/$pkg->{name}-$pkg->{vversion}.deb
				mkdir -p \$(\@D)
				cp \$(DIR)/debian/destdirs/$pkg->{name}-$pkg->{vversion}.deb \$\@


			EOF
	}


	print <<~EOF;
		.POSIX:

		DIR = $json->{datadir}

		debs = \\
		EOF
	print @debs, "\n";
	print <<~EOF;
		GPGKEY = '$json->{maintainer}{name} <$json->{maintainer}{email}>'


		all: \\
			\$(DIR)/debian/public/InRelease \$(DIR)/debian/public/Release.gpg \\
			\$(DIR)/debian/public/public-key.asc debian.out.txt

		debian.out.txt:
			\@printf '\$(DIR)/debian/public/*\\n' > \$\@


		\$(DIR)/debian/public/Packages: \$(debs)
			cd \$(\@D) && paku debian-packages *.deb > \$(\@F)

		\$(DIR)/debian/public/Release: \$(DIR)/debian/public/Packages
			paku debian-release \$(DIR)/debian/public/Packages > \$\@

		\$(DIR)/debian/public/Release.gpg: \$(DIR)/debian/public/Release
			gpg -abs -o \$\@ \$(DIR)/debian/public/Release

		\$(DIR)/debian/public/InRelease: \$(DIR)/debian/public/Release
			gpg --default-key \$(GPGKEY) -a --clear-sign -o \$\@ \$(DIR)/debian/public/Release

		\$(DIR)/debian/public/public-key.asc: \$(debs)
			gpg --armour --export \$(GPGKEY) > \$\@


		EOF
	print @targets;
}

sub emit_alpine() {
	my $d = $ARGV[0] or die 'Missing "src/alpine/" directory';
	my $json = load_json();
	for my $pkg (@{$json->{pkgs}}) {
		my @subpackages = ();
		if ($pkg->{manpages}) {
			push @subpackages, "$pkg->{name}-doc";
		}
		if ($pkg->{i18n}) {
			push @subpackages, "$pkg->{name}-lang";
		}

		my $date = $pkg->{date} =~ s/-//gr;
		my $ver = $pkg->{label} eq 'latest' ? "0.0.1_git$date" : $pkg->{vversion};
		my $dir = "$d/$pkg->{'full-name'}";
		mkdir "$dir";
		open(my $fh, '>', "$dir/APKBUILD");
		print $fh <<~EOF;
			# Maintainer: $pkg->{maintainer}
			pkgname='$pkg->{name}'
			pkgver='$ver'
			pkgrel='0'
			pkgdesc='$pkg->{description}'
			url='$pkg->{homepage}'
			arch='noarch'
			license='$pkg->{license}'
			depends=''
			makedepends=''
			checkdepends=''
			install=''
			subpackages='@subpackages'
			source='$pkg->{url}'
			pkgbasedir="\$startdir/.abuild/pkg"
			srcdir="\$startdir/.abuild/src"
			builddir="\$srcdir/$pkg->{name}-$pkg->{vversion}"

			build() {
				make PREFIX=/usr
			}

			check() {
				make check
			}

			package() {
				make install DESTDIR="\$pkgdir" PREFIX=/usr
			}

			cleanup_srcdir() {
				rm -rf "\$startdir/.abuild"
			}

			sha512sums='
			$pkg->{sha512}  $pkg->{fname}
			'
			EOF
		close $fh;
	}
	my @apks    = ();
	my @targets = ();

	for my $pkg (@{$json->{pkgs}}) {
		next if $pkg->{architectures} ne 'any';

		my $date = $pkg->{date} =~ s/-//gr;
		my $ver = $pkg->{label} eq 'latest' ? "0.0.1_git$date" : $pkg->{vversion};

		my $recipe_dir = "src/alpine/$pkg->{'full-name'}/";
		my $apk_name = "$pkg->{name}-$ver-r0.apk";
		my $apk_path = "\$(DIR)/alpine/REPODEST/alpine/x86_64/$apk_name";

		push @apks, "\t$apk_path \\\n";

		push @targets, <<~EOF;
			$apk_path: $recipe_dir/APKBUILD
				cd $recipe_dir && abuild \\
					-s \$\$OLDPWD/\$(DIR)/alpine/SRCDEST  \\
					-P \$\$OLDPWD/\$(DIR)/alpine/REPODEST \\
					sanitycheck clean fetch verify unpack build check rootpkg index clean

			EOF
	}


	print <<~EOF;
		.POSIX:

		DIR = $json->{datadir}
		RSAKEY = $json->{maintainer}{email}


		apks = \\
		EOF

	print @apks, "\n";
	print "\n\n";
	print <<~EOF;
		all: \$(apks) \$(DIR)/alpine/REPODEST/alpine/\$(RSAKEY).rsa.pub alpine.out.txt

		alpine.out.txt:
			\@printf '\$(DIR)/alpine/REPODEST/alpine/*\\n' > \$\@

		\$(apks): src/secrets/\$(RSAKEY).rsa

		\$(DIR)/alpine/REPODEST/alpine/\$(RSAKEY).rsa.pub: src/secrets/\$(RSAKEY).rsa
			mkdir -p \$(\@D)
			cp src/secrets/\$(RSAKEY).rsa.pub \$\@

		src/secrets/\$(RSAKEY).rsa: src/secrets/\$(RSAKEY).rsa.gpg
			gpg -d -o \$\@ \$\@.gpg
			chmod 400 \$\@

		EOF
	print @targets;
}

sub pascal_case($s) {
	return join('', map(ucfirst, split '-', $s))
}

sub emit_homebrew() {
	my $d = $ARGV[0] or die 'Missing "Formula/" directory';
	my $json = load_json();
	for my $pkg (@{$json->{pkgs}}) {
		open(my $fh, '>', "$d/$pkg->{'full-name'}.rb");
		my $class_name = pascal_case $pkg->{'full-name'};
		print $fh <<~EOF;
			class $class_name < Formula
			  desc '$pkg->{description}'
			  homepage '$pkg->{homepage}'
			  url '$pkg->{url}'
			  sha256 '$pkg->{sha256}'
			  license 'AGPL-3.0-or-later'

			  def install
			    system 'make',            "PREFIX=#{prefix}"
			    system 'make', 'check',   "PREFIX=#{prefix}"
			    system 'make', 'install', "PREFIX=#{prefix}"
			  end

			  test do
			    system "#{bin}/$pkg->{name}", '-V'
			  end
			end
			EOF
		close $fh;
	}
}

sub emit_html() {
	my $json = load_json();
	print <<~EOF;
		<!DOCTYPE html>
		<html lang="en">
		  <head>
		    <meta charset="UTF-8" />
		    <meta name="viewport" content="width=device-width, initial-scale=1" />
		    <link rel="icon" type="image/svg+html" href="favicon.svg" />
		    <title>$json->{name} package index</title>

		    <style>
		      body {
		        max-width: 800px;
		        margin: 0 auto;
		      }

		      ul {
		        list-style: none;
		      }

		      li {
		        margin-top: 2em;
		      }

		      pre {
		        overflow: auto;
		        white-space: pre;
		        margin: 5px;
		        padding: 5px;
		        border-radius: 5px;
		      }

		      pre, code {
		        background-color: #ddd;
		      }

		      \@media(prefers-color-scheme: dark) {
		        :root {
		          color: white;
		          background-color: black;
		        }

		        a {
		          color: hsl(211, 100%, 60%);
		        }

		        a:visited {
		          color: hsl(242, 100%, 80%);
		        }

		        pre, code {
		          background-color: #222;
		        }
		      }
		    </style>
		  </head>
		  <body>
		    <main>
		      <h1>
		        $json->{name} package index
		      </h1>
		      <ul>
		EOF

	for my $pkg (@{$json->{pkgs}}) {
		my $guix_suffix = $pkg->{label} eq 'latest' ? '' : "\@$pkg->{version}";
		my $apt_suffix  = $pkg->{label} eq 'latest' ? '' : "=$pkg->{label}";
		my $id = $pkg->{name} . (
			$pkg->{label} eq 'latest' ? '' : "-$pkg->{vversion}"
		);
		print <<~EOF;
		        <li id="$id">
		          <details>
		            <summary>
		              <a href="#$id">$pkg->{name}</a>
		              ($pkg->{vname}) - $pkg->{description}
		            </summary>
		            <p>
		            <a href="$pkg->{homepage}">Homepage</a>
		            </p>
		            <section>
		              <h2>Guix</h2>
		              <p>
		                After following the
		                <a href="#guix-instructions">Guix instructions</a>
		                to include this channel, you can launch a shell
		                that includes this package:
		              </p>
		              <pre><code>\$ guix shell $pkg->{name}$guix_suffix</code></pre>
		              <p>
		                Alternatively, you can install it imperatively:
		              </p>
		              <pre><code>\$ guix install $pkg->{name}$guix_suffix</code></pre>
		            </section>
		            <section>
		              <h2>Debian</h2>
		              <p>
		                After following the
		                <a href="#debian-instructions">Debian instructions</a>
		                to include this repository to
		                <code>/etc/apt/sources.list</code>, you can
		                install it:
		              </p>
		              <pre><code># apt install $pkg->{name}$apt_suffix</code></pre>
		            </section>
		            <section>
		              <h2>Alpine</h2>
		              <p>
		                After folowwing the
		                <a href="#alpine-instructions">Alpine instructions</a>
		                to include this repository to
		                <code>/etc/apk/repositories</code>, you can
		                install it:
		              </p>
		              <pre><code># apk add $pkg->{name}</code></pre>
		            </section>
		            <section>
		              <h2>Nix</h2>
		              <p>
		                After following the
		                <a href="#nix-instructions">Nix instructions</a>
		                to include this repository as an overlay, you
		                can launch a shell that includes this package:
		              </p>
		              <pre><code>\$ nix-shell -p $pkg->{'full-name'}</code></pre>
		              <p>
		                Alternatively, you can install it imperatively:
		              </p>
		              <pre><code>\$ nix-env -i $pkg->{'full-name'}</code></pre>
		            </section>
		            <section>
		              <h2>Homebrew</h2>
		              <p>
		                After following the
		                <a href="#homebrew-instructions">Homebrew instructions</a>
		                to include this repository as a <code>tap</code>, you can
		                install it with:
		              </p>
		              <pre><code>\$ brew install $pkg->{'full-name'}</code></pre>
		            </section>
		          </details>
		        </li>
		EOF
	}

	my $channel_name = $json->{namespace} =~ s/\./-/gr;
	my $overlay_name = $json->{namespace} =~ s/\./-/gr;
	my $tap_name     = $json->{namespace} =~ s/\./\//gr;
	print <<~EOF;
		      </ul>
		      <article id="guix-instructions">
		        <h2>Guix instructions</h2>
		        <p>
		          Add this channel to your
		          <code>~/.config/guix/channels.scm</code>:
		        </p>
		        <pre><code>(cons*
		 (channel
		  (name '$channel_name)
		  (url "$json->{vcs}->{git}")
		  (branch "main")
		  (introduction
		   (make-channel-introduction
		    "d749e053e6db365069cb9b2ef47a78b06f9e7361"
		    (openpgp-fingerprint
		     "5BDA E9B8 B2F6 C6BC BB0D  6CE5 81F9 0EC3 CD35 6060"))))
		 %default-channels)</code></pre>
		        <p>
		          Afterwards, do a <code>guix pull</code> to make the
		          packages in this channel available to your profile.
		        </p>
		        <p>
		          See also the
		          <a href="https://guix.gnu.org/manual/en/guix.html#Channels">Guix manual on channels</a>
		          for more information.
		        </p>
		      </article>
		      <article id="debian-instructions">
		        <h2>Debian instructions</h2>
		        <p>
		          Include my public key for validating the repository
		          signatures:
		        </p>
		        <pre><code>\$ wget -qO- $json->{'base-url'}/debian/public-key.asc |
		    sudo tee /etc/apt/trusted.gpg.d/$json->{namespace}.asc</code></pre>
		        <p>
		          Afterwards, include this repository to the list of
		          repositories that <code>apt(8)</code> uses for sources
		          by adding its URL to
		          <code>/etc/apt/sources.list</code>:
		        </p>
		        <pre><code>\$ echo 'deb $json->{'base-url'}/debian ./' |
		    sudo tee -a /etc/apt/sources.list
		\$ sudo apt update</code></pre>
		        <p>
		          After that the packages from this repository will
		          be available.
		        </p>
		      </article>
		      <article id="alpine-instructions">
		        <h2>Alpine instructions</h2>
		        <p>
		          Get my public key used to sign the repository:
		        </p>
		        <pre><code>\$ wget -qO- $json->{'base-url'}/alpine/$json->{maintainer}{email}.rsa.pub |
		    doas tee /etc/apk/keys/$json->{maintainer}{email}.rsa.pub</code></pre>
		        <p>
		          Then include this repository in the
		          <code>apk-repositories(5)</code> list that
		          <code>apk(8)</code> uses to retrive package files for
		          installation:
		        </p>
		        <pre><code>\$ echo '$json->{'base-url'}/alpine' |
		    doas tee -a /etc/apk/repositories</code></pre>
		        <p>
		          After that the packages frmo this repository will be
		          available.
		        </p>
		      </article>
		      <article id="nix-instructions">
		        <h2>Nix instructions</h2>
		        <p>
		          Add this repository as an overlay to your
		          <code>/etc/nixos/configuration.nix</code>:
		        </p>
		        <pre><code>  nixpkgs = {
		    overlays = [
		      (import (fetchTarball {
		        url = "$json->{vcs}->{tarball}";
		      }) { inherit pkgs; })
		    ];
		  };</code></pre>
		        <p>
		          All the packages live under the
		          <code>$overlay_name</code> attribute set, like.
		          <code>$overlay_name.$json->{pkgs}[0]->{name}</code>,
		          so it can be included in the list of packages:
		        </p>
		        <pre><code>  environment.systemPackages = with pkgs; [
		    ...
		    $overlay_name.$json->{pkgs}[0]->{name}
		  ];</pre></code>
		        <p>
		          To make the overlay available outside the system
		          environment of
		          <code>/etc/nixos/configuration.nix</code>, you need to
		          add this overlay to your
		          <code>~/.config/nixpkgs/overlays/</code> directory,
		          like a
		          <code>~/.config/nixpkgs/overlays/$json->{namespace}.nix</code>
		          file containing:
		        </p>
		        <pre><code>import (fetchTarball {
		  url = "$json->{vcs}->{tarball}";
		}) { pkgs = import &lt;nixpkgs&gt; {}; }</pre></code>
		        <p>
		          Then you'd be able to launch a shell with a package
		          from this overlay:
		        </p>
		        <pre><code>\$ nix-shell -p $overlay_name.$json->{pkgs}[0]->{name}</code></pre>
		      </article>
		      <article id="homebrew-instructions">
		        <h2>Homebrew instructions</h2>
		        <p>
		          Add this repository as a tap:
		        </p>
		        <pre><code>\$ brew tap --force-auto-update $tap_name $json->{vcs}->{http}</code></pre>
		        <p>
		          The explicit <code>--force-auto-update</code> option
		          is required, because <code>homebrew(1)</code> will only
		          fetch updates automatically for repositories hosted on
		          GitHub.  With this option, repositories not on GitHub
		          are treated equally.
		        </p>
		      </article>
		    </main>
		  </body>
		</html>
		EOF
}


sub run_template($name, $version, $template) {
	return ($template =~ s/\@name\@/$name/gr) =~ s/\@version\@/$version/gr;
}

sub set_difference($s1, $s2) {
	my %idx = ();
	for (@{$s1}) {
		$idx{$_} = 1;
	}
	for (@{$s2}) {
		delete $idx{$_};
	}
	return keys(%idx);
}

sub emit_refresh() {
	my $json_str = do {
		local $/;
		<STDIN>;
	};
	my $json = JSON::decode_json($json_str);

	my $defaults = {
		datadir => '.paku',
		guix => {},
		mappings => {},
		maintainer => {
			name => '',
			email => '',
		},
		namespace => '',
		name => '',
		'base-url' => '',
		vcs => {
			git => '',
			http => '',
			tarball => '',
		},
		pkgs => [],
	};
	my $out = {
		%$defaults,
		%$json,
	};

	my $default_package = {
		maintainer     => $out->{defaults}{maintainer} || '',
		'exclude-tags' => [],
	};
	for my $package_any (@{$out->{packages}{any}}) {
		my $package = ref $package_any ?
			{ %$default_package, %$package_any } :
			{ %$default_package, name => $package_any };

		my $repo_url = run_template($package->{name}, '', $out->{defaults}{templates}{repository});
		my $dir = File::Temp::newdir();
		`git clone '$repo_url' '$dir'`;
		die if $?;

		my @versions = ();
		my $tags_any = $package->{tags} || $out->{defaults}{versions}{tags};
		my @tags = ();
		if (ref $tags_any) {
			push @tags, @$tags_any;
		} elsif ($tags_any eq 'all') {
			my @ret = `git -C '$dir' tag`;
			die if $?;
			chomp @ret;

			push @tags, set_difference(\@ret, $package->{'exclude-tags'});
		} else {
			die "Unknown value of \"tags\": $tags_any";
		}

		for (@tags) {
			my $ver = $_ =~ s/^v//gr;
			my %version = (
				type     => 'tag',
				vversion => $_,
				version  => $ver,
				vname    => $_,
				vlabel   => $ver,
				label    => $ver =~ s/\./-/gr,
			);
			push @versions, \%version;
		}

		my $default_branch =
			$package->{default_branch} ||
			$out->{defaults}{default_branch} ||
			'main';
		my $branches = $package->{branches} || $out->{defaults}{versions}{branches};
		for (@{$branches}) {
			my $revision = `git -C '$dir' rev-parse '$_'`;
			die if $?;
			chomp $revision;

			my $label = $_ eq $default_branch ? 'latest' : $_;

			my %version = (
				type     => 'branch',
				vversion => $revision,
				version  => $_,
				vname    => $label,
				vlabel   => $revision,
				label    => $label,
			);
			push @versions, \%version;
		}

		for my $version (@versions) {
			my $pkg = {
				%$version,
				name => $package->{name},
				architectures => 'any',
			};

			my $full_name = $pkg->{name} . (
				$pkg->{label} eq 'latest' ? '' : "-$pkg->{label}"
			);
			$pkg->{'full-name'} = $full_name;

			my $revision = `git -C '$dir' rev-parse '$pkg->{vversion}'`;
			die if $?;
			chomp $revision;
			$pkg->{revision} = $revision;

			`git -C '$dir' checkout '$pkg->{vversion}'`;
			die if $?;
			my $url = run_template($package->{name}, $pkg->{vversion}, $out->{defaults}{templates}{tarball});
			$pkg->{url} = $url;

			my $date = `git -C '$dir' log -1 --format=%cs`;
			die if $?;
			chomp $date;
			$pkg->{date} = $date;

			$pkg->{manpages} = -d "$dir/doc/" ? JSON::true : JSON::false;
			$pkg->{i18n}     = -d "$dir/po/"  ? JSON::true : JSON::false;

			for (qw(description long-description)) {
				my $s = do { local(@ARGV, $/) = "$dir/$_"; <> };
				chomp $s;
				$pkg->{$_} = $package->{$_} || $s;
			}

			my @sha_guix = `guix download '$url'`;
			die if $?;
			chomp @sha_guix;
			$pkg->{sha256guix} = $sha_guix[-1];

			my $sha_nix = `nix-prefetch-url --unpack '$url'`;
			die if $?;
			chomp $sha_nix;
			$pkg->{sha256nix} = $sha_nix;


			my $ff = File::Fetch->new(uri => $url);
			my $where = $ff->fetch(to => '/tmp');
			my $fh;

			open ($fh, '<', $where) or die "Can't open \"$where\": $!";
			my $sha256 = Digest::SHA->new(256)->addfile($fh)->hexdigest;
			close $fh;
			$pkg->{sha256} = $sha256;

			open ($fh, '<', $where) or die "Can't open \"$where\": $!";
			my $sha512 = Digest::SHA->new(512)->addfile($fh)->hexdigest;
			close $fh;
			$pkg->{sha512} = $sha512;

			unlink $where;


			for (qw(base-url homepage changelog downloads-page fname)) {
				$pkg->{$_} = $package->{$_} ||
					run_template(
						$pkg->{name},
						$pkg->{vversion},
						$out->{defaults}{templates}{$_}
					);
			}

			for (qw(inputs native-inputs)) {
				$pkg->{$_} = $package->{$_} || [];
			}

			for (qw(maintainer license)) {
				$pkg->{$_} = $package->{$_} || $out->{defaults}{$_};
			}

			for (qw(maintainer description long-description)) {
				$pkg->{"$_-b64"} = MIME::Base64::encode_base64($pkg->{$_}, '');
			}

			push @{$out->{pkgs}}, $pkg;
		}
	}
	print JSON->new->pretty->canonical->encode($out);
}


my %actions = (
	'debian-packages'  => \&emit_packages,
	'debian-release'   => \&emit_release,
	'build-nix'        => \&emit_build_nix,
	nix                => \&emit_nix,
	guix               => \&emit_guix,
	'guix-channel-key' => \&emit_guix_channel_key,
	debian             => \&emit_debian,
	alpine             => \&emit_alpine,
	homebrew           => \&emit_homebrew,
	html               => \&emit_html,
	refresh            => \&emit_refresh,
);

my $action = $ARGV[0] or die "Missing ACTION";
shift;
my $fn = $actions{$action} or die "Unknown ACTION: \"$action\"";
&$fn;