# Documentation generation
{
  inputs,
  self,
  lib,
  ...
}:
let
  pkgs = inputs.nixpkgs.legacyPackages.x86_64-linux;

  # Extract options from a sample configuration
  getAthenixOptions =
    configName:
    let
      nixosConfig = self.nixosConfigurations.${configName};
      evaledOptions = nixosConfig.options;

      # Filter to just athenix namespace
      athenixOptions = evaledOptions.athenix or { };
    in
    athenixOptions;

  # Generate markdown documentation from options
  optionsToMarkdown =
    options:
    pkgs.writeText "options.md" ''
      # Athenix Configuration Options

      This document describes all available configuration options in the Athenix namespace.

      ## Quick Reference

      - **athenix.sw** - Software configuration (desktop, headless, kiosk modes)
      - **athenix.users** - User account management
      - **athenix.host** - Host-specific settings (filesystem, build methods)
      - **athenix.fleet** - Fleet inventory definitions
      - **athenix.forUser** - Convenience option to enable a user
      - **athenix.system.gc** - Garbage collection settings

      ## Detailed Options

      For detailed option information, use:
      ```bash
      # View all athenix options
      nix eval .#nixosConfigurations.nix-desktop1.options.athenix --apply builtins.attrNames

      # View specific option description
      nix eval .#nixosConfigurations.nix-desktop1.options.athenix.sw.desktop.enable.description

      # Export all options to JSON
      nix build .#athenix-options
      cat result | jq
      ```

      ## Software Types

      Enable different system configurations:

      - **desktop** - Full KDE Plasma desktop environment
      - **headless** - Server/container configuration  
      - **tablet-kiosk** - Touch-optimized kiosk for tablets
      - **stateless-kiosk** - Diskless PXE boot kiosk
      - **builders** - Build server with optional Gitea Actions runner

      See the individual option descriptions for detailed information.
    '';
in
{
  perSystem =
    { system, ... }:
    lib.mkIf (system == "x86_64-linux") {
      packages = {
        # Generate option documentation in markdown
        docs =
          pkgs.runCommand "athenix-docs"
            {
              nativeBuildInputs = [ pkgs.jq ];
            }
            ''
                        mkdir -p $out
                        
                        # Copy existing documentation
                        ${if builtins.pathExists ../README.md then "cp ${../README.md} $out/README.md" else ""}
                        ${if builtins.pathExists ../docs then "cp -r ${../docs} $out/guides" else ""}
                        
                        # Generate options reference
                        cat > $out/OPTIONS.md << 'EOF'
              ${builtins.readFile (optionsToMarkdown (getAthenixOptions "nix-desktop1"))}
                        EOF
                        
                        echo "Documentation generated in $out"
            '';

        # Extract just the athenix namespace options as JSON
        athenix-options =
          let
            nixosConfig =
              self.nixosConfigurations.nix-desktop1
                or (builtins.head (builtins.attrValues self.nixosConfigurations));

            # Recursively extract option information
            extractOption =
              opt:
              if opt ? _type && opt._type == "option" then
                {
                  inherit (opt) description;
                  type = opt.type.description or (opt.type.name or "unknown");
                  default =
                    if opt ? default then
                      if builtins.isAttrs opt.default && opt.default ? _type then "<special>" else opt.default
                    else
                      null;
                  example =
                    if opt ? example then
                      if builtins.isAttrs opt.example && opt.example ? _type then "<special>" else opt.example
                    else
                      null;
                }
              else if builtins.isAttrs opt then
                lib.mapAttrs (name: value: extractOption value) (
                  # Filter out internal attributes
                  lib.filterAttrs (n: _: !lib.hasPrefix "_" n) opt
                )
              else
                null;

            athenixOpts = nixosConfig.options.athenix or { };
          in
          pkgs.writeText "athenix-options.json" (builtins.toJSON (extractOption athenixOpts));
      };
    };
}