default.nix

{ # host package set (unused except for fetching nixpkgs)
  hostPkgs        ? import <nixpkgs> {}

, # versioned nixpkgs
  pkgs            ? import (hostPkgs.nix-update-source.fetch ./pkgs.json).src {}

, # versioned nixpkgs-older version for zmcat
  pkgs-old        ? import (hostPkgs.nix-update-source.fetch ./pkgs-old.json).src {}

, # fetcher alias for the remaining arguments
  fetched         ? s: (pkgs.nix-update-source.fetch s).src

, #source overrides: core nrm components
  aml-src         ? fetched aml/pin.json
, libnrm-src      ? fetched libnrm/pin.json
, nrm-src         ? fetched nrm/pin.json
, containers-src  ? fetched containers/pin.json

, #source overrides: applications
  amg-src         ? fetched amg/pin.json
, qmcpack-src     ? fetched qmcpack/pin.json
, openmc-src      ? fetched openmc/pin.json
, stream-src      ? fetched stream/pin.json
, lammps-src      ? fetched lammps/pin.json

, #source overrides: tooling
  argotk-src       ? builtins.fetchGit {inherit (fetched argotk/pin.json) url rev;}
, repoquality-src  ? builtins.fetchGit {inherit (fetched repoquality/pin.json) url rev;}
, argonix-src      ? builtins.fetchGit {inherit (fetched argonix/pin.json) url rev;}

, #used for hardware experiments.
  sudoPath ? null

, #whether to rebuild apps when libnrm changes.
  rebuildApps ? true
}:
let
  callPackage = pkgs.lib.callPackageWith (pkgs // argopkgs);

  argopkgs = rec {
    # library of nix expressions
    argolib       = import ../lib/utils.nix;
    # Argo components (source overridabel via argument)
    aml           = callPackage ./aml        {src=aml-src;};
    nrm           = callPackage ./nrm        {src=nrm-src;};
    containers    = callPackage ./containers {src=containers-src;};
    libnrm        = callPackage ./libnrm     {src=libnrm-src;};
    libnrm-pinned = callPackage ./libnrm     {src=fetched libnrm/pin.json;};
    libnrm-pmpi   = libnrm.overrideAttrs (oldAttrs: rec {
      configureFlags = "--enable-pmpi";
      buildInputs = oldAttrs.buildInputs ++ [ pkgs.mpich2 ];
    });

    # applications with replaceDependency for libnrm.
    repLibnrm = path: src: extra:
    let
      drv = callPackage path {
        nrmSupport = true;
        src = src;
        libnrm = libnrm-pinned;
      };
    in if !rebuildApps then drv else pkgs.replaceDependency {
      drv = drv;
      oldDependency = libnrm-pinned;
      newDependency = libnrm;
    };
    amg          = repLibnrm ./amg     amg-src     {};
    qmcpack      = repLibnrm ./qmcpack qmcpack-src {};
    openmc       = repLibnrm ./openmc  openmc-src  {};
    lammps       = repLibnrm ./lammps  lammps-src  {};
    stream       = repLibnrm ./stream  stream-src  {iterationCount="20000";};

    # data (static, non source overridable via arguments)
    openmc-data = fetched openmc/data.json;

    # tools
    zymake = callPackage ./zymake {
      inherit (pkgs.ocamlPackages) findlib ocamlbuild topkg batteries;
    };
    haskellPackages = pkgs.haskellPackages.override {
      overrides = self: super: with pkgs.haskell.lib;
      rec {
        panpipe        = (pkgs.haskell.lib.doJailbreak super.panpipe);
        spdx           = (pkgs.haskell.lib.doJailbreak super.spdx);
        generic-pretty = doJailbreak super.generic-pretty;

        #minor cabal and version fix
        panhandle    = (self.callCabal2nix "panhandle" (builtins.fetchGit {
                      inherit (panhandle-src) url rev; })) {};

        #argo tools
        argotk = (self.callCabal2nix "argotk" argotk-src) {};
        argonix = (self.callCabal2nix "argonix" argonix-src) {};
        repoquality = (self.callCabal2nix "repoquality" repoquality-src) {};
      };
    };

    # re-export from hpkgs and add non-haskell build rule specialization
    inherit (haskellPackages) repoquality;

    argotk = haskellPackages.argotk.overrideAttrs (old:{
        buildInputs=old.buildInputs ++ [pkgs.hwloc];
        installPhase = old.installPhase + ''
          mkdir $out/share/
          ARGOTK_SHARE=share $out/bin/argotk --bash-completion-script argotk > $out/share/argotk.sh
          cp -r share/* $out/share/
          substituteInPlace $out/share/simple-H2O.xml --replace \
                H2O.HF.wfs.xml $out/share/H2O.HF.wfs.xml
          substituteInPlace $out/share/simple-H2O.xml --replace \
                O.BFD.xml $out/share/O.BFD.xml
          substituteInPlace $out/share/simple-H2O.xml --replace \
                H.BFD.xml $out/share/H.BFD.xml
        '';
      });

    argonix = haskellPackages.argonix.overrideAttrs (old:{
        installPhase = old.installPhase + ''
          mkdir $out/share/
          $out/bin/argonix --bash-completion-script argonix > $out/share/argonix.sh
        '';
      });

    # fix for nrm
    pyzmq = pkgs.pythonPackages.pyzmq.override { zeromq3 = pkgs.zeromq; };

    # archived for sake of the simplicity of this file
    zmcat = pkgs-old.haskellPackages.callPackage ./zmcat {};
    zmqat = pkgs-old.haskellPackages.zmqat;

    # ci/experimental environments
    testBuildInputs =  [
      # argotk runs mpiexec:
      pkgs.mpich2
      # argotk uses hwloc to choose CPU counts:
      pkgs.hwloc
      # these are needed for some reason:
      pkgs.coreutils
      pkgs.utillinux
      pkgs.git
      # argo tools
      argotk
      # argo components
      containers
      nrm
    ];

    test = pkgs.stdenv.mkDerivation rec {
      name = "testEnv";

      buildInputs = testBuildInputs ++ [ stream ];

      #required to be able to build the drv.
      installPhase = "mkdir $out";
      unpackPhase = "true";

      __noChroot = true;
      shellHook =''
        echo ""
        echo "ENTERING ENVIRONMENT: Sources of impurity for this build are: /tmp/ /etc/argo/ /var/run/ /var/lock/".
        echo "ENTERING ENVIRONMENT: Moreover, sandboxing is disabled, in particular because of:"
        echo "ENTERING ENVIRONMENT: /tmp/nrm-* sockets, /etc/argo, /var/run/, /var/lock/ which all need read access. "
        echo "ENTERING ENVIRONMENT: until these components are patched to allow for alternative paths, no sandbox use is possible."
        source ${argotk}/share/argotk.sh # bash completion
        echo ""
      '';
      #argotk uses this environment variable.
      ARGOTK_SHARE = "${argotk}/share";
    };

    expe = test.overrideAttrs (old:{
      buildInputs = testBuildInputs ++ [
        #debug tools
        pkgs.which
        zmcat

        #experiment tools
        zymake

        #applications
        lammps
        qmcpack
        openmc
        stream
        amg

        #data
        openmc-data
      ];
      OPENMC_CROSS_SECTIONS = "${openmc-data}/cross_sections.xml";
      OPENMC_PWD = "${argotk}/share/openmc";
    });

    analysis =
    pkgs.rWrapper.override{ packages = with pkgs.rPackages; [
      pkgs.rlwrap
      pkgs.pandoc
      docopt
      formatR
      purrr
      knitr
      cowplot
      plotly
      lubridate
      dplyr
      ggplot2
      xtable
      ggthemes
      data_table
    ];};

    jupyter =
      let
        jupyter = import (fetched jupyter/pin.json) {};
      in
       (jupyter.jupyterlabWith {
          kernels = [
            (jupyter.kernels.juniperWith {
              name = "analysis";
              packages = p: with p; [ ggplot2
                  pkgs.which
                  docopt
                  purrr
                  knitr
                  cowplot
                  plotly
                  lubridate
                  dplyr
                  ggplot2
                  xtable
                  ggthemes
                  data_table
              ];
            })
          ];
         }).env;

    doArgotk = command: test.overrideAttrs (old:{
      buildPhase = "argotk "+command;
      installPhase = ''
        mkdir $out
        cp _output/* $out/
      '';
    });
    testHello       = doArgotk "TestHello";
    testListen      = doArgotk "TestListen";
    testPerfwrapper = doArgotk "TestPerfwrapper";
    testPower       = doArgotk "TestPower";
    testSTREAM      = doArgotk "TestSTREAM";
    testAll         = doArgotk "tests";

  };
# re-exporting a full nixpkgs-like package set
in pkgs // argopkgs