#!/usr/bin/env nu
# Generate taskserv skeleton structure for rapid creation
# Creates all required files: flake.nix, nixos-module.nix, Nickel files

use std

# Taskserv metadata
def taskserv-metadata [] {
  {
    # Batch 2: Container runtimes
    containerd: {
      category: "container",
      type: "container-runtime",
      description: "containerd container runtime for NixOS",
      nixos_module: "virtualisation.containerd",
      complexity: "moderate",
    },
    podman: {
      category: "container",
      type: "container-runtime",
      description: "Podman daemon-less container engine",
      nixos_module: "virtualisation.podman",
      complexity: "simple",
    },
    # Batch 3: Cluster base
    etcd: {
      category: "cluster",
      type: "distributed-kv",
      description: "etcd distributed key-value store for Kubernetes",
      nixos_module: "services.etcd",
      complexity: "moderate",
    },
    coredns: {
      category: "cluster",
      type: "dns-server",
      description: "CoreDNS for Kubernetes service discovery",
      nixos_module: "services.coredns",
      complexity: "simple",
    },
    # Batch 4: Kubernetes
    kubernetes: {
      category: "cluster",
      type: "orchestrator",
      description: "Kubernetes control plane and node components",
      nixos_module: "services.kubernetes",
      complexity: "complex",
    },
    # Batch 5: Storage and networking
    cilium: {
      category: "network",
      type: "cni",
      description: "Cilium eBPF-based networking for Kubernetes",
      nixos_module: "services.cilium",
      complexity: "complex",
    },
    external_nfs: {
      category: "storage",
      type: "nfs-client",
      description: "External NFS client mount configuration",
      nixos_module: "fileSystems",
      complexity: "simple",
    },
    rook_ceph: {
      category: "storage",
      type: "distributed-storage",
      description: "Rook operator for Ceph distributed storage",
      nixos_module: "services.kubernetes",
      complexity: "complex",
    },
    # Batch 6: Services
    postgres: {
      category: "services",
      type: "database",
      description: "PostgreSQL relational database",
      nixos_module: "services.postgresql",
      complexity: "simple",
    },
    redis: {
      category: "services",
      type: "cache",
      description: "Redis in-memory data store",
      nixos_module: "services.redis",
      complexity: "simple",
    },
    proxy: {
      category: "services",
      type: "load-balancer",
      description: "HAProxy network proxy and load balancer",
      nixos_module: "services.haproxy",
      complexity: "simple",
    },
    webhook: {
      category: "services",
      type: "webhook-handler",
      description: "Webhook handler service",
      nixos_module: "custom",
      complexity: "simple",
    },
  }
}

# Generate flake.nix template
def generate-flake [taskserv: string, description: string] {
  $"
{
  description = \"$description\";

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

  outputs = { self, nixpkgs, flake-utils }:
    flake-utils.lib.eachDefaultSystem (system:
      let
        pkgs = nixpkgs.legacyPackages.\${system};
      in
      {
        checks = {
          format = pkgs.runCommand \"($taskserv)-format-check\"
            {
              buildInputs = with pkgs; [ nixpkgs-fmt ];
            }
            ''
              nixpkgs-fmt --check \${./.}
              mkdir \$out
            '';
        };

        devShells.default = pkgs.mkShell {
          buildInputs = with pkgs; [
            nixpkgs-fmt
          ];
        };
      }
    ) // {
      nixosModules = {
        default = import ./nixos-module.nix;
      };
    };
}
"
}

# Generate nixos-module.nix template
def generate-module [taskserv: string, nixos_module: string] {
  let cfg_name = ($taskserv | str replace "_" "-")

  $"
{ config, lib, pkgs, ... }:
with lib;
let
  cfg = config.provisioning.taskservs.$taskserv;
in
{
  options.provisioning.taskservs.$taskserv = {
    enable = mkEnableOption \"$taskserv service\";
  };

  config = mkIf cfg.enable {
    # NixOS module configuration goes here
    # Reference: services.$nixos_module or virtualisation.*

    # Metadata
    assertions = [
      {
        assertion = true;
        message = \"$taskserv properly configured\";
      }
    ];
  };
}
"
}

# Generate main.ncl
def generate-main-ncl [taskserv: string, description: string] {
  $"
# $taskserv Taskserv Main Configuration

let defaults = import \"defaults.ncl\" in

{
  taskserv_name | doc \"Taskserv identifier\" = \"$taskserv\",
  taskserv_type | doc \"Taskserv category\" = \"$description\",
  taskserv_version | doc \"Taskserv version\" = \"1.0.0\",

  config | doc \"Default taskserv configuration\" = defaults.${taskserv}_config,

  metadata | doc \"Taskserv documentation\" = {
    description | doc \"What this taskserv provides\" = \"$description for NixOS\",
    author | doc \"Taskserv author\" = \"Provisioning Team\",
    documentation_path | doc \"Path to documentation\" = \"./README.md\",
  },
}
"
}

# Generate defaults.ncl
def generate-defaults-ncl [taskserv: string] {
  $"
# $taskserv Taskserv Defaults

{
  ${taskserv}_config | default = {
    enable | doc \"Enable $taskserv\" | default = true,
  },
}
"
}

# Generate contracts.ncl
def generate-contracts-ncl [taskserv: string] {
  $"
# $taskserv Taskserv Contracts

{
  ${(($taskserv | str capitalize) + "Config")} = {
    enable | Bool | doc \"Enable $taskserv\",
  },
}
"
}

# Main function
export def main [
    taskservs: list<string> = ["containerd", "podman", "etcd", "coredns", "kubernetes", "cilium", "external_nfs", "rook_ceph", "postgres", "redis", "proxy", "webhook"]
    --output-dir: string = "provisioning/extensions/taskservs"
] {
    let metadata = taskserv-metadata

    print $"Generating taskserv skeletons for ($taskservs | length) services..."

    for taskserv in $taskservs {
        if not ($metadata | has $taskserv) {
            print $"⚠ ($taskserv): not in metadata, skipping"
            continue
        }

        let meta = $metadata | get $taskserv
        let taskserv_dir = $"($output_dir)/($meta.category)/($taskserv)"

        mkdir $taskserv_dir
        mkdir $"($taskserv_dir)/nickel"
        mkdir $"($taskserv_dir)/modules"
        mkdir $"($taskserv_dir)/templates"
        mkdir $"($taskserv_dir)/scripts"

        # Generate flake.nix
        let flake_content = (generate-flake $taskserv $meta.description)
        $flake_content | save --force $"($taskserv_dir)/flake.nix"

        # Generate nixos-module.nix
        let module_content = (generate-module $taskserv $meta.nixos_module)
        $module_content | save --force $"($taskserv_dir)/nixos-module.nix"

        # Generate Nickel files
        let main_content = (generate-main-ncl $taskserv $meta.type)
        $main_content | save --force $"($taskserv_dir)/nickel/main.ncl"

        let defaults_content = (generate-defaults-ncl $taskserv)
        $defaults_content | save --force $"($taskserv_dir)/nickel/defaults.ncl"

        let contracts_content = (generate-contracts-ncl $taskserv)
        $contracts_content | save --force $"($taskserv_dir)/nickel/contracts.ncl"

        print $"✓ ($taskserv): skeleton generated at ($taskserv_dir)"
    }

    print "All taskserv skeletons generated successfully"
}