/// A mounted directory.

/// Mount the existing mounted root private to the current namespace,
/// i.e. stop propagating mount events with the parent namespace.

    /// Create a bind mount, i.e. a directory into another one.

    /// Create ramfs mounted onto `target`.

use clap::*;

use std::path::{Path, PathBuf};

use serde_derive::*;
use std::path::PathBuf;

        let ref store = self.deb_client.store_path;

        let ref store = self.deb_client.store_path();

}
#[derive(Deserialize)]
pub struct Config {
    pgp_home: PathBuf,
    store_path: PathBuf,
    package_index: String,
    user: String,

/// Elpe
#[derive(Parser, Debug)]
#[command(version, about, long_about = None)]
struct Args {
    /// Path to the configuration file
    #[arg(short, long)]
    config: PathBuf,
}

    let store_path = Path::new("/home/pe/Projets/frix/store");
    let user = "pe";
    let home = "/home/pe";

    let args = Args::parse();

    let container_channel = crate::container::serve(user, store_path);

    let config: Config = toml::from_str(&std::fs::read_to_string(&args.config).unwrap()).unwrap();
    let container_channel = crate::container::serve(&config.user, &config.store_path);

        privdrop::PrivDrop::default().user(user).apply().unwrap();
        unsafe {
            std::env::set_var("HOME", home);
        }

        privdrop::PrivDrop::default()
            .user(&config.user)
            .apply()
            .unwrap();

            deb_client: Client::new(store_path, "http://fr.archive.ubuntu.com/ubuntu"),

            deb_client: Client::new(&config.pgp_home, &config.store_path, &config.package_index),

        /*
        let x = elpe
            .deb_client
            .command("noble", "qemu-utils", "usr/bin/qemu-nbd")
            .await
            .output()
            .await
            .unwrap();
        panic!("x = {:?}", x);
        */

        got: String

        got: String,

        got: PathBuf

        got: PathBuf,

        status: i32

        status: i32,

    pgp_home: PathBuf,

/// 

/// Root file of a package index, containing the signed hashes of the package list.

    pub fn new<P: AsRef<std::path::Path>>(store_path: P, mirror: &str) -> Self {

    /// Create a client.
    pub fn new<P: AsRef<std::path::Path>, Q: AsRef<std::path::Path>>(
        pgp_home: P,
        store_path: Q,
        mirror: &str,
    ) -> Self {

            pgp_home: pgp_home.as_ref().to_path_buf(),

    }
    /// Retrieve the store path this client was created with.
    pub fn store_path(&self) -> &std::path::Path {
        &self.store_path

        self.c.get_or_create(|| reqwest::ClientBuilder::new()
                             .read_timeout(self.timeout)
                             .build().unwrap()
        )

        self.c.get_or_create(|| {
            reqwest::ClientBuilder::new()
                .read_timeout(self.timeout)
                .build()
                .unwrap()
        })

    /// Like `tokio::process::Command::new`, but where `cmd` is taken
    /// from inside the supplied package. This decompresses the
    /// package.

    /// This locks a store path in order to avoid races to write to
    /// the same store path.
    ///
    /// For performance and portability reasons, this is implemented
    /// using in-memory Mutexes rather than using filesystem
    /// locks. This process is the only one allowed to write to the
    /// store anyway.

    /// Download a list of packages.

        let ref m = self.mirror;
        let ref release = in_release.release;

        let ref m = self.mirror;
        let ref release = in_release.release;

    /// Download the "InRelease" file of the index, and verify the signatures.

            // Sequoia wants to extract the verification code from
            // their binary and make it available as a lib, but
            // haven't done so as of June 2025.

                .env("HOME", &self.pgp_home)

    /// Read an already downloaded InRelease file, without re-checking
    /// the signatures.

        let r = self
            .client()
            .get(url)
            .send()
            .await?;

        let r = self.client().get(url).send().await?;

/// Recursively list all files inside a directory.

/// An iterator recursively listing all files inside a directory.

/// Recursively list all directories inside a directory.

/// An iterator recursively listing all directories inside a directory.

    /// the root (i.e. the root is the last).

    /// the root (i.e. the root is the last element).

/// Download a Debian package and its dependency DAG from package
/// indices and the package's name.

                            debug!("adding transitive dep: {:?} -> {:?}", last.package.package, dep);

                            debug!(
                                "adding transitive dep: {:?} -> {:?}",
                                last.package.package, dep
                            );

            elt.spawn_extract(client.clone())
                .await;

            elt.spawn_extract(client.clone()).await;

pub async fn hash_reader(

async fn hash_reader(

                    debug!("adding transitive dep: {:?} -> {:?}", last.package.package, dep);

                    debug!(
                        "adding transitive dep: {:?} -> {:?}",
                        last.package.package, dep
                    );

    async fn spawn_extract(
        &mut self,
        client: Client,
    ) {

    async fn spawn_extract(&mut self, client: Client) {

    #[allow(missing_docs)]

    #[allow(missing_docs)]

    #[allow(missing_docs)]

    #[allow(missing_docs)]

    #[allow(missing_docs)]

    #[allow(missing_docs)]

    /// Path of the .deb file inside an index.

    /// A simple dependency.

    Alternatives { alt: Vec<SimpleDep<'a>> },

    /// A dependency that can be supplied by multiple packages. This
    /// is an alternative mechanism to virtual packages.
    Alternatives {
        #[allow(missing_docs)]
        alt: Vec<SimpleDep<'a>>,
    },

    /// Name of the dependency.

    /// Whether this dependency can have any version.

    /// Constraints on dependencies.

}
/*
impl<'a> From<Dep<'a>> for OwnedDep {
    fn from(e: Dep<'a>) -> Self {
        match e {
            Dep::Simple(s) => OwnedDep::Simple(s.to_owned()),
            Dep::Alternatives { alt } => OwnedDep::Alternatives {
                alt: alt.iter().map(From::from).collect()
            },
        }
    }

/// A dependency, which is either a "simple" dependency, or a list of
/// alternatives.
#[derive(Debug, Clone)]
pub enum OwnedDep {
    Simple(OwnedSimpleDep),
    Alternatives { alt: Vec<OwnedSimpleDep> },
}
/// A single dependency.
#[derive(Debug, Clone)]
pub struct OwnedSimpleDep {
    pub name: String,
    pub any: bool,
    pub constraints: Vec<(String, OwnedVersion)>,
}
impl<'a> From<SimpleDep<'a>> for OwnedSimpleDep {
    fn from(e: SimpleDep<'a>) -> Self {
        OwnedSimpleDep {
            name: e.name.to_string(),
            any: e.any,
            constraints: e.constraints.iter().map(|(a, b)| (a.into(), b.into())).collect(),
        }
    }
}
 */

        .try_init();

        .try_init()
        .unwrap();

        _ => false

        _ => false,

///
/// Debian versions have mechanisms to override upstream ones, such as
/// the "epoch" prefix to reorder versions if necessary, and the
/// "debian" suffix to add specifics.

    /// Epoch, i.e. a Debian mechanism to reorder upstream versions if
    /// necessary, for example if the upstream versioning scheme
    /// changes.

    /// Upstream version.

    /// Debian-specific suffix to distinguish between patches.

#[derive(Debug, Clone)]
pub struct OwnedVersion {
    pub epoch: u32,
    pub upstream_version: OwnedUpstream,
    pub debian: Option<String>,
}

#[derive(Debug, Clone)]

#[derive(Debug, Clone, PartialEq, Eq)]

impl<'a> std::ops::Deref for Upstream<'a> {
    type Target = str;
    fn deref(&self) -> &str {
        self.0
    }
}

#[derive(Debug, Clone)]
pub struct OwnedUpstream(String);

impl<'a> PartialOrd for Upstream<'a> {
    /// Following the algorithm described here:
    /// https://www.debian.org/doc/debian-policy/ch-controlfields.html#version
    fn partial_cmp(&self, b: &Upstream<'a>) -> Option<std::cmp::Ordering> {
        fn split_initial(s: &str) -> (&str, &str, &str) {
            // Find `u`, the first digit, and `v > u`, the first non-digit after `u`.
            let mut u = s.len();
            let mut v = s.len();
            for (n, &b) in s.as_bytes().iter().enumerate() {
                if u == s.len() {
                    if b >= b'0' && b <= b'9' {
                        u = n
                    }
                } else if b < b'0' || b > b'9' {
                    v = n;
                    break;
                }
            }
            let (ab, c) = s.split_at(v);
            let (a, b) = ab.split_at(u);
            (a, b, c)
        }
        let mut a = self.0;
        let mut b = b.0;
        use std::cmp::Ordering;
        loop {
            let (a0, a1, a_) = split_initial(a);
            let (b0, b1, b_) = split_initial(b);
            // Compare a0 / b0 using the modified ASCII ordering described in the Debian manual.
            let mut a0i = a0.as_bytes().iter();
            let mut b0i = b0.as_bytes().iter();
            loop {
                match (a0i.next(), b0i.next()) {
                    (None, None) => break,
                    (Some(c), Some(d)) if c == d => continue,
                    (Some(b'~'), _) => return Some(Ordering::Less),
                    (_, Some(b'~')) => return Some(Ordering::Greater),
                    (Some(c), Some(d)) if c.is_ascii_alphabetic() && !d.is_ascii_alphabetic() => {
                        return Some(Ordering::Less);
                    }
                    (Some(c), Some(d)) if d.is_ascii_alphabetic() && !c.is_ascii_alphabetic() => {
                        return Some(Ordering::Greater);
                    }
                    (c, d) => return Some(c.cmp(&d)),
                }
            }
            // If we haven't returned, a0 == b0. Compare the digits part.
            let a1 = if a1.is_empty() {
                0
            } else {
                a1.parse::<u64>().unwrap()
            };
            let b1 = if b1.is_empty() {
                0
            } else {
                b1.parse::<u64>().unwrap()
            };
            let cmp1 = a1.cmp(&b1);
            if let Ordering::Equal = cmp1 {
                a = a_;
                b = b_;
            } else {
                return Some(cmp1);
            }
        }
    }
}

impl<'a> Ord for Upstream<'a> {
    fn cmp(&self, b: &Upstream<'a>) -> std::cmp::Ordering {
        self.partial_cmp(b).unwrap()
    }
}
#[test]
fn test_upstream_ordering() {
    let mut x = [
        Upstream("~~"),
        Upstream("~~a"),
        Upstream("~"),
        Upstream(""),
        Upstream("a"),
    ];
    let y = x.clone();
    x.sort();
    assert_eq!(x, y,);
}

#[allow(dead_code)]

#[allow(missing_docs)]

    /// Parse the control part, containing the description (stanza) of this package.

    /// Return the md5sums of each file.

    /// Decompress the data part of the deb file into a directory.

    /// Parse a `.deb` file from a buffered reader.

struct Index_ {
    map: memmap::Mmap,
    lru: Mutex<lru::LruCache<String, Option<(usize, usize)>>>,
}

struct Index_ {
    map: memmap::Mmap,
    lru: Mutex<lru::LruCache<String, Option<(usize, usize)>>>,
}

    /// Open an index file.

    /// Looks a package up by name. This async version uses
    /// `spawn_blocking` since the process uses mmap and hence does
    /// blocking IO.
    ///
    /// This implementation assumes the packages are in
    /// lexicographical order of their name and uses a binary search.

    /// Look virtual packages up by name. This runs a simple regular
    /// expression on the entire index, and hence may be costly both
    /// in complexity and in IO.

    /// Blocking package lookup by name.

    /// Given a range of bytes `a` (inclusive) to `b` (exclusive)
    /// inside the file, as well as a middle point, find the stanza
    /// containing byte number `m1` in the file.
    ///
    /// This assums a..b is large enough to contain the entire stanza
    /// around m1.

    /// Do the actual binay search.

            debug!(
                "a = {:?}",
                std::str::from_utf8(&s[a..s.len().min(a + 30)]).unwrap()
            );
            debug!(
                "b = {:?}",
                std::str::from_utf8(&s[b..s.len().min(b + 30)]).unwrap()
            );

                debug!("not found: {:?}", package);

            debug!("line {:?}", line);

                debug!("package: {:?}", st.package);

                    debug!("found {:?}", package);

                    debug!("smaller");

                    debug!("greater");

                debug!(
                    "break a = {:?}",
                    std::str::from_utf8(&s[a..s.len().min(a + 30)]).unwrap()
                );
                debug!(
                    "break b = {:?}",
                    std::str::from_utf8(&s[b..s.len().min(b + 30)]).unwrap()
                );

    /// Name of the package, to be appended to the hash to form a store path.

    /// Store paths to mount into the build environment.

    /// Build script to run inside the build environment.

    /// Target platform.

            inner_process(
                user, &r, &tmp_dir, &dest, &store, &tmp_store, &name,
            )

            inner_process(user, &r, &tmp_dir, &dest, &store, &tmp_store, &name)

let luau = stdenv.mkDerivation rec {
      pname = "luau";
      version = "0.621";
      src = fetchFromGitHub {
        owner = "luau-lang";
        repo = "luau";
        rev = version;
        hash = "sha256-bkuYYGYcnMwQDK81ZH+74hA4XaQfVFMWvAKpy+ODCak=";
      };
      nativeBuildInputs = [ cmake pkg-config ];
      buildInputs = lib.optionals stdenv.cc.isClang [ llvmPackages.libunwind ];
      installPhase = ''
    runHook preInstall
    install -Dm755 -t $out/bin luau
    install -Dm755 -t $out/bin luau-analyze
    install -Dm755 -t $out/bin luau-compile
    install -Dm755 -t $out/lib lib*
    runHook postInstall
  '';
  #     doCheck = true;
  #     checkPhase = ''
  #   runHook preCheck
  #   ./Luau.UnitTest
  #   ./Luau.Conformance
  #   runHook postCheck
  # '';
      # passthru.updateScript = gitUpdater { };

      meta = with lib; {
        description = "Fast, small, safe, gradually typed embeddable scripting language derived from Lua";
        homepage = "https://luau-lang.org/";
        changelog = "https://github.com/luau-lang/luau/releases/tag/${version}";
        license = licenses.mit;
        platforms = platforms.all;
        maintainers = [ ];
        mainProgram = "luau";
      };
    };
    # grpc-async = ocamlPackages.buildDunePackage rec {
    #   pname = "gprc-async";
    #   version = "0.2.0";
    #   src = builtins.fetchurl {
    #     url = "https://github.com/emilpriver/jsoo-code-mirror/archive/refs/tags/v0.0.1.tar.gz";
    #     sha256 = "sha256:0rby6kd9973icp72fj8i07awibamwsi3afy71dhrbq771dgz16cq";
    #   };
    #   propagatedBuildInputs = with pkgs; [
    #     ocamlPackages.brr
    #     ocamlPackages.js_of_ocaml
    #   ];
    # };
    gluten-async = ocamlPackages.buildDunePackage rec {

let gluten-async = ocamlPackages.buildDunePackage rec {

    # grpc-src = pkgs.fetchFromGitHub {
    #   owner = "dialohq";
    #   repo = "ocaml-grpc";
    #   rev = "b71fba7067bad2cad62df9abd8b4e190e3c4fc94";
    #   sha256 = "sha256-NtNU0ANMLRFFLoGtHMB0ynHbyh8YTfRF+PttJi9pYHU=";
    # };

    # luau

    # elpe

    elpe

toml = "0.8.23"
clap = { version = "4.5.39", features = ["derive"] }

version = "4.5.38"

version = "4.5.39"

checksum = "ed93b9805f8ba930df42c2590f05453d5ec36cbb85d018868a5b24d31f6ac000"

checksum = "fd60e63e9be68e5fb56422e397cf9baddded06dae1d2e523401542383bc72a9f"

 "clap_derive",

version = "4.5.38"

version = "4.5.39"

checksum = "379026ff283facf611b0ea629334361c4211d1b12ee01024eec1591133b04120"

checksum = "89cc6392a1f72bbeb820d71f32108f61fdaf18bc526e1d23954168a67759ef51"

name = "clap_derive"
version = "4.5.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09176aae279615badda0765c0c0b3f6ed53f4709118af73cf4655d85d1530cd7"
dependencies = [
 "heck",
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]

 "clap",

 "toml",

 "serde",
]
[[package]]
name = "serde_spanned"
version = "0.6.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
dependencies = [

]
[[package]]
name = "toml"
version = "0.8.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
dependencies = [
 "serde",
 "serde_spanned",
 "toml_datetime",
 "toml_edit",

name = "toml_datetime"
version = "0.6.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
dependencies = [
 "serde",
]
[[package]]
name = "toml_edit"
version = "0.22.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
dependencies = [
 "indexmap",
 "serde",
 "serde_spanned",
 "toml_datetime",
 "toml_write",
 "winnow",
]
[[package]]
name = "toml_write"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
[[package]]

[[package]]
name = "winnow"
version = "0.7.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c06928c8748d81b05c9be96aad92e1b6ff01833332f281e8cfca3be4b35fc9ec"
dependencies = [
 "memchr",
]