name: Unreal Engine Build

on:
  workflow_dispatch:
  push:
    branches: [main, develop]

jobs:
  build-and-release:
    runs-on: windows
    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop'
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3
        with:
          lfs: false
          fetch-depth: 0

      - name: Setup environment
        run: |
          # Set environment variables for Unreal Engine
          echo "UE_ROOT=E:/Games/UE_5.5" >> $env:GITHUB_ENV
          # Set environment variables for Linux toolchain
          $env:LINUX_MULTIARCH_ROOT = "C:/UnrealToolchains/v23_clang-18.1.0-rockylinux8"
          echo "LINUX_MULTIARCH_ROOT=$env:LINUX_MULTIARCH_ROOT" >> $env:GITHUB_ENV
          
          # Create directories for builds
          mkdir -Force Builds/Windows
          mkdir -Force Builds/Linux
          mkdir -Force PackagedReleases

      - name: Build for Windows
        run: |
          # Execute Windows build script
          if (Test-Path ./win_build.sh) {
            # Use Git Bash to run shell scripts
            & 'C:\Program Files\Git\bin\bash.exe' -c "./win_build.sh"
          } else {
            echo "Windows build script not found. Creating placeholder build..."
            New-Item -Path "Builds/Windows" -Name "placeholder.txt" -ItemType "file" -Value "Windows build placeholder"
          }
      
      - name: Build for Linux
        run: |
          # Execute Linux build script
          if (Test-Path ./linux_build.sh) {
            # Use Git Bash to run shell scripts
            & 'C:\Program Files\Git\bin\bash.exe' -c "./linux_build.sh"
          } else {
            echo "Linux build script not found. Creating placeholder build..."
            New-Item -Path "Builds/Linux" -Name "placeholder.txt" -ItemType "file" -Value "Linux build placeholder"
          }
      
      - name: Package builds
        run: |
          echo "Packaging Windows build..."
          if (Test-Path "Builds/Windows") {
            # Change directory and create zip
            Push-Location Builds/Windows
            Compress-Archive -Path .\* -DestinationPath ..\..\PackagedReleases\LuckyRobots-Windows.zip -Force
            Pop-Location
          }
          
          echo "Packaging Linux build..."
          if (Test-Path "Builds/Linux") {
            # Change directory and create zip
            Push-Location Builds/Linux
            Compress-Archive -Path .\* -DestinationPath ..\..\PackagedReleases\LuckyRobots-Linux.zip -Force
            Pop-Location
          }
          
          echo "=== Packaged releases ==="
          Get-ChildItem -Path PackagedReleases
      
      - name: Create Tag
        if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop'
        run: |
          # Call Git Bash to handle Git operations
          & 'C:\Program Files\Git\bin\bash.exe' -c "
            # Fetch all tags
            git fetch --tags
            
            # Get the latest version tag, if any
            LATEST_TAG=\$(git tag -l 'v[0-9]*.[0-9]*.[0-9]*' | sort -V | tail -n1)
            
            if [ -z \"\$LATEST_TAG\" ]; then
              # No previous version tag, start with 1.0.0
              NEW_VERSION=\"1.0.0\"
              echo \"No previous version tags found, starting with 1.0.0\"
            else
              # Strip 'v' prefix if it exists
              VERSION=\${LATEST_TAG#v}
              
              # Split version into parts
              MAJOR=\$(echo \$VERSION | cut -d. -f1)
              MINOR=\$(echo \$VERSION | cut -d. -f2)
              PATCH=\$(echo \$VERSION | cut -d. -f3)
              
              # Auto-increment patch version
              PATCH=\$((PATCH + 1))
              NEW_VERSION=\"\${MAJOR}.\${MINOR}.\${PATCH}\"
              echo \"Auto-incremented patch version from \${VERSION} to \${NEW_VERSION}\"
            fi
            
            # Final tag with v prefix
            TAG=\"v\${NEW_VERSION}\"
            echo \"Creating git tag: \$TAG\"
            
            # Configure git with token authentication
            git config --global user.email \"actions@gitea.com\"
            git config --global user.name \"Gitea Actions\"
            
            # Direct token approach - simplest method
            git remote set-url origin \"https://goran:${{ secrets.GITEATOKEN }}@luckyrobots.com/goran/lyra_game_ue.git\"
            
            # Set git to not prompt for input
            export GIT_TERMINAL_PROMPT=0
            
            # Check if tag exists
            if ! git rev-parse \"\$TAG\" >/dev/null 2>&1; then
              # Create tag without opening editor (-m flag)
              git tag -a \"\$TAG\" -m \"Release \$TAG\"
              
              # Push with timeout and debug
              echo \"Pushing tag \$TAG to origin...\"
              git push --verbose origin \"\$TAG\" || {
                echo \"Error: Failed to push tag. Check your token permissions.\"
                exit 1
              }
              echo \"Successfully created and pushed tag: \$TAG\"
            else
              echo \"Tag \$TAG already exists, skipping tag creation\"
            fi
            echo \"RELEASE_TAG=\$TAG\" >> \$GITHUB_ENV
          "
          
          # Copy the RELEASE_TAG from Bash environment to PowerShell environment
          # Read the last tag created
          $latestTag = & 'C:\Program Files\Git\bin\bash.exe' -c "git tag | sort -V | tail -n1"
          echo "RELEASE_TAG=$latestTag" >> $env:GITHUB_ENV
      
      - name: Create Release
        uses: https://gitea.com/actions/gitea-release-action@main
        with:
          files: |-
            PackagedReleases/*.zip
          token: '${{ secrets.GITEATOKEN }}'
          title: 'Release ${{ env.RELEASE_TAG }}'
          body: |
            ## Automated release from CI build #${{ github.run_number }}
            
            This release includes builds for:
            - Windows
            - Linux
            
            Built from commit: ${{ github.sha }}
          prerelease: ${{ github.ref != 'refs/heads/main' }}
          tag_name: '${{ env.RELEASE_TAG }}'
          
  macos-build:
    runs-on: macos
    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop'
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3
        with:
          lfs: false
          fetch-depth: 0

      - name: Setup Unreal Engine
        run: |
          # Use the correct path where Unreal Engine is installed
          UE_PATH="/Users/Shared/Epic Games/UE_5.5"
          
          if [ ! -d "$UE_PATH" ]; then
            echo "Error: Unreal Engine is not installed in the expected location"
            echo "Please ensure Unreal Engine is installed at $UE_PATH"
            exit 1
          fi
          
          # Set environment variable with the correct Engine path
          echo "UE_ROOT=$UE_PATH/Engine" >> $GITHUB_ENV
          echo "Using Unreal Engine 5.5"
        
      - name: Build Unreal Project
        run: |
          chmod +x ./mac_build.sh
          ./mac_build.sh
        
      - name: Prepare Mac release
        run: |
          echo "Preparing packaged files for release..."
          
          # Create a directory for release files
          mkdir -p PackagedReleases
          
          # Debug: Show what we're packaging
          echo "=== Packaging for Release ==="
          echo "Build directory contents:"
          ls -la Builds/
          
          # Find the app bundle in the Builds directory
          APP_PATH=$(find Builds -type d -name "*.app" | head -1)
          
          if [ -n "$APP_PATH" ]; then
            echo "Found app bundle: $APP_PATH"
            # Get the app name
            APP_NAME=$(basename "$APP_PATH")
            # Create zip file of the app bundle
            (cd $(dirname "$APP_PATH") && zip -r "../../PackagedReleases/${APP_NAME%.app}-macOS.zip" "$APP_NAME")
            echo "Created packaged release: PackagedReleases/${APP_NAME%.app}-macOS.zip"
          else
            echo "No .app bundle found in Builds directory"
            
            # Look for a directory that might be a bundle but not named .app
            MAIN_BUILD_DIR=$(find Builds -mindepth 1 -maxdepth 1 -type d | head -1)
            if [ -n "$MAIN_BUILD_DIR" ]; then
              echo "Found main build directory: $MAIN_BUILD_DIR"
              DIR_NAME=$(basename "$MAIN_BUILD_DIR")
              # Package this directory as if it were the app
              (cd $(dirname "$MAIN_BUILD_DIR") && zip -r "../../PackagedReleases/${DIR_NAME}-macOS.zip" "$DIR_NAME")
              echo "Created packaged release from main directory: PackagedReleases/${DIR_NAME}-macOS.zip"
            else
              # Package the entire Builds directory as a fallback
              echo "No main directory found, packaging everything"
              zip -r "PackagedReleases/LuckyRobots-macOS.zip" Builds
              echo "Created fallback package: PackagedReleases/LuckyRobots-macOS.zip"
            fi
          fi
          
          echo "Packaged releases:"
          ls -la PackagedReleases/
      
      - name: Create Gitea Release
        if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop'
        uses: https://gitea.com/actions/gitea-release-action@main
        with:
          token: ${{ secrets.GITEATOKEN }}
          tag_name: ${{ env.RELEASE_TAG }}
          title: "Release ${{ env.RELEASE_TAG }}"
          files: PackagedReleases/*.zip