{{- /* Render code examples with all languages for Markdown output */ -}}
{{- /* This partial processes clients-example shortcodes and renders them as Markdown code blocks */ -}}
{{- /* Enhanced for AI agent readability with language labels and grouping */ -}}

{{- $content := .RawContent -}}

{{- /* Unescape HTML entities in the raw content */ -}}
{{- $content = $content | replaceRE """ "\"" -}}
{{- $content = $content | replaceRE """ "\"" -}}
{{- $content = $content | replaceRE "&lt;" "<" -}}
{{- $content = $content | replaceRE "&gt;" ">" -}}
{{- $content = $content | replaceRE "&amp;" "&" -}}
{{- $content = $content | replaceRE "&#39;" "'" -}}

{{- /* Language display name mapping */ -}}
{{- $langNames := dict -}}
{{- $langNames = merge $langNames (dict "redis-cli" "Redis CLI") -}}
{{- $langNames = merge $langNames (dict "c#" "C#") -}}
{{- $langNames = merge $langNames (dict "go" "Go") -}}
{{- $langNames = merge $langNames (dict "java" "Java") -}}
{{- $langNames = merge $langNames (dict "javascript" "JavaScript (Node.js)") -}}
{{- $langNames = merge $langNames (dict "node.js" "JavaScript (Node.js)") -}}
{{- $langNames = merge $langNames (dict "php" "PHP") -}}
{{- $langNames = merge $langNames (dict "python" "Python") -}}
{{- $langNames = merge $langNames (dict "rust" "Rust") -}}

{{- /* Language key to display name mapping for special cases */ -}}
{{- $keyNames := dict -}}
{{- $keyNames = merge $keyNames (dict "C#-Sync" "C# (Synchronous)") -}}
{{- $keyNames = merge $keyNames (dict "C#-Async" "C# (Asynchronous)") -}}
{{- $keyNames = merge $keyNames (dict "Java-Sync" "Java (Synchronous - Jedis)") -}}
{{- $keyNames = merge $keyNames (dict "Java-Async" "Java (Asynchronous - Lettuce)") -}}
{{- $keyNames = merge $keyNames (dict "Java-Reactive" "Java (Reactive - Lettuce)") -}}
{{- $keyNames = merge $keyNames (dict "Rust-Sync" "Rust (Synchronous)") -}}
{{- $keyNames = merge $keyNames (dict "Rust-Async" "Rust (Asynchronous)") -}}
{{- $keyNames = merge $keyNames (dict "Node.js" "JavaScript (Node.js)") -}}
{{- $keyNames = merge $keyNames (dict "Python" "Python") -}}
{{- $keyNames = merge $keyNames (dict "Go" "Go") -}}
{{- $keyNames = merge $keyNames (dict "PHP" "PHP") -}}

{{- /* Standard language code mapping for code fences */ -}}
{{- $codeFenceLangs := dict -}}
{{- $codeFenceLangs = merge $codeFenceLangs (dict "c#" "csharp") -}}
{{- $codeFenceLangs = merge $codeFenceLangs (dict "go" "go") -}}
{{- $codeFenceLangs = merge $codeFenceLangs (dict "java" "java") -}}
{{- $codeFenceLangs = merge $codeFenceLangs (dict "node.js" "javascript") -}}
{{- $codeFenceLangs = merge $codeFenceLangs (dict "javascript" "javascript") -}}
{{- $codeFenceLangs = merge $codeFenceLangs (dict "php" "php") -}}
{{- $codeFenceLangs = merge $codeFenceLangs (dict "python" "python") -}}
{{- $codeFenceLangs = merge $codeFenceLangs (dict "rust" "rust") -}}

{{- /* Process each clients-example shortcode */ -}}
{{- $pattern := `\{\{<\s*clients-example\s+(?:set|id)="([^"]+)"(?:\s+step="([^"]*)")?(?:\s+description="([^"]*)")?(?:\s+difficulty="([^"]*)")?(?:\s+buildsUpon="([^"]*)")?[^>]*>\s*([\s\S]*?)\s*\{\{<\s*/clients-example\s*>\}\}` -}}

{{- $processed := $content -}}
{{- $matches := findRE $pattern $content -}}

{{- range $match := $matches -}}
  {{- $exampleId := replaceRE $pattern `$1` $match -}}
  {{- $stepName := replaceRE $pattern `$2` $match -}}
  {{- $description := replaceRE $pattern `$3` $match -}}
  {{- $difficulty := replaceRE $pattern `$4` $match -}}
  {{- $buildsUponStr := replaceRE $pattern `$5` $match -}}
  {{- $cliContent := replaceRE $pattern `$6` $match -}}

  {{- /* Unescape HTML entities in description */ -}}
  {{- if $description -}}
    {{- $description = $description | replaceRE "&#34;" "\"" -}}
    {{- $description = $description | replaceRE "&quot;" "\"" -}}
    {{- $description = $description | replaceRE "&lt;" "<" -}}
    {{- $description = $description | replaceRE "&gt;" ">" -}}
    {{- $description = $description | replaceRE "&amp;" "&" -}}
    {{- $description = $description | replaceRE "&#39;" "'" -}}
    {{- $description = $description | replaceRE "&apos;" "'" -}}
  {{- end -}}

  {{- /* Parse buildsUpon into an array */ -}}
  {{- $buildsUpon := slice -}}
  {{- if $buildsUponStr -}}
    {{- $parts := split $buildsUponStr "," -}}
    {{- range $part := $parts -}}
      {{- $trimmed := trim $part " " -}}
      {{- if $trimmed -}}
        {{- $buildsUpon = $buildsUpon | append $trimmed -}}
      {{- end -}}
    {{- end -}}
  {{- end -}}

  {{- /* Get example data */ -}}
  {{- $exampleData := index $.Site.Data.examples $exampleId -}}
  {{- if $exampleData -}}
    {{- /* Build replacement with all languages */ -}}
    {{- $replacement := "" -}}

    {{- /* Add section header for this example group */ -}}
    {{- $replacement = printf "#### Code Examples\n\n" -}}

    {{- /* Add description if provided */ -}}
    {{- if $description -}}
      {{- $replacement = printf "%s%s\n\n" $replacement $description -}}
    {{- end -}}

    {{- /* Add difficulty level if provided */ -}}
    {{- if $difficulty -}}
      {{- $diffDisplay := $difficulty -}}
      {{- if eq $difficulty "beginner" -}}
        {{- $diffDisplay = "Beginner" -}}
      {{- else if eq $difficulty "intermediate" -}}
        {{- $diffDisplay = "Intermediate" -}}
      {{- else if eq $difficulty "advanced" -}}
        {{- $diffDisplay = "Advanced" -}}
      {{- end -}}
      {{- $replacement = printf "%s**Difficulty:** %s\n\n" $replacement $diffDisplay -}}
    {{- end -}}

    {{- /* Add buildsUpon information if provided */ -}}
    {{- if gt (len $buildsUpon) 0 -}}
      {{- $replacement = printf "%s**Builds upon:** %s\n\n" $replacement (delimit $buildsUpon ", ") -}}
    {{- end -}}

    {{- /* Add commands information if available */ -}}
    {{- $stepsCommands := index $exampleData "steps_commands" -}}
    {{- if and $stepsCommands $stepName (isset $stepsCommands $stepName) -}}
      {{- $commands := index $stepsCommands $stepName -}}
      {{- if $commands -}}
        {{- $commandNames := slice -}}
        {{- $commandsWithComplexity := slice -}}
        {{- range $cmdName := $commands -}}
          {{- $commandNames = $commandNames | append $cmdName -}}
          {{- /* Try to find command in multiple data files */ -}}
          {{- $cmdData := (index $.Site.Data.commands_core $cmdName) | default (index $.Site.Data.commands_redisearch $cmdName) | default (index $.Site.Data.commands_redisjson $cmdName) | default (index $.Site.Data.commands_redistimeseries $cmdName) | default (index $.Site.Data.commands_redisbloom $cmdName) -}}
          {{- if $cmdData -}}
            {{- $complexity := "" -}}
            {{- if $cmdData.complexity -}}
              {{- /* Extract just the O(...) part using regex */ -}}
              {{- $complexityMatch := findRE `^O\([^)]*\)(?:\s+amortized)?` $cmdData.complexity -}}
              {{- if $complexityMatch -}}
                {{- $complexity = index $complexityMatch 0 -}}
              {{- else if eq $cmdData.complexity "Depends on subcommand." -}}
                {{- $complexity = "Depends on subcommand" -}}
              {{- end -}}
            {{- end -}}
            {{- $commandsWithComplexity = $commandsWithComplexity | append (dict "name" $cmdName "complexity" $complexity) -}}
          {{- else -}}
            {{- $commandsWithComplexity = $commandsWithComplexity | append (dict "name" $cmdName "complexity" "") -}}
          {{- end -}}
        {{- end -}}
        {{- $replacement = printf "%s**Commands:** %s\n\n" $replacement (delimit $commandNames ", ") -}}
        {{- /* Add complexity information if available */ -}}
        {{- $hasComplexity := false -}}
        {{- range $cmd := $commandsWithComplexity -}}
          {{- if $cmd.complexity -}}
            {{- $hasComplexity = true -}}
          {{- end -}}
        {{- end -}}
        {{- if $hasComplexity -}}
          {{- $replacement = printf "%s**Complexity:**\n" $replacement -}}
          {{- range $cmd := $commandsWithComplexity -}}
            {{- if $cmd.complexity -}}
              {{- $replacement = printf "%s- %s: %s\n" $replacement $cmd.name $cmd.complexity -}}
            {{- end -}}
          {{- end -}}
          {{- $replacement = printf "%s\n" $replacement -}}
        {{- end -}}
      {{- end -}}
    {{- end -}}

    {{- /* Collect all language examples and build availability list */ -}}
    {{- $langExamples := slice -}}
    {{- $redisCliLang := dict -}}
    {{- $availableLangs := slice -}}

    {{- /* Add Redis CLI to availability list if we have CLI content */ -}}
    {{- if $cliContent -}}
      {{- $availableLangs = $availableLangs | append "Redis CLI" -}}
    {{- end -}}

    {{- /* Collect all other languages */ -}}
    {{- range $lang, $langData := $exampleData -}}
      {{- if ne $lang "steps_commands" -}}
        {{- if eq $lang "redis-cli" -}}
          {{- $redisCliLang = dict "key" $lang "data" $langData -}}
        {{- else -}}
          {{- $langCode := index $langData "language" -}}
          {{- $displayName := index $keyNames $lang -}}
          {{- if not $displayName -}}
            {{- $displayName = index $langNames $langCode -}}
          {{- end -}}
          {{- if not $displayName -}}
            {{- $displayName = $lang -}}
          {{- end -}}
          {{- $langExamples = $langExamples | append (dict "key" $lang "data" $langData "displayName" $displayName) -}}
          {{- $availableLangs = $availableLangs | append $displayName -}}
        {{- end -}}
      {{- end -}}
    {{- end -}}

    {{- /* Sort available languages alphabetically (except Redis CLI which stays first) */ -}}
    {{- $sortedLangs := slice -}}
    {{- $sortedLangs = $sortedLangs | append "Redis CLI" -}}
    {{- $otherLangs := slice -}}
    {{- range $lang := $availableLangs -}}
      {{- if ne $lang "Redis CLI" -}}
        {{- $otherLangs = $otherLangs | append $lang -}}
      {{- end -}}
    {{- end -}}
    {{- $otherLangs = sort $otherLangs -}}
    {{- range $lang := $otherLangs -}}
      {{- $sortedLangs = $sortedLangs | append $lang -}}
    {{- end -}}
    {{- $availableLangs = $sortedLangs -}}

    {{- /* Add CLI example first if provided */ -}}
    {{- if $cliContent -}}
      {{- /* Clean up the CLI content - remove leading/trailing whitespace and stray }} */ -}}
      {{- $cliContent = replaceRE "^\\s*\\}\\}\\s*" "" $cliContent -}}
      {{- $replacement = printf "%s**Redis CLI:**\n\n```\n%s\n```\n\n" $replacement $cliContent -}}
    {{- end -}}

    {{- /* Add language availability summary */ -}}
    {{- $replacement = printf "%s**Available in:** %s\n\n" $replacement (delimit $availableLangs ", ") -}}

    {{- /* Sort language examples by display name (alphabetically) */ -}}
    {{- $sortedLangExamples := slice -}}
    {{- range $sortedLang := $otherLangs -}}
      {{- range $langExample := $langExamples -}}
        {{- if eq $langExample.displayName $sortedLang -}}
          {{- $sortedLangExamples = $sortedLangExamples | append $langExample -}}
        {{- end -}}
      {{- end -}}
    {{- end -}}
    {{- $langExamples = $sortedLangExamples -}}

    {{- /* Rebuild language examples with Redis CLI first */ -}}
    {{- if $redisCliLang -}}
      {{- $finalLangs := slice $redisCliLang -}}
      {{- range $langExample := $langExamples -}}
        {{- $finalLangs = $finalLangs | append $langExample -}}
      {{- end -}}
      {{- $langExamples = $finalLangs -}}
    {{- end -}}

    {{- /* Add code examples for each language */ -}}
    {{- range $langExample := $langExamples -}}
      {{- $lang := $langExample.key -}}
      {{- $langData := $langExample.data -}}
      {{- $langCode := index $langData "language" -}}
      {{- $targetPath := index $langData "target" -}}
      {{- $namedSteps := index $langData "named_steps" -}}

      {{- /* Get the line range for this step if specified */ -}}
      {{- $lineRange := "" -}}
      {{- if and $stepName $namedSteps (isset $namedSteps $stepName) -}}
        {{- $lineRange = index $namedSteps $stepName -}}
      {{- end -}}

      {{- /* Read the file content */ -}}
      {{- $fileContent := "" -}}
      {{- if fileExists $targetPath -}}
        {{- $fileContent = readFile $targetPath -}}
      {{- end -}}

      {{- if $fileContent -}}
        {{- /* Extract lines if range specified */ -}}
        {{- $displayContent := $fileContent -}}
        {{- if $lineRange -}}
          {{- $parts := split $lineRange "-" -}}
          {{- if eq (len $parts) 2 -}}
            {{- $startLine := (index $parts 0 | int) -}}
            {{- $endLine := (index $parts 1 | int) -}}
            {{- $lines := split $fileContent "\n" -}}
            {{- $selectedLines := slice -}}
            {{- range $i, $line := $lines -}}
              {{- if and (ge (add $i 1) $startLine) (le (add $i 1) $endLine) -}}
                {{- $selectedLines = $selectedLines | append $line -}}
              {{- end -}}
            {{- end -}}
            {{- $displayContent = delimit $selectedLines "\n" -}}
          {{- end -}}
        {{- end -}}

        {{- /* Unescape HTML entities */ -}}
        {{- $displayContent = $displayContent | replaceRE "&#34;" "\"" -}}
        {{- $displayContent = $displayContent | replaceRE "&quot;" "\"" -}}
        {{- $displayContent = $displayContent | replaceRE "&lt;" "<" -}}
        {{- $displayContent = $displayContent | replaceRE "&gt;" ">" -}}
        {{- $displayContent = $displayContent | replaceRE "&amp;" "&" -}}
        {{- $displayContent = $displayContent | replaceRE "&#39;" "'" -}}

        {{- /* Get display name for language */ -}}
        {{- $displayName := index $keyNames $lang -}}
        {{- if not $displayName -}}
          {{- $displayName = index $langNames $langCode -}}
        {{- end -}}
        {{- if not $displayName -}}
          {{- $displayName = $lang -}}
        {{- end -}}

        {{- /* Get standard code fence language */ -}}
        {{- $codeFenceLang := index $codeFenceLangs $langCode -}}
        {{- if not $codeFenceLang -}}
          {{- $codeFenceLang = $langCode -}}
        {{- end -}}

        {{- /* Standardize Java variants to just 'java' for code fences */ -}}
        {{- if or (eq $codeFenceLang "java-async") (eq $codeFenceLang "java-reactive") -}}
          {{- $codeFenceLang = "java" -}}
        {{- end -}}

        {{- $replacement = printf "%s**%s:**\n\n```%s\n%s\n```\n\n" $replacement $displayName $codeFenceLang $displayContent -}}
      {{- end -}}
    {{- end -}}

    {{- /* Replace the shortcode with the rendered examples */ -}}
    {{- $processed = replace $processed $match $replacement 1 -}}
  {{- end -}}
{{- end -}}

{{- $processed -}}