{ nixpkgs, addManifest }:

let
  genodeSources = let
    inherit (nixpkgs) stdenv;
    platform = stdenv.targetPlatform;

    arch = with platform;
      if isx86_64 then
        "x86_64"
      else
        throw "unknown Genode arch for platform ${platform.system}";

    toolPrefix = if platform.isx86 then
      "genode-x86-"
    else
      throw "unknown tool prefix for Genode arch ${arch}";
  in stdenv.mkDerivation {
    pname = "genode-sources";
    inherit (nixpkgs.genodeHeaders) src version;
    nativeBuildInputs = with nixpkgs.buildPackages; [ expect gnumake tcl ];
    patches = [ ./init.xsd.patch ./svn-trust-server-cert.patch ];
    configurePhase = ''
      patchShebangs ./tool
      substituteInPlace repos/base/etc/tools.conf \
        --replace "/usr/local/genode/tool/19.05/bin/" ""
      substituteInPlace tool/check_abi \
        --replace "exec nm" "exec ${toolPrefix}nm"
    '';
    dontBuild = true;
    installPhase = "cp -a . $out";
  };

  sourceForgeToolchain = nixpkgs.buildPackages.callPackage ./toolchain.nix { };

  stdenv' =
    nixpkgs.stdenvAdapters.overrideCC nixpkgs.stdenv sourceForgeToolchain;

  platform = stdenv'.targetPlatform;

  arch = with platform;
    if isx86_64 then
      "x86_64"
    else
      throw "unknown Genode arch for platform ${platform.system}";

  preparePort = name:
    { hash ? "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", ... }@args:
    nixpkgs.buildPackages.stdenv.mkDerivation (args // {
      outputHashMode = "recursive";
      outputHash = hash;
      pname = name;
      inherit (genodeSources) version;

      GIT_SSL_CAINFO =
        "${nixpkgs.buildPackages.cacert}/etc/ssl/certs/ca-bundle.crt";
      VERBOSE = "";
      # need to build in verbose mode because errors are hidden

      impureEnvVars = stdenv'.lib.fetchers.proxyImpureEnvVars
        ++ [ "GIT_PROXY_COMMAND" "SOCKS_SERVER" ];

      dontUnpack = true;
      dontConfigure = true;

      nativeBuildInputs = with nixpkgs.buildPackages;
        [ bison flex gitMinimal glibc glibcLocales rsync wget which ]
        ++ (args.nativeBuildInputs or [ ]);

      buildPhase = ''
        runHook preBuild
        export CONTRIB_DIR=$NIX_BUILD_TOP/contrib
        mkdir $CONTRIB_DIR
        ${genodeSources}/tool/ports/prepare_port $pname
        runHook postBuild
      '';

      installPhase = ''
        runHook preInstall
        rsync $CONTRIB_DIR/* $out/ \
          -lr --copy-unsafe-links \
          --exclude '*.git' \
          --exclude '*.svn' \
          --exclude '*.gz' \
          --exclude '*.xz' \

        runHook postInstall
      '';
    });

  ports =
    nixpkgs.lib.mapAttrs preparePort (import ./ports.nix nixpkgs.buildPackages);

  buildUpstream = { name, targets, portInputs ? [ ], nativeBuildInputs ? [ ]
    , ... }@extraAttrs:

    let
      drv = stdenv'.mkDerivation (extraAttrs // {
        pname = name;
        inherit (genodeSources) version;
        inherit targets;

        dontUnpack = true;

        nativeBuildInputs = with nixpkgs.buildPackages;
          [ binutils bison flex stdenv.cc tcl which ] ++ nativeBuildInputs;

        enableParallelBuilding = true;

        configurePhase = let
          linkPorts = toString
            (builtins.map (drv: " ln -sv ${drv}/* contrib/;") portInputs);
        in ''
          runHook preConfigure
          export CONTRIB_DIR=$NIX_BUILD_TOP/contrib
          export BUILD_DIR=$NIX_BUILD_TOP/build
          ${genodeSources}/tool/create_builddir ${arch}
          substituteInPlace build/etc/build.conf \
            --replace "#REPOSITORIES" "REPOSITORIES"
          mkdir $CONTRIB_DIR; ${linkPorts}
          runHook postConfigure
        '';

        makeFlags = [ "-C build" ] ++ targets;

        installPhase = ''
          runHook preInstall
          find build/bin -name '*.xsd' -delete
          find build/bin -follow -type f -exec install -Dt $out '{}' \;
          runHook postInstall
        '';
      });
    in addManifest drv;

  buildOverrides = import ./targets.nix {
    inherit (nixpkgs) buildPackages;
    inherit ports;
  };

in {
  inherit buildUpstream;
  genodeSources = genodeSources // {
    make = target:
      with builtins;
      let
        attrs = if hasAttr target buildOverrides then
          getAttr target buildOverrides
        else
          { };
      in buildUpstream ({
        name = builtins.replaceStrings [ "/" ] [ "-" ] target;
        targets = [ target ];
      } // attrs);
    inherit ports;
  };

}