{ lib, importCargoLock, fetchCargoTarball, stdenv, callPackage, cargoBuildHook
, cargoCheckHook, cargoInstallHook, cargoNextestHook, cargoSetupHook, cargo
, cargo-auditable, buildPackages, rustc, libiconv, windows }:

{ name ? "${args.pname}-${args.version}"

  # Name for the vendored dependencies tarball
, cargoDepsName ? name

, src ? null, srcs ? null, preUnpack ? null, unpackPhase ? null
, postUnpack ? null, cargoPatches ? [ ], patches ? [ ], sourceRoot ? null
, logLevel ? "", buildInputs ? [ ], nativeBuildInputs ? [ ]
, cargoUpdateHook ? "", cargoDepsHook ? "", buildType ? "release", meta ? { }
, cargoLock ? null, cargoVendorDir ? null, checkType ? buildType
, buildNoDefaultFeatures ? false
, checkNoDefaultFeatures ? buildNoDefaultFeatures, buildFeatures ? [ ]
, checkFeatures ? buildFeatures, useNextest ? false
  # Enable except on aarch64 pkgsStatic, where we use lld for reasons
, auditable ? !cargo-auditable.meta.broken && !(stdenv.hostPlatform.isStatic
  && stdenv.hostPlatform.isAarch64 && !stdenv.hostPlatform.isDarwin)

, depsExtraArgs ? { }

  # Toggles whether a custom sysroot is created when the target is a .json file.
, __internal_dontAddSysroot ? false

  # Needed to `pushd`/`popd` into a subdir of a tarball if this subdir
  # contains a Cargo.toml, but isn't part of a workspace (which is e.g. the
  # case for `rustfmt`/etc from the `rust-sources).
  # Otherwise, everything from the tarball would've been built/tested.
, buildAndTestSubdir ? null, ... }@args:

assert cargoVendorDir == null && cargoLock == null
  -> !(args ? cargoSha256 && args.cargoSha256 != null)
  && !(args ? cargoHash && args.cargoHash != null)
  -> throw "cargoSha256, cargoHash, cargoVendorDir, or cargoLock must be set";

let

  cargoDeps = if cargoVendorDir != null then
    null
  else if cargoLock != null then
    importCargoLock cargoLock
  else
    fetchCargoTarball ({
      inherit src srcs sourceRoot preUnpack unpackPhase postUnpack
        cargoUpdateHook;
      name = cargoDepsName;
      patches = cargoPatches;
    } // lib.optionalAttrs (args ? cargoHash) { hash = args.cargoHash; }
      // lib.optionalAttrs (args ? cargoSha256) { sha256 = args.cargoSha256; }
      // depsExtraArgs);

  target = stdenv.hostPlatform.rust.rustcTargetSpec;
  targetIsJSON = lib.hasSuffix ".json" target;
  useSysroot = targetIsJSON && !__internal_dontAddSysroot;

  sysroot = callPackage ./sysroot { } {
    inherit target;
    shortTarget = stdenv.hostPlatform.rust.cargoShortTarget;
    RUSTFLAGS = args.RUSTFLAGS or "";
    originalCargoToml = src + /Cargo.toml; # profile info is later extracted
  };

  # Tests don't currently work for `no_std`, and all custom sysroots are currently built without `std`.
  # See https://os.phil-opp.com/testing/ for more information.
in assert useSysroot -> !(args.doCheck or true);

stdenv.mkDerivation
((removeAttrs args [ "depsExtraArgs" "cargoUpdateHook" "cargoLock" ])
  // lib.optionalAttrs useSysroot {
    RUSTFLAGS = "--sysroot ${sysroot} " + (args.RUSTFLAGS or "");
  } // {
    inherit buildAndTestSubdir cargoDeps;

    cargoBuildType = buildType;

    cargoCheckType = checkType;

    cargoBuildNoDefaultFeatures = buildNoDefaultFeatures;

    cargoCheckNoDefaultFeatures = checkNoDefaultFeatures;

    cargoBuildFeatures = buildFeatures;

    cargoCheckFeatures = checkFeatures;

    patchRegistryDeps = ./patch-registry-deps;

    nativeBuildInputs = nativeBuildInputs ++ lib.optionals auditable [
      (buildPackages.cargo-auditable-cargo-wrapper.override {
        inherit cargo cargo-auditable;
      })
    ] ++ [
      cargoBuildHook
      (if useNextest then cargoNextestHook else cargoCheckHook)
      cargoInstallHook
      cargoSetupHook
      rustc
    ];

    buildInputs = buildInputs
      ++ lib.optionals stdenv.hostPlatform.isDarwin [ libiconv ]
      ++ lib.optionals stdenv.hostPlatform.isMinGW [ windows.pthreads ];

    patches = cargoPatches ++ patches;

    PKG_CONFIG_ALLOW_CROSS =
      if stdenv.buildPlatform != stdenv.hostPlatform then 1 else 0;

    postUnpack = ''
      eval "$cargoDepsHook"

      export RUST_LOG=${logLevel}
    '' + (args.postUnpack or "");

    configurePhase = args.configurePhase or ''
      runHook preConfigure
      runHook postConfigure
    '';

    doCheck = args.doCheck or true;

    strictDeps = true;

    meta = {
      # default to Rust's platforms
      platforms = rustc.meta.platforms ++ [
        # Platforms without host tools from
        # https://doc.rust-lang.org/nightly/rustc/platform-support.html
        "armv7a-darwin"
        "armv5tel-linux"
        "armv7a-linux"
        "m68k-linux"
        "mipsel-linux"
        "mips64el-linux"
        "riscv32-linux"
        "armv6l-netbsd"
        "x86_64-redox"
        "wasm32-wasi"
      ];
      badPlatforms = [
        # Rust is currently unable to target the n32 ABI
        lib.systems.inspect.patterns.isMips64n32
      ];
    } // meta;
  })