name: GitHub release

# copied from https://github.com/sharkdp/bat/blob/70ec3fc24e46cae8f0054a03f92ecfd53c7b98d6/.github/workflows/CICD.yml
# with edits

on:
  release:
    types: [published]
  workflow_dispatch:
    inputs:
      tag:
        description: 'Tag to upload artifacts to (leave empty for latest)'
        required: false
        default: ''

jobs:
  all-jobs:
    if: always() # Otherwise this job is skipped if the matrix job fails
    name: all-jobs
    runs-on: ubuntu-latest
    needs:
      - crate_metadata
      - lint
      - tests
      - cargo-audit
      - build
    steps:
      - run: jq --exit-status 'all(.result == "success")' <<< '${{ toJson(needs) }}'
  crate_metadata:
    name: Extract crate metadata
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v5
    - name: Extract crate information
      id: crate_metadata
      run: |
        TAG="${{ github.event.inputs.tag }}"
        if [ -z "$TAG" ]; then
          git fetch --tags
          TAG=$(git tag --sort=-creatordate | head -n 1)
        fi
        git fetch --tags --prune
        git checkout "tags/$TAG" -b "release-$TAG"
        echo "tag=$TAG" >> $GITHUB_OUTPUT
        cargo metadata --no-deps --format-version 1 | jq -r '"name=" + .packages[0].name' | tee -a $GITHUB_OUTPUT
        cargo metadata --no-deps --format-version 1 | jq -r '"version=" + .packages[0].version' | tee -a $GITHUB_OUTPUT
        cargo metadata --no-deps --format-version 1 | jq -r '"maintainer=" + .packages[0].authors[0]' | tee -a $GITHUB_OUTPUT
        cargo metadata --no-deps --format-version 1 | jq -r '"homepage=" + .packages[0].homepage' | tee -a $GITHUB_OUTPUT
    outputs:
      name: ${{ steps.crate_metadata.outputs.name }}
      version: ${{ steps.crate_metadata.outputs.version }}
      maintainer: ${{ steps.crate_metadata.outputs.maintainer }}
      homepage: ${{ steps.crate_metadata.outputs.homepage }}
      tag: ${{ steps.crate_metadata.outputs.tag }}

  lint:
    name: Ensure code quality
    runs-on: ubuntu-latest
    needs: crate_metadata
    steps:
    - uses: dtolnay/rust-toolchain@stable
      with:
        components: rustfmt,clippy
    - uses: actions/checkout@v5
      with:
        fetch-depth: 0
        ref: ${{ needs.crate_metadata.outputs.tag }}
    - run: |
        sudo apt-get -y update
        sudo apt-get -y install protobuf-compiler
        if command -v protoc >/dev/null 2>&1; then
          echo "PROTOC=$(command -v protoc)" >> $GITHUB_ENV
        fi
    - run: cargo fmt -- --check
    - run: cargo clippy --locked --all-targets --all-features -- -D warnings

  tests:
    name: Run tests
    runs-on: ubuntu-latest
    needs: crate_metadata
    steps:
    - name: Git checkout
      uses: actions/checkout@v5
      with:
        fetch-depth: 0
        ref: ${{ needs.crate_metadata.outputs.tag }}
    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@stable
    - name: Build and install
      run: |
        sudo apt-get -y update
        sudo apt-get -y install protobuf-compiler
        if command -v protoc >/dev/null 2>&1; then
          echo "PROTOC=$(command -v protoc)" >> $GITHUB_ENV
        fi
        cargo install --locked --path .
    - name: Run unit tests
      run: cargo test --locked

  cargo-audit:
    name: cargo audit
    runs-on: ubuntu-latest
    needs: crate_metadata
    steps:
      - run: cargo install cargo-audit --locked
      - uses: actions/checkout@v5
        with:
          fetch-depth: 0
          ref: ${{ needs.crate_metadata.outputs.tag }}
      - run: cargo audit
  build:
    permissions:
      contents: write
    name: ${{ matrix.job.target }} (${{ matrix.job.os }})
    runs-on: ${{ matrix.job.os }}
    needs: crate_metadata
    strategy:
      fail-fast: false
      matrix:
        job:
          - { target: aarch64-unknown-linux-musl  , os: ubuntu-latest, dpkg_arch: arm64,            use-cross: true }
          - { target: aarch64-unknown-linux-gnu   , os: ubuntu-latest, dpkg_arch: arm64,            use-cross: true }
          - { target: arm-unknown-linux-gnueabihf , os: ubuntu-latest, dpkg_arch: armhf,            use-cross: true }
          - { target: arm-unknown-linux-musleabihf, os: ubuntu-latest, dpkg_arch: musl-linux-armhf, use-cross: true }
          - { target: i686-pc-windows-msvc        , os: windows-2025,                                              }
          - { target: i686-unknown-linux-gnu      , os: ubuntu-latest, dpkg_arch: i686,             use-cross: true }
          - { target: i686-unknown-linux-musl     , os: ubuntu-latest, dpkg_arch: musl-linux-i686,  use-cross: true }
          - { target: x86_64-apple-darwin         , os: macos-15-intel,                                                  }
          - { target: aarch64-apple-darwin        , os: macos-14,                                                  }
          - { target: x86_64-pc-windows-msvc      , os: windows-2025,                                              }
          - { target: aarch64-pc-windows-msvc     , os: windows-11-arm,                                            }
          - { target: x86_64-unknown-linux-gnu    , os: ubuntu-latest, dpkg_arch: amd64,            use-cross: true }
          - { target: x86_64-unknown-linux-musl   , os: ubuntu-latest, dpkg_arch: musl-linux-amd64, use-cross: true }
    env:
      BUILD_CMD: cargo
    steps:
    - name: Checkout source code
      uses: actions/checkout@v5
      # with:
      #   fetch-depth: 0
      #   ref: ${{ needs.crate_metadata.outputs.tag }}

    - name: Install prerequisites (linux / macos)
      if: startsWith(matrix.job.os, 'ubuntu') || startsWith(matrix.job.os, 'macos')
      shell: bash
      run: |
        case ${{ matrix.job.os }} in
          ubuntu*|linux*)
            echo "installing linux prerequisites"
            sudo apt-get -y update
            case ${{ matrix.job.target }} in
              arm-unknown-linux-*) sudo apt-get -y install gcc-arm-linux-gnueabihf ;;
              aarch64-unknown-linux-gnu) sudo apt-get -y install gcc-aarch64-linux-gnu ;;
            esac
            ;;
          macos*)
            brew update
            brew install protobuf
            if ! command -v protoc >/dev/null 2>&1; then
              echo "protoc not installed properly on macOS, exiting with error..."
              exit 1
            fi
            PROTOC_PATH=$(command -v protoc)
            chmod 755 "$PROTOC_PATH" || true
            ;;
        esac

        if [ -n "$PROTOC_PATH" ]; then
          echo "PROTOC found at: $PROTOC_PATH"
          echo "PROTOC=$PROTOC_PATH" >> $GITHUB_ENV
        else
          echo "PROTOC not found"
        fi

    - name: Install prerequisites (windows)
      if: startsWith(matrix.job.os, 'windows-')
      shell: pwsh
      run: |
        choco install protoc -y --no-progress
        # refresh environment so current session sees updated PATH
        refreshenv
        $proto = (Get-Command protoc -ErrorAction SilentlyContinue).Source
        if (-not [string]::IsNullOrEmpty($proto)) {
          Write-Host "PROTOC found at: $proto"
          Add-Content -Path $env:GITHUB_ENV -Value "PROTOC=$proto"
          # also ensure PATH contains Chocolatey bin for processes that just call "protoc"
          Add-Content -Path $env:GITHUB_ENV -Value ("PATH=" + $env:Path + ";" + (Split-Path $proto))
          protoc --version
        } else {
          Write-Host "PROTOC not found"
          exit 1
        }

    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@stable
      with:
        targets: ${{ matrix.job.target }}

    - name: Install cross
      if: matrix.job.use-cross
      uses: taiki-e/install-action@v2
      with:
        tool: cross

    - name: Overwrite build command env variable
      if: matrix.job.use-cross
      shell: bash
      run: echo "BUILD_CMD=cross" >> $GITHUB_ENV

    - name: Show version information (Rust, cargo, GCC)
      shell: bash
      run: |
        gcc --version || true
        rustup -V
        rustup toolchain list
        rustup default
        cargo -V
        rustc -V

    - name: Build
      shell: bash
      run: |
        if [ -n "$PROTOC" ]; then
          echo "PROTOC env is set: $PROTOC"
        fi

        # Enable vendored-protoc when using cross builds (leave macOS/Windows alone)
        BUILD_FEATURES=""
        if [ "${{ matrix.job.use-cross }}" = "true" ]; then
          echo "Enabling vendored-protoc feature for cross build"
          BUILD_FEATURES="--features vendored-protoc"
        fi

        $BUILD_CMD build $BUILD_FEATURES --locked --release --target=${{ matrix.job.target }}

    - name: Set binary name & path
      id: bin
      shell: bash
      run: |
        # Figure out suffix of binary
        EXE_suffix=""
        case ${{ matrix.job.target }} in
          *-pc-windows-*) EXE_suffix=".exe" ;;
        esac;

        # Setup paths
        BIN_NAME="${{ needs.crate_metadata.outputs.name }}${EXE_suffix}"
        BIN_PATH="target/${{ matrix.job.target }}/release/${BIN_NAME}"

        # Let subsequent steps know where to find the binary
        echo "BIN_PATH=${BIN_PATH}" >> $GITHUB_OUTPUT
        echo "BIN_NAME=${BIN_NAME}" >> $GITHUB_OUTPUT

    - name: Set testing options
      id: test-options
      shell: bash
      run: |
        # test only library unit tests and binary for arm-type targets
        unset CARGO_TEST_OPTIONS
        unset CARGO_TEST_OPTIONS ; case ${{ matrix.job.target }} in arm-* | aarch64-*) CARGO_TEST_OPTIONS="--lib --bin ${{ needs.crate_metadata.outputs.name }}" ;; esac;
        # If we're using cross, enable vendored-protoc for tests as well
        CARGO_TEST_FEATURES=""
        if [ "${{ matrix.job.use-cross }}" = "true" ]; then
          CARGO_TEST_FEATURES="--features vendored-protoc"
        fi

        echo "CARGO_TEST_OPTIONS=${CARGO_TEST_OPTIONS}" >> $GITHUB_OUTPUT
        echo "CARGO_TEST_FEATURES=${CARGO_TEST_FEATURES}" >> $GITHUB_OUTPUT

    - name: Run tests
      shell: bash
      run: |
        if [[ ${{ matrix.job.os }} = windows-* ]]
        then
          powershell.exe -command "$BUILD_CMD test --locked --target=${{ matrix.job.target }} ${{ steps.test-options.outputs.CARGO_TEST_OPTIONS}} ${{ steps.test-options.outputs.CARGO_TEST_FEATURES}}"
        else
          $BUILD_CMD test --locked --target=${{ matrix.job.target }} ${{ steps.test-options.outputs.CARGO_TEST_OPTIONS}} ${{ steps.test-options.outputs.CARGO_TEST_FEATURES}}
        fi

    - name: Create tarball
      id: package
      shell: bash
      run: |
        PKG_suffix=".tar.gz" ; case ${{ matrix.job.target }} in *-pc-windows-*) PKG_suffix=".zip" ;; esac;
        PKG_BASENAME=${{ needs.crate_metadata.outputs.name }}-v${{ needs.crate_metadata.outputs.version }}-${{ matrix.job.target }}
        PKG_NAME=${PKG_BASENAME}${PKG_suffix}
        echo "PKG_NAME=${PKG_NAME}" >> $GITHUB_OUTPUT

        PKG_STAGING="_cicd-intermediates/package"
        ARCHIVE_DIR="${PKG_STAGING}/${PKG_BASENAME}/"
        mkdir -p "${ARCHIVE_DIR}"
        mkdir -p "${ARCHIVE_DIR}/autocomplete"

        # Binary
        cp "${{ steps.bin.outputs.BIN_PATH }}" "$ARCHIVE_DIR"

        # README, LICENSE and CHANGELOG files
        cp "README.md" "LICENSE" "$ARCHIVE_DIR"

        # base compressed package
        pushd "${PKG_STAGING}/" >/dev/null
        case ${{ matrix.job.target }} in
          *-pc-windows-*) 7z -y a "${PKG_NAME}" "${PKG_BASENAME}"/* | tail -2 ;;
          *) tar czf "${PKG_NAME}" "${PKG_BASENAME}"/* ;;
        esac;
        popd >/dev/null

        # Let subsequent steps know where to find the compressed package
        echo "PKG_PATH=${PKG_STAGING}/${PKG_NAME}" >> $GITHUB_OUTPUT

    - name: Create Debian package
      id: debian-package
      shell: bash
      if: startsWith(matrix.job.os, 'ubuntu')
      run: |
        COPYRIGHT_YEARS="2018 - "$(date "+%Y")
        DPKG_STAGING="_cicd-intermediates/debian-package"
        DPKG_DIR="${DPKG_STAGING}/dpkg"
        mkdir -p "${DPKG_DIR}"

        DPKG_BASENAME=${{ needs.crate_metadata.outputs.name }}
        DPKG_CONFLICTS=${{ needs.crate_metadata.outputs.name }}-musl
        case ${{ matrix.job.target }} in *-musl) DPKG_BASENAME=${{ needs.crate_metadata.outputs.name }}-musl ; DPKG_CONFLICTS=${{ needs.crate_metadata.outputs.name }} ;; esac;
        DPKG_VERSION=${{ needs.crate_metadata.outputs.version }}
        DPKG_ARCH="${{ matrix.job.dpkg_arch }}"
        DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb"
        echo "DPKG_NAME=${DPKG_NAME}" >> $GITHUB_OUTPUT

        # Binary
        install -Dm755 "${{ steps.bin.outputs.BIN_PATH }}" "${DPKG_DIR}/usr/bin/${{ steps.bin.outputs.BIN_NAME }}"

        # README and LICENSE
        install -Dm644 "README.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/README.md"
        install -Dm644 "LICENSE" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/LICENSE"

        cat > "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright" <<EOF
        Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
        Upstream-Name: ${{ needs.crate_metadata.outputs.name }}
        Source: ${{ needs.crate_metadata.outputs.homepage }}

        Files: *
        Copyright: ${{ needs.crate_metadata.outputs.maintainer }}
        Copyright: $COPYRIGHT_YEARS ${{ needs.crate_metadata.outputs.maintainer }}
        License: Apache-2.0 or MIT

        License: Apache-2.0
          On Debian systems, the complete text of the Apache-2.0 can be found in the
          file /usr/share/common-licenses/Apache-2.0.

        License: MIT
          Permission is hereby granted, free of charge, to any
          person obtaining a copy of this software and associated
          documentation files (the "Software"), to deal in the
          Software without restriction, including without
          limitation the rights to use, copy, modify, merge,
          publish, distribute, sublicense, and/or sell copies of
          the Software, and to permit persons to whom the Software
          is furnished to do so, subject to the following
          conditions:
          .
          The above copyright notice and this permission notice
          shall be included in all copies or substantial portions
          of the Software.
          .
          THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
          ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
          TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
          PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
          SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
          CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
          OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
          IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
          DEALINGS IN THE SOFTWARE.
        EOF
          chmod 644 "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright"

          # control file
          mkdir -p "${DPKG_DIR}/DEBIAN"
          cat > "${DPKG_DIR}/DEBIAN/control" <<EOF
        Package: ${DPKG_BASENAME}
        Version: ${DPKG_VERSION}
        Section: utils
        Priority: optional
        Maintainer: ${{ needs.crate_metadata.outputs.maintainer }}
        Homepage: ${{ needs.crate_metadata.outputs.homepage }}
        Architecture: ${DPKG_ARCH}
        Provides: ${{ needs.crate_metadata.outputs.name }}
        Conflicts: ${DPKG_CONFLICTS}
        Description: cat(1) clone with wings.
          A cat(1) clone with syntax highlighting and Git integration.
        EOF

        DPKG_PATH="${DPKG_STAGING}/${DPKG_NAME}"
        echo "DPKG_PATH=${DPKG_PATH}" >> $GITHUB_OUTPUT

        # build dpkg
        fakeroot dpkg-deb --build "${DPKG_DIR}" "${DPKG_PATH}"

    - name: "Artifact upload: tarball"
      uses: actions/upload-artifact@master
      with:
        name: ${{ steps.package.outputs.PKG_NAME }}
        path: ${{ steps.package.outputs.PKG_PATH }}

    - name: "Artifact upload: Debian package"
      uses: actions/upload-artifact@master
      if: steps.debian-package.outputs.DPKG_NAME
      with:
        name: ${{ steps.debian-package.outputs.DPKG_NAME }}
        path: ${{ steps.debian-package.outputs.DPKG_PATH }}

    - name: Publish archives and packages
      uses: ncipollo/release-action@v1
      with:
        tag: ${{ needs.crate_metadata.outputs.tag }}
        omitBody: true
        omitBodyDuringUpdate: true
        omitName: true
        allowUpdates: true
        prerelease: true
        replacesArtifacts: true
        updateOnlyUnreleased: false
        artifacts: ${{ steps.package.outputs.PKG_PATH }},${{ steps.debian-package.outputs.DPKG_PATH }}