geode.shard

rec {
    lib = rec {
        mkPackage = pkgSet: pkgSet // { __functor = self: config: builtins.mergeTree self { inherit config; }; };
    };

    util = rec {
        ensureExists = { path, default ? null }: assert geode.file.exists path; default;

        dirEnts = dir: let
                found = shell.find [
                    dir
                    "("
                    "-type" "f"
                    "-o" "-type" "d"
                    ")"
                    "-printf"
                    "%P\n"
                ];
            in assert found.exitCode == 0; builtins.split "\n" found.stdout;

        mkdirIfNotExists = path: if geode.file.exists path
            then 0
            else assert (geode.file.mkdir path) == 0; path;

        mkdirRec = path: if geode.file.exists path
            then 0
            else builtins.seq
                (mkdirRec (geode.file.dirname path))
                (geode.file.mkdir path);

        merge = fst: snd: fst // snd;

        installFile = { src, dst, mode ? "744" }: let dstDir = geode.file.dirname (geode.prefix + dst); 
            in assert (mkdirRec dstDir) == 0;
                shell.install ["-m" mode src (geode.prefix + dst)];

        installFiles = builtins.map installFile;

        writeFile = file: data: builtins.seq
            (mkdirRec $ geode.file.dirname file)
            (geode.file.writeFile file $ builtins.toString data);

        # utility functions that mimic shell commands
        shell = {
            cp = args: 
                geode.proc.spawn "cp" (builtins.map builtins.toString args) true;

            make = args: 
                geode.proc.spawn "make" (builtins.map builtins.toString (args ++ ["-j" (geode.proc.nJobs)])) true;

            find = args: 
                geode.proc.spawnPipe "find" (builtins.map builtins.toString args) "";

            install = args:
                geode.proc.spawn "install" (builtins.map builtins.toString args) true;

            xorriso = args:
                geode.proc.spawn "xorriso" (builtins.map builtins.toString args) true;

            nproc = geode.proc.spawn "nproc" [] true;
        };

        paths = rec {
            prefix = ensureExists { path = geode.prefix; default = geode.prefix; };
            store = ensureExists { path = geode.store; default = geode.store; };

            gcc_specs = let path = prefix + "/lib/gcc/cross-libc.specs"; 
                in ensureExists { inherit path; default = path; };
        };

        archive = {
            mkisofs = { input, output ? "amethyst.iso", uefi ? null }: geode.proc.spawn "xorriso" [
                "-as" "mkisofs"
                input
                "-o" output
            ] true;
        };

        io = rec {
            term = rec {
                reset = "\e[0m";
                bold = "\e[1m";
                
                red = "\e[31m";
                green = "\e[32m";
                yellow = "\e[33m";
                blue = "\e[34m";
                magenta = "\e[35m";
                cyan = "\e[36m";

                color = c: s: c + s + reset;
            };

            fmtMajor = str: term.bold + (term.color term.cyan str);

            logMajor = str: task: builtins.seq (geode.debug.println $ fmtMajor str) task;
        };
    };

    templates = {
        staticConfig = {
            boot.kernelParams = [];
            boot.initrd = {
                compression = "ustar";
                path = /boot/initrd;
                enabled = false;
            };

            environment.systemPackages = [];
        };
    };

    manager = rec {
        pkgAttrs = pkg: builtins.head (builtins.attrValues pkg);

        pkgOpts = pkg: (pkgAttrs pkg).opts or {};
        pkgName = pkg: (pkgAttrs pkg).name or null;

        pkgBuildDependencies = pkg: pkg.buildDependencies or [];

        announceBuild = pkg: util.io.logMajor ("Building " + pkg.name + "...");

        announceInstall = pkg: util.io.logMajor ("Installing " + pkg.name + "...");

        newTask = name: task: if task == null then [] else
            [{ inherit name task; }];

        buildPipeline = config: pkg: builtins.foldl (a: b: a ++ b) [] (builtins.map (installPipeline config) $ pkgBuildDependencies pkg)
            ++ (announceBuild pkg (
                (newTask "fetch" pkg.fetch or null)
                ++ (newTask "unpack" pkg.unpack or null)
                ++ (newTask "patch" pkg.patch or null)
                ++ (newTask "configure" pkg.configure or null)
                ++ (newTask "build" pkg.build or null)
                ++ (newTask "check" pkg.check or null)
            ));

        installPipeline = config: pkg: let
            noEnableFlag = c: true;
        in if (pkg.isEnabled or noEnableFlag) config
            then (buildPipeline config pkg) ++ (announceInstall pkg $ newTask "install" pkg.install or null)
            else [];

        installPkg = pkg: with builtins;
            let
                taskError = msg: name: geode.error.throw $ "Task '" + name + "' on package '" + pkg.name + "' " + msg + ".";
                successful = name: task: 
                    if isNull task then true
                    else if isInt task then task == 0
                    else if isList task then all (successful name) task
                    else taskError "returned unexpected value" name;
                reportError = { name, task }: if successful name task 
                    then true 
                    else taskError ("returned non-zero exit code: " + $ toString task) name;
            in all reportError $ manager.installPipeline config pkg;
    };

    pkgIndex = let 
            found = util.shell.find [(geode.store + "/pkgs") "-type" "f" "-name" "*.shard"];
        in assert found.exitCode == 0; builtins.split "\n" found.stdout;

    pkgList = builtins.map import pkgIndex;
    pkgs = builtins.foldl util.merge {} pkgList;
}