# Generic builder.

{ lib, config, python, wrapPython, unzip, ensureNewerSourcesForZipFilesHook
# Whether the derivation provides a Python module or not.
, toPythonModule, namePrefix, update-python-libraries, setuptools, pypaBuildHook
, pypaInstallHook, pythonCatchConflictsHook, pythonImportsCheckHook
, pythonNamespacesHook, pythonOutputDistHook, pythonRemoveBinBytecodeHook
, pythonRemoveTestsDirHook, pythonRuntimeDepsCheckHook, setuptoolsBuildHook
, setuptoolsCheckHook, wheelUnpackHook, eggUnpackHook, eggBuildHook
, eggInstallHook }:

let
  inherit (builtins) unsafeGetAttrPos;
  inherit (lib)
    elem optionalString max stringLength fixedWidthString getName optional
    optionals optionalAttrs hasSuffix escapeShellArgs extendDerivation head
    splitString isBool;

  leftPadName = name: against:
    let len = max (stringLength name) (stringLength against);
    in fixedWidthString len " " name;

  isPythonModule = drv:
    # all pythonModules have the pythonModule attribute
    (drv ? "pythonModule")
    # Some pythonModules are turned in to a pythonApplication by setting the field to false
    && (!isBool drv.pythonModule);

  isMismatchedPython = drv: drv.pythonModule != python;

  withDistOutput' = lib.flip elem [ "pyproject" "setuptools" "wheel" ];

  isBootstrapInstallPackage' = lib.flip elem [ "flit-core" "installer" ];

  isBootstrapPackage' = lib.flip elem
    ([ "build" "packaging" "pyproject-hooks" "wheel" ]
      ++ optionals (python.pythonOlder "3.11") [ "tomli" ]);

  isSetuptoolsDependency' = lib.flip elem [ "setuptools" "wheel" ];

  cleanAttrs = lib.flip removeAttrs [
    "disabled"
    "checkPhase"
    "checkInputs"
    "nativeCheckInputs"
    "doCheck"
    "doInstallCheck"
    "dontWrapPythonPrograms"
    "catchConflicts"
    "pyproject"
    "format"
    "disabledTestPaths"
    "outputs"
    "stdenv"
    "dependencies"
    "optional-dependencies"
    "build-system"
  ];

in { name ? "${attrs.pname}-${attrs.version}"

  # Build-time dependencies for the package
, nativeBuildInputs ? [ ]

  # Run-time dependencies for the package
, buildInputs ? [ ]

  # Dependencies needed for running the checkPhase.
  # These are added to buildInputs when doCheck = true.
, checkInputs ? [ ], nativeCheckInputs ? [ ]

  # propagate build dependencies so in case we have A -> B -> C,
  # C can import package A propagated by B
, propagatedBuildInputs ? [ ]

  # Python module dependencies.
  # These are named after PEP-621.
, dependencies ? [ ], optional-dependencies ? { }

  # Python PEP-517 build systems.
, build-system ? [ ]

  # DEPRECATED: use propagatedBuildInputs
, pythonPath ? [ ]

  # Enabled to detect some (native)BuildInputs mistakes
, strictDeps ? true

, outputs ? [
  "out"
]

# used to disable derivation, useful for specific python versions
, disabled ? false

  # Raise an error if two packages are installed with the same name
  # TODO: For cross we probably need a different PYTHONPATH, or not
  # add the runtime deps until after buildPhase.
, catchConflicts ? (python.stdenv.hostPlatform == python.stdenv.buildPlatform)

# Additional arguments to pass to the makeWrapper function, which wraps
# generated binaries.
, makeWrapperArgs ? [ ]

  # Skip wrapping of python programs altogether
, dontWrapPythonPrograms ? false

  # Don't use Pip to install a wheel
  # Note this is actually a variable for the pipInstallPhase in pip's setupHook.
  # It's included here to prevent an infinite recursion.
, dontUsePipInstall ? false

  # Skip setting the PYTHONNOUSERSITE environment variable in wrapped programs
, permitUserSite ? false

  # Remove bytecode from bin folder.
  # When a Python script has the extension `.py`, bytecode is generated
  # Typically, executables in bin have no extension, so no bytecode is generated.
  # However, some packages do provide executables with extensions, and thus bytecode is generated.
, removeBinBytecode ? true

  # pyproject = true <-> format = "pyproject"
  # pyproject = false <-> format = "other"
  # https://github.com/NixOS/nixpkgs/issues/253154
, pyproject ? null

  # Several package formats are supported.
  # "setuptools" : Install a common setuptools/distutils based package. This builds a wheel.
  # "wheel" : Install from a pre-compiled wheel.
  # "pyproject": Install a package using a ``pyproject.toml`` file (PEP517). This builds a wheel.
  # "egg": Install a package from an egg.
  # "other" : Provide your own buildPhase and installPhase.
, format ? null

, meta ? { }

, doCheck ? config.doCheckByDefault or false

, disabledTestPaths ? [ ]

  # Allow passing in a custom stdenv to buildPython*
, stdenv ? python.stdenv

, ... }@attrs:

assert (pyproject != null) -> (format == null);

let
  format' = if pyproject != null then
    if pyproject then "pyproject" else "other"
  else if format != null then
    format
  else
    "setuptools";

  withDistOutput = withDistOutput' format';

  validatePythonMatches = let
    throwMismatch = attrName: drv:
      let
        myName = "'${namePrefix}${name}'";
        theirName = "'${drv.name}'";
        optionalLocation = let
          pos = unsafeGetAttrPos (if attrs ? "pname" then "pname" else "name")
            attrs;
        in optionalString (pos != null)
        " at ${pos.file}:${toString pos.line}:${toString pos.column}";
      in throw ''
        Python version mismatch in ${myName}:

        The Python derivation ${myName} depends on a Python derivation
        named ${theirName}, but the two derivations use different versions
        of Python:

            ${leftPadName myName theirName} uses ${python}
            ${leftPadName theirName myName} uses ${toString drv.pythonModule}

        Possible solutions:

          * If ${theirName} is a Python library, change the reference to ${theirName}
            in the ${attrName} of ${myName} to use a ${theirName} built from the same
            version of Python

          * If ${theirName} is used as a tool during the build, move the reference to
            ${theirName} in ${myName} from ${attrName} to nativeBuildInputs

          * If ${theirName} provides executables that are called at run time, pass its
            bin path to makeWrapperArgs:

                makeWrapperArgs = [ "--prefix PATH : ''${lib.makeBinPath [ ${
                  getName drv
                } ] }" ];

        ${optionalLocation}
      '';

    checkDrv = attrName: drv:
      if (isPythonModule drv) && (isMismatchedPython drv) then
        throwMismatch attrName drv
      else
        drv;

  in attrName: inputs: map (checkDrv attrName) inputs;

  isBootstrapInstallPackage = isBootstrapInstallPackage' (attrs.pname or null);

  isBootstrapPackage = isBootstrapInstallPackage
    || isBootstrapPackage' (attrs.pname or null);

  isSetuptoolsDependency = isSetuptoolsDependency' (attrs.pname or null);

  passthru = attrs.passthru or { } // {
    updateScript = let filename = head (splitString ":" self.meta.position);
    in attrs.passthru.updateScript or [ update-python-libraries filename ];
  } // optionalAttrs (dependencies != [ ]) { inherit dependencies; }
    // optionalAttrs (optional-dependencies != { }) {
      inherit optional-dependencies;
    } // optionalAttrs (build-system != [ ]) { inherit build-system; };

  # Keep extra attributes from `attrs`, e.g., `patchPhase', etc.
  self = toPythonModule (stdenv.mkDerivation ((cleanAttrs attrs) // {

    name = namePrefix + name;

    nativeBuildInputs = [
      python
      wrapPython
      ensureNewerSourcesForZipFilesHook # move to wheel installer (pip) or builder (setuptools, flit, ...)?
      pythonRemoveTestsDirHook
    ] ++ optionals
      (catchConflicts && !isBootstrapPackage && !isSetuptoolsDependency) [
        #
        # 1. When building a package that is also part of the bootstrap chain, we
        #    must ignore conflicts after installation, because there will be one with
        #    the package in the bootstrap.
        #
        # 2. When a package is a dependency of setuptools, we must ignore conflicts
        #    because the hook that checks for conflicts uses setuptools.
        #
        pythonCatchConflictsHook
      ] ++ optionals removeBinBytecode [ pythonRemoveBinBytecodeHook ]
      ++ optionals (hasSuffix "zip" (attrs.src.name or "")) [ unzip ]
      ++ optionals (format' == "setuptools") [ setuptoolsBuildHook ]
      ++ optionals (format' == "pyproject") [
        (if isBootstrapPackage then
          pypaBuildHook.override {
            inherit (python.pythonOnBuildForHost.pkgs.bootstrap) build;
            wheel = null;
          }
        else
          pypaBuildHook)
        (if isBootstrapPackage then
          pythonRuntimeDepsCheckHook.override {
            inherit (python.pythonOnBuildForHost.pkgs.bootstrap) packaging;
          }
        else
          pythonRuntimeDepsCheckHook)
      ] ++ optionals (format' == "wheel") [ wheelUnpackHook ]
      ++ optionals (format' == "egg") [
        eggUnpackHook
        eggBuildHook
        eggInstallHook
      ] ++ optionals (format' != "other") [
        (if isBootstrapInstallPackage then
          pypaInstallHook.override {
            inherit (python.pythonOnBuildForHost.pkgs.bootstrap) installer;
          }
        else
          pypaInstallHook)
      ] ++ optionals (stdenv.buildPlatform == stdenv.hostPlatform) [
        # This is a test, however, it should be ran independent of the checkPhase and checkInputs
        pythonImportsCheckHook
      ] ++ optionals (python.pythonAtLeast "3.3") [
        # Optionally enforce PEP420 for python3
        pythonNamespacesHook
      ] ++ optionals withDistOutput [ pythonOutputDistHook ]
      ++ nativeBuildInputs ++ build-system;

    buildInputs =
      validatePythonMatches "buildInputs" (buildInputs ++ pythonPath);

    propagatedBuildInputs = validatePythonMatches "propagatedBuildInputs"
      (propagatedBuildInputs ++ dependencies ++ [
        # we propagate python even for packages transformed with 'toPythonApplication'
        # this pollutes the PATH but avoids rebuilds
        # see https://github.com/NixOS/nixpkgs/issues/170887 for more context
        python
      ]);

    inherit strictDeps;

    LANG = "${if python.stdenv.isDarwin then "en_US" else "C"}.UTF-8";

    # Python packages don't have a checkPhase, only an installCheckPhase
    doCheck = false;
    doInstallCheck = attrs.doCheck or true;
    nativeInstallCheckInputs = [ ] ++ optionals (format' == "setuptools") [
      # Longer-term we should get rid of this and require
      # users of this function to set the `installCheckPhase` or
      # pass in a hook that sets it.
      setuptoolsCheckHook
    ] ++ nativeCheckInputs;
    installCheckInputs = checkInputs;

    postFixup = optionalString (!dontWrapPythonPrograms) ''
      wrapPythonPrograms
    '' + attrs.postFixup or "";

    # Python packages built through cross-compilation are always for the host platform.
    disallowedReferences =
      optionals (python.stdenv.hostPlatform != python.stdenv.buildPlatform)
      [ python.pythonOnBuildForHost ];

    outputs = outputs ++ optional withDistOutput "dist";

    inherit passthru;

    meta = {
      # default to python's platforms
      platforms = python.meta.platforms;
      isBuildPythonPackage = python.meta.platforms;
    } // meta;
  } // optionalAttrs (attrs ? checkPhase) {
    # If given use the specified checkPhase, otherwise use the setup hook.
    # Longer-term we should get rid of `checkPhase` and use `installCheckPhase`.
    installCheckPhase = attrs.checkPhase;
  } // optionalAttrs (disabledTestPaths != [ ]) {
    disabledTestPaths = escapeShellArgs disabledTestPaths;
  }));

in extendDerivation
(disabled -> throw "${name} not supported for interpreter ${python.executable}")
passthru self