name: Release Plugin
run-name: "Release | ${{ inputs.name }} → ${{ inputs.tag }}"

on:
  workflow_dispatch:
    inputs:
      payload:
        description: 'Base64-kodierter JSON-Payload'
        required: true
      name:
        description: 'Plugin Name'
        required: true
      tag:
        description: 'Release Tag'
        required: true

jobs:
  release-plugin:
    runs-on: alpine-latest
    defaults:
      run:
        shell: bash

    steps:
      - name: Abhängigkeiten installieren
        shell: sh
        run: |
          apk add --no-cache bash jq git rsync zip curl

      - name: Daten zusammenstellen
        id: daten
        run: |
          DECODED=$(echo "${{ github.event.inputs.payload }}" | base64 -d)

          # Werte aus Payload auslesen
          NAME=$(echo "$DECODED"  | jq -r '.name')
          GROUP=$(echo "$DECODED" | jq -r '.group')
          VERSION=$(echo "$DECODED" | jq -r '.version')
          CHANNEL=$(echo "$DECODED" | jq -r '.channel')
          PRERELEASE=$(echo "$DECODED" | jq -r '.prerelease')
          ZIP_FOLDER=$(echo "$DECODED" | jq -r '.zip_folder')

          # Outputs setzen
          echo "name=$NAME"         >> $GITHUB_OUTPUT
          echo "group=$GROUP"       >> $GITHUB_OUTPUT
          echo "version=$VERSION"   >> $GITHUB_OUTPUT
          echo "channel=$CHANNEL"   >> $GITHUB_OUTPUT
          echo "prerelease=$PRERELEASE" >> $GITHUB_OUTPUT
          echo "zip_folder=$ZIP_FOLDER" >> $GITHUB_OUTPUT
          echo "zip_file=${ZIP_FOLDER}.zip" >> $GITHUB_OUTPUT

          # Debug-Ausgabe
          echo "name=$NAME"
          echo "group=$GROUP"
          echo "version=$VERSION"
          echo "channel=$CHANNEL"
          echo "prerelease=$PRERELEASE"
          echo "zip_folder=$ZIP_FOLDER"
          echo "zip_file=${ZIP_FOLDER}.zip"

          GIT_REPO_URL="https://${RELEASE_TOKEN}:x-oauth-basic@${{ vars.RELEASE_URL }}/${GITHUB_REPOSITORY}.git"
          echo "git_repo_url=$GIT_REPO_URL"                                 >> $GITHUB_OUTPUT
          echo "git_repo_url=$GIT_REPO_URL"

          PAYLOAD_REPO="${GROUP}/${NAME}"
          GIT_PLUGIN_URL="https://${RELEASE_TOKEN}:x-oauth-basic@${{ vars.RELEASE_URL }}/$PAYLOAD_REPO.git"
          echo "git_plugin_url=$GIT_PLUGIN_URL"                             >> $GITHUB_OUTPUT
          echo "git_plugin_url=$GIT_PLUGIN_URL"

      - name: Repositorys klonen
        run: |
          git clone "$GIT_REPO_URL" repo
          git clone "$GIT_PLUGIN_URL" plugin
          cd plugin
          git checkout "$CHANNEL"
          cd ..

        env:
          CHANNEL: ${{ steps.daten.outputs.channel }}
          GIT_REPO_URL: ${{ steps.daten.outputs.git_repo_url }}
          GIT_PLUGIN_URL: ${{ steps.daten.outputs.git_plugin_url }}
          RELEASE_TOKEN: ${{ secrets.RELEASE_TOKEN }}

      - name: Metadata anpassen
        run: |
          cd plugin
          INI_FILE="metadata.txt"
          # version setzen
          sed -i "s/^version=.*/version=$VERSION/" "$INI_FILE"

          # experimental setzen
          if [ "$PRERELEASE" = "true" ]; then
            sed -i "s/^experimental=.*/experimental=true/" "$INI_FILE"
          else
            sed -i "s/^experimental=.*/experimental=false/" "$INI_FILE"
          fi

          # channel im repository ersetzen
          sed -i "s|^\(repository=.*src/branch/\).*|\1$CHANNEL/|" "$INI_FILE"

          # Debug: Ausgabe der Datei
          echo "== Inhalt der angepassten INI-Datei =="
          cat "$INI_FILE"

        env:
          VERSION: ${{ steps.daten.outputs.version }}
          PRERELEASE: ${{ steps.daten.outputs.prerelease }}
          CHANNEL: ${{ steps.daten.outputs.channel }}

      - name: ZIP-Datei erstellen
        id: zip
        run: |
          mkdir -p ${ZIP_FOLDER}

          rsync -a \
            --exclude='.git' \
            --exclude='.gitea' \
            --exclude='.gitignore' \
            --exclude='plugin.cfg' \
            --exclude='*/__pycache__/*' \
            ./plugin/ ./${ZIP_FOLDER}/

          ls -la ${ZIP_FOLDER}/
          zip -r "${ZIP_FILE}" "${ZIP_FOLDER}/"
          ls -la

        env:
          ZIP_FOLDER: ${{ steps.daten.outputs.zip_folder }}
          ZIP_FILE: ${{ steps.daten.outputs.zip_folder }}.zip

      - name: Changelog einlesen
        id: changelog
        run: |
          cd plugin

          # Aktueller Block = alles vor dem ersten ---
          CURRENT=$(awk '/^---/{exit} {print}' changelog.txt)

          # Vollständige Historie = alles nach dem ersten ---
          HISTORY=$(awk 'found{print} /^---/{found=1}' changelog.txt)

          # Gitea Release Body zusammenbauen
          VERSION="${{ steps.releaseinfo.outputs.version }}"
          FULL=$(printf "## %s\n%s\n\n%s" "$VERSION" "$CURRENT" "$HISTORY")

          echo "DEBUG | Aktueller Changelog:"
          echo "$CURRENT"

          # Für GITHUB_OUTPUT: Multiline via EOF-Marker
          echo "current<<EOF" >> $GITHUB_OUTPUT
          echo "$CURRENT"     >> $GITHUB_OUTPUT
          echo "EOF"          >> $GITHUB_OUTPUT

          echo "full<<EOF"    >> $GITHUB_OUTPUT
          echo "$FULL"        >> $GITHUB_OUTPUT
          echo "EOF"          >> $GITHUB_OUTPUT

      - name: Gitea-Release erstellen
        id: create_release
        run: |
          API_URL="https://${{ vars.RELEASE_URL }}/api/v1/repos/${PLUGIN_GROUP}/${PLUGIN_NAME}/releases"

          JSON=$(jq -n \
            --arg tag "$TAG" \
            --arg name "Version $VERSION" \
            --arg body  "$BODY" \
            --argjson prerelease "$PRERELEASE" \
            '{tag_name: $tag, name: $name, body: $body, prerelease: $prerelease}')

          API_RESPONSE=$(curl -s -X POST "$API_URL" \
            -H "accept: application/json" \
            -H "Authorization: token $RELEASE_TOKEN" \
            -H "Content-Type: application/json" \
            -d "$JSON")

          RELEASE_ID=$(echo "$API_RESPONSE" | jq -r '.id')

            if [ "$RELEASE_ID" = "null" ] || [ -z "$RELEASE_ID" ]; then
              echo "Fehler beim Erstellen des Releases!"
              echo "$API_RESPONSE"
              exit 1
            fi

            echo "release_id=$RELEASE_ID" >> $GITHUB_OUTPUT
        env:
          PRERELEASE: ${{ steps.daten.outputs.prerelease }}
          BODY: ${{ steps.changelog.outputs.current }}
          VERSION: ${{ steps.daten.outputs.version }}
          TAG: ${{ steps.daten.outputs.version }}
          PLUGIN_NAME: ${{ steps.daten.outputs.name }}
          PLUGIN_GROUP: ${{ steps.daten.outputs.group }}  
          RELEASE_TOKEN: ${{ secrets.RELEASE_TOKEN }}

      - name: ZIP-Datei hochladen
        run: |
          pwd
          ls -la
          echo @${ZIP_FILE}
          
          API_URL="https://${{ vars.RELEASE_URL }}/api/v1/repos/${PLUGIN_GROUP}/${PLUGIN_NAME}/releases/${RELEASE_ID}/assets?name=${ZIP_FILE}"

          curl -sf -X POST "$API_URL" \
            -H "Authorization: token $RELEASE_TOKEN" \
            -H "Content-Type: application/zip" \
            --data-binary "@${ZIP_FILE}" \
            -o upload_response.json

          if jq -e '.id' upload_response.json >/dev/null 2>&1; then
            echo "ZIP erfolgreich hochgeladen."
          else
            echo "Fehler beim Hochladen der ZIP!"
            cat upload_response.json
            exit 1
          fi

        env:
          RELEASE_ID: ${{ steps.create_release.outputs.release_id }}
          ZIP_FILE: ${{ steps.daten.outputs.zip_file }}
          PLUGIN_NAME: ${{ steps.daten.outputs.name }}
          PLUGIN_GROUP: ${{ steps.daten.outputs.group }}
          RELEASE_TOKEN: ${{ secrets.RELEASE_TOKEN }}