{
  description = "API service for Slices";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    crane.url = "github:ipetkov/crane";
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.rust-analyzer-src.follows = "";
    };
  };

  outputs = { self, nixpkgs, crane, fenix }:
    let
      systems = [ "x86_64-linux" "aarch64-darwin" ];
      forAllSystems = nixpkgs.lib.genAttrs systems;

      mkPackagesForSystem = system:
        let
          pkgs = import nixpkgs {
            inherit system;
            config = { allowUnfree = true; };
          };

          # Configure crane with stable Rust toolchain from nixpkgs (more reliable)
          craneLib = crane.mkLib pkgs;

          # Project source for crane
          src = pkgs.lib.cleanSourceWith {
            src = ../.;
            filter = path: type:
              (craneLib.filterCargoSources path type) ||
              (pkgs.lib.hasInfix "/migrations/" path) ||
              (pkgs.lib.hasSuffix "/migrations" path) ||
              (pkgs.lib.hasInfix "/.sqlx/" path) ||
              (pkgs.lib.hasSuffix "/.sqlx" path) ||
              (pkgs.lib.hasInfix "/scripts/" path) ||
              (pkgs.lib.hasSuffix "/scripts" path) ||
              (pkgs.lib.hasInfix "/packages/lexicon-rs/" path);
          };

          commonArgs = {
            inherit src;
            version = "0.1.0";
            strictDeps = true;
            pname = "slices";
            name = "slices";
            sourceRoot = "source/api";
            cargoLock = ../api/Cargo.lock;
            buildInputs = with pkgs; [
              openssl
              pkg-config
              postgresql
              stdenv.cc.cc.lib
            ] ++ pkgs.lib.optionals pkgs.stdenv.isLinux [
              glibc
            ];
            nativeBuildInputs = with pkgs; [
              pkg-config
              openssl.dev
              sqlx-cli
              stdenv.cc
            ];

            # Environment variables for OpenSSL
            OPENSSL_NO_VENDOR = 1;
            PKG_CONFIG_PATH = "${pkgs.openssl.dev}/lib/pkgconfig";

            # Environment variables for SQLx
            SQLX_OFFLINE = "true";

            # Fix for linker issues in Nix
            CC = "${pkgs.stdenv.cc}/bin/cc";

            cargoExtraArgs = "--bin slices";
          };

          # Build cargo artifacts
          cargoArtifacts = craneLib.buildDepsOnly commonArgs;

          # Build the package
          slices = craneLib.buildPackage (commonArgs // {
            cargoArtifacts = cargoArtifacts;
            doCheck = false;
            CARGO_PROFILE = "release";
          });

          # Copy migration files
          migrationFiles = pkgs.stdenv.mkDerivation {
            name = "slices-migrations";
            src = ../api/migrations;
            installPhase = ''
              mkdir -p $out/migrations
              cp -r * $out/migrations/
            '';
          };

          # Copy script files
          scriptFiles = pkgs.stdenv.mkDerivation {
            name = "slices-scripts";
            src = ../api/scripts;
            installPhase = ''
              mkdir -p $out/scripts
              cp -r * $out/scripts/
            '';
          };


          # Common OCI labels
          ociLabels = {
            "org.opencontainers.image.title" = "slices";
            "org.opencontainers.image.description" = "API service for Slices";
            "org.opencontainers.image.version" = "0.1.0";
            "org.opencontainers.image.authors" = "Slices Social";
            "org.opencontainers.image.licenses" = "MIT";
          };

          # Docker image for deployment
          slicesImg = pkgs.dockerTools.buildImage {
            name = "slices";
            tag = "latest";
            fromImage = pkgs.dockerTools.pullImage {
              imageName = "alpine";
              imageDigest = "sha256:beefdbd8a1da6d2915566fde36db9db0b524eb737fc57cd1367effd16dc0d06d";
              sha256 = "sha256-Sfb0quuaHgzxA7paz5P51WhdA35to39HtOufceXixz0=";
            };
            copyToRoot = pkgs.buildEnv {
              name = "image-root";
              paths = [
                slices
                pkgs.cacert
                pkgs.postgresql
                scriptFiles
              ];
              pathsToLink = [ "/bin" "/etc" "/scripts" ];
            };

            config = {
              Cmd = [ "/bin/slices" ];
              Env = [
                "RUST_BACKTRACE=1"
                "RUST_LOG=info"
                "PORT=8080"
              ];
              ExposedPorts = {
                "8080/tcp" = {};
              };
              Labels = ociLabels;
            };
          };

        in
        {
          inherit slices slicesImg;
          default = slices;
        };
    in
    {
      packages = forAllSystems mkPackagesForSystem;

      devShells = forAllSystems (system:
        let
          pkgs = import nixpkgs { inherit system; };
          craneLib = crane.mkLib pkgs;
        in
        {
          default = craneLib.devShell {
            packages = with pkgs; [
              nixpkgs-fmt
              nil
              dive
              postgresql
              sqlx-cli
            ];

            # Set up environment for development
            RUST_LOG = "info";
          };
        });
    };
}