# SPDX-License-Identifier: CC0-1.0

{ buildPackages, targetPackages }:
with buildPackages;

let
  version = "20.05";
  genodeSources = let
    platform = targetPackages.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 stdenvNoCC.mkDerivation {
    pname = "genode-sources";
    inherit version;
    src = fetchurl {
      url = "https://github.com/genodelabs/genode/archive/${version}.tar.gz";
      hash = "sha256-5Fd8ywGbDtQF+9yDZ5xAQ7l1Vzh1jQAQeqVj+EtO1us=";
    };
    nativeBuildInputs = [ expect gnumake tcl ];
    patches = [ ./LIB.patch ./binary-labels.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";
  };

  toolchain = callPackage ./toolchain.nix { };

  stdenv' =
    targetPackages.stdenvAdapters.overrideCC targetPackages.stdenv toolchain;

  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="
    , patches ? [ ], ... }@args:
    let havePatches = patches != [ ];
    in stdenvNoCC.mkDerivation (args // {
      outputHashMode = "recursive";
      outputHash = hash;
      pname = name;
      inherit (genodeSources) version;
      inherit patches;

      GIT_SSL_CAINFO = "${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" ];

      src = if havePatches then genodeSources else null;
      dontUnpack = !havePatches;

      dontConfigure = true;

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

      buildPhase =
        # ignore the port hash, its only for the inputs
        ''
          runHook preBuild
          export CONTRIB_DIR=$NIX_BUILD_TOP/contrib
          export GENODE_DIR=${if havePatches then "$(pwd)" else genodeSources}
          mkdir $CONTRIB_DIR
          $GENODE_DIR/tool/ports/prepare_port $pname CHECK_HASH=no
          runHook postBuild
        '';

      installPhase =
        # strip non-deterministic and extra artifacts
        ''
          runHook preInstall
          chmod -R +w $CONTRIB_DIR/*
          find $CONTRIB_DIR/* -name .git -exec rm -rf {} \; || true
          find $CONTRIB_DIR/* -name .svn -exec rm -rf {} \; || true
          find $CONTRIB_DIR/* -name '*.t?z' -exec rm -rf {} \; || true
          find $CONTRIB_DIR/* -name '*.tar.*' -exec rm -rf {} \; || true

          mkdir $out
          cp -a $CONTRIB_DIR/* $out/
          runHook postInstall
        '';
    });

  ports = stdenv.lib.mapAttrs preparePort
    (import ./ports.nix { inherit buildPackages; });

  buildUpstream = { name, targets, portInputs ? [ ], nativeBuildInputs ? [ ]
    , patches ? [ ], enableParallelBuilding ? true, ... }@extraAttrs:
    let havePatches = patches != [ ];

    in stdenv'.mkDerivation (extraAttrs // {
      pname = name;
      inherit (genodeSources) version;
      inherit targets patches enableParallelBuilding;

      src = if havePatches then genodeSources else null;
      dontUnpack = !havePatches;

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

      configurePhase = let
        linkPorts = toString
          (builtins.map (drv: " ln -sv ${drv}/* $CONTRIB_DIR/;") portInputs);
      in ''
        runHook preConfigure
        export CONTRIB_DIR=$NIX_BUILD_TOP/contrib
        export BUILD_DIR=$(pwd)/build
        export GENODE_DIR=${if havePatches then "$(pwd)" else genodeSources}

        $GENODE_DIR/tool/create_builddir ${arch}
        substituteInPlace $BUILD_DIR/etc/build.conf \
          --replace "#REPOSITORIES" "REPOSITORIES"
        mkdir $CONTRIB_DIR; ${linkPorts}
        runHook postConfigure
      '';

      STRIP_TARGET_CMD = "cp $< $@";

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

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

  buildDepot = { name, apiOnly ? false, portInputs ? [ ]
    , nativeBuildInputs ? [ ], ... }@extraAttrs:

    stdenv'.mkDerivation (extraAttrs // {
      pname = name;
      inherit (genodeSources) version;
      enableParallelBuilding = true;

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

      src = genodeSources;
      # The genode source tree must be copied to the build directory
      # because the depot tool must modify the source tree as it runs.

      configurePhase = let
        copyPorts = # wasteful copy
          toString
          (builtins.map (drv: " cp -r ${drv}/* $CONTRIB_DIR/;") portInputs);
      in ''
        runHook preConfigure
        export GENODE_DIR=$(pwd)
        export CONTRIB_DIR=$GENODE_DIR/contrib
        export DEPOT_DIR=$GENODE_DIR/depot
        mkdir -p $CONTRIB_DIR; ${copyPorts}
        chmod +rwX -R .
        runHook postConfigure
      '';

      STRIP_TARGET_CMD = "cp $< $@";
      # defer strip until fixup phase

      makefile = "tool/depot/create";
      makeFlags = [
        "genodelabs/bin/${arch}/${name}"

        # by default the build system will refuse to be useful
        "FORCE=1"
        "KEEP_BUILD_DIR=1"
        "UPDATE_VERSIONS=1"
        "VERBOSE="
      ];

      installPhase = ''
        runHook preInstall
        rm -r depot/genodelabs/bin/${arch}/${name}/*\.build
        find depot/genodelabs/bin/${arch}/${name} -type f -exec install -Dt "''${!outputBin}" {} \;
        moveToOutput "lib*.so" "''${!outputLib}/lib"
        runHook postInstall
      '';

    });

  buildOverrides = callPackage ./targets.nix { inherit ports; };

  specs = with platform;
    [ ]

    ++ lib.optional is32bit "32bit"

    ++ lib.optional is64bit "64bit"

    ++ lib.optional isAarch32 "arm"

    ++ lib.optional isAarch64 "arm_64"

    ++ lib.optional isRiscV "riscv"

    ++ lib.optional isx86 "x86"

    ++ lib.optional isx86_32 "x86_32"

    ++ lib.optional isx86_64 "x86_64";

  genodeBase = buildUpstream {
    name = "base";
    targets = [ "LIB=vfs" ];
    postInstall =
      # The actual ld.lib.so is kernel specific
      # so ship the stubbed library for linking
      ''
        cp $BUILD_DIR/var/libcache/ld/ld.abi.so $out/ld.lib.so
        mkdir -p $out/include
        cp -r --no-preserve=mode \
          $GENODE_DIR/repos/base/include/* \
          $GENODE_DIR/repos/os/include/* \
          $GENODE_DIR/repos/demo/include/* \
          $GENODE_DIR/repos/gems/include/* \
          $out/include/
        for spec in ${toString specs}; do
          dir=$out/include/spec/$spec
          if [ -d $dir ]; then
            cp -r $dir/* $out/include/
          fi
        done
        rm -rf $out/include/spec
        cp -r $GENODE_DIR/repos/base/src/ld $out/ld
      '';
  };

in genodeSources // {
  inherit buildUpstream buildDepot ports specs toolchain genodeBase;

  make = target:
    let
      name = builtins.replaceStrings [ "/" ] [ "-" ] target;
      attrs = buildOverrides.${name} or { };
    in buildUpstream ({
      inherit name;
      targets = [ target ];
    } // attrs);

  depot = name:
    let attrs = buildOverrides.${name} or { };
    in buildDepot ({ inherit name; } // attrs);

}