flake.nix

{
  description = "Libmahjong Riichi Mahjong Game Engine";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs";
    flake-utils.url = "github:numtide/flake-utils";
  };

  outputs =
    {
      self,
      nixpkgs,
      flake-utils,
    }:
    flake-utils.lib.eachDefaultSystem (
      system:
      let
        pkgs = import nixpkgs { inherit system; };

        llvmPackage = pkgs.llvmPackages_21;
        gccPackage = pkgs.gcc15Stdenv;

        buildPackages = with pkgs; [
          cmake
          git
          ninja
        ];

        # clang wrapper with gcc's libstdc++
        clangWithGccStdlib = pkgs.wrapCCWith {
          cc = llvmPackage.clang-unwrapped;
          bintools = llvmPackage.bintools;
          libcxx = gccPackage.cc.cc.lib;
          extraBuildCommands = ''
            echo "-isystem ${gccPackage.cc.cc}/include/c++/${gccPackage.cc.version}" >> $out/nix-support/cc-cflags
            echo "-isystem ${gccPackage.cc.cc}/include/c++/${gccPackage.cc.version}/x86_64-unknown-linux-gnu" >> $out/nix-support/cc-cflags

            echo "-isystem ${gccPackage.cc.cc}/include/c++/${gccPackage.cc.version}" > $out/nix-support/libcxx-cxxflags
            echo "-isystem ${gccPackage.cc.cc}/include/c++/${gccPackage.cc.version}/x86_64-unknown-linux-gnu" >> $out/nix-support/libcxx-cxxflags
          '';
        };

        clangStdenv = pkgs.stdenvAdapters.overrideCC gccPackage clangWithGccStdlib;

        clangTools = llvmPackage.clang-tools.override {
          stdenv = clangStdenv;
          clang = clangWithGccStdlib;
          clang-unwrapped = llvmPackage.clang-unwrapped;
        };

        commonAttrs = {
          pname = "libmahjong";
          version = "0.1.0";
          src = ./.;

          cmakeFlags = [
            "-DBUILD_SHARED_LIBS=ON" # Explicitly build shared libraries
            "-Dlibmahjong_build_tests=OFF"
            "-Dlibmahjong_build_tools=OFF"
            "-DCMAKE_INSTALL_LIBDIR=lib"
            "-DCMAKE_INSTALL_INCLUDEDIR=include"
          ];

          # Let CMake handle installation
          dontUseCmakeBuildDir = false;

          meta = with pkgs.lib; {
            description = "Riichi Mahjong Game Engine Library";
          };
        };

        clangGtest = pkgs.gtest.override {
          stdenv = clangStdenv;
        };

        clangNativeBuildInputs = buildPackages ++ [
          clangTools
        ];

        testNativeBuildInputs = clangNativeBuildInputs ++ [
          clangGtest
          clangGtest.dev
          llvmPackage.compiler-rt # Add compiler-rt for coverage runtime
        ];
      in
      {
        devShells.default = clangStdenv.mkDerivation {
          name = "libmahjong-dev";
          nativeBuildInputs = clangNativeBuildInputs;

          # Disable all hardening
          hardeningDisable = [ "all" ];

          # Explicitly set to prevent contamination
          NIX_CFLAGS_COMPILE = "-isystem ${gccPackage.cc.cc}/include/c++/${gccPackage.cc.version} -isystem ${gccPackage.cc.cc}/include/c++/${gccPackage.cc.version}/x86_64-unknown-linux-gnu";

          shellHook = ''
            mkdir -p .vscode
            echo "{" > .vscode/settings.json
            echo '  "nixEnvSelector.nixFile": "''${workspaceFolder}/shell.nix",' >> .vscode/settings.json
            echo "  \"cmake.cmakePath\": \"${pkgs.cmake}/bin/cmake\"," >> .vscode/settings.json
            echo "  \"cmake.ctestPath\": \"${pkgs.cmake}/bin/ctest\"," >> .vscode/settings.json
            echo "  \"cmake.skipConfigureIfCachePresent\": true," >> .vscode/settings.json
            echo "  \"cmake.configureOnOpen\": false," >> .vscode/settings.json
            echo "  \"cmake.configureOnEdit\": false," >> .vscode/settings.json
            echo "}" >> .vscode/settings.json

            ${pkgs.cmake}/bin/cmake -S . -B build -G Ninja \
              -Dlibmahjong_build_tests=OFF \
              -DCMAKE_CXX_FLAGS="-O1 -g"
          '';
        };

        packages = rec {
          gcc = gccPackage.mkDerivation (
            commonAttrs
            // {
              nativeBuildInputs = buildPackages;
              # Add any runtime dependencies your library needs
              propagatedBuildInputs = with pkgs; [
                # Add dependencies that users of your library will need
              ];

              # This ensures dependent packages can find your library
              setupHook = pkgs.writeText "setup-hook.sh" ''
                addLibmahjongLibs() {
                  addToSearchPath LD_LIBRARY_PATH $1/lib
                }
                addEnvHooks "$targetOffset" addLibmahjongLibs
              '';
            }
          );

          clang = clangStdenv.mkDerivation (
            commonAttrs
            // {
              nativeBuildInputs = clangNativeBuildInputs;

              hardeningDisable = [ "all" ];

              cmakeFlags = commonAttrs.cmakeFlags ++ [
                "-Dlibmahjong_use_clang_utils=OFF"
              ];

              # This ensures dependent packages can find your library
              setupHook = pkgs.writeText "setup-hook.sh" ''
                addLibmahjongLibs() {
                  addToSearchPath LD_LIBRARY_PATH $1/lib
                }
                addEnvHooks "$targetOffset" addLibmahjongLibs
              '';
            }
          );

          tests = clangStdenv.mkDerivation {
            pname = "libmahjong-tests";
            version = "0.1.0";
            src = ./.;
            nativeBuildInputs = testNativeBuildInputs;
            hardeningDisable = [ "all" ];

            # Disable memory sanitizer for tests
            # libstdc++ isnt instrumented and therefore isnt
            # detecting things properly compared to libc++
            # It might be possible to resolve this with some more
            # complicated nix configurations but it might be awful
            cmakeFlags = [
              "-Dlibmahjong_build_tools=OFF"
              "-Dlibmahjong_build_tests=ON"
              "-Dlibmahjong_use_clang_utils=OFF"
              "-Dlibmahjong_enable_msan=OFF"
            ];

            installPhase = ''
              runHook preInstall

              mkdir -p $out
              ctest --output-on-failure --output-junit $out/test.xml

              runHook postInstall
            '';
          };

          coverage =
            pkgs.runCommand "libmahjong-coverage"
              {
                nativeBuildInputs = clangNativeBuildInputs;
                buildInputs = [ llvmPackage.libcxx ];
                src = ./.;
                hardeningDisable = [ "all" ];
              }
              ''
                mkdir -p $out

                cmake -S $src \
                      -B build \
                      -G Ninja \
                      -DCMAKE_BUILD_TYPE=Debug \
                      -Dlibmahjong_build_tools=OFF \
                      -Dlibmahjong_build_tests=ON \
                      -Dlibmahjong_enable_coverage=ON

                cmake --build build

                mkdir -p build/coverage
                LLVM_PROFILE_FILE="$PWD/build/coverage/coverage-%p.profraw" ctest --test-dir build --output-on-failure

                # Find all test executables
                TEST_BINARIES=$(find build/tests -type f -executable ! -name "*.so" 2>/dev/null | grep -v CMakeFiles | tr '\n' ' ')
                # Find the main library
                MAIN_LIB=$(find build -name "libmahjong.so" -type f | head -1)

                ${llvmPackage.llvm}/bin/llvm-profdata merge \
                  -sparse build/coverage/*.profraw \
                  -o $out/coverage.profdata

                # We need to provide some sort of binary for the reports/exports,
                # but all the cov data got generated when we ran ctest. Just use the first one
                FIRST_BINARY=$(echo $TEST_BINARIES | cut -d' ' -f1)

                ${llvmPackage.llvm}/bin/llvm-cov report \
                  $FIRST_BINARY \
                  -object=$MAIN_LIB \
                  -instr-profile=$out/coverage.profdata \
                  $src/src \
                  > $out/coverage-summary.txt

                ${llvmPackage.llvm}/bin/llvm-cov show \
                  $FIRST_BINARY \
                  -object=$MAIN_LIB \
                  -instr-profile=$out/coverage.profdata \
                  -format=html \
                  -output-dir=$out/html \
                  $src/src

                ${llvmPackage.llvm}/bin/llvm-cov export \
                  $FIRST_BINARY \
                  -object=$MAIN_LIB \
                  -instr-profile=$out/coverage.profdata \
                  -format=lcov \
                  $src/src \
                  > $out/coverage.lcov

                ${llvmPackage.llvm}/bin/llvm-cov export \
                  $FIRST_BINARY \
                  -object=$MAIN_LIB \
                  -instr-profile=$out/coverage.profdata \
                  $src/src \
                  > $out/coverage.json
              '';

          default = clang;
        };

        lib = {
          libmahjong = self.packages.${system}.default;
        };
      }
    );
}