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: true
          fetch-depth: 0

      - name: Setup environment
        run: |
          # Set environment variables for Unreal Engine
          echo "UE_ROOT=E:/Games/UE_5.5" >> $GITHUB_ENV
          # Set environment variables for Linux toolchain
          $env:LINUX_MULTIARCH_ROOT="C:/UnrealToolchains/v23_clang-18.1.0-rockylinux8"
          echo "LINUX_MULTIARCH_ROOT=${LINUX_MULTIARCH_ROOT}" >> $GITHUB_ENV
          
          # Create directories for builds (with error handling)
          if (!(Test-Path "Builds/Windows")) { New-Item -ItemType Directory -Path "Builds/Windows" -Force }
          if (!(Test-Path "Builds/Linux")) { New-Item -ItemType Directory -Path "Builds/Linux" -Force }
          if (!(Test-Path "PackagedReleases")) { New-Item -ItemType Directory -Path "PackagedReleases" -Force }

      - name: Build for Windows
        run: |
          chmod +x ./win_build.sh
          ./win_build.sh
      
      - name: Build for Linux
        run: |
          chmod +x ./linux_build.sh
          ./linux_build.sh
      
      - name: Package builds
        run: |
          echo "Packaging Windows build..."
          if [ -d "Builds/Windows" ]; then
            cd Builds/Windows
            zip -r ../../PackagedReleases/LuckyRobots-Windows.zip .
            cd ../..
          fi
          
          echo "Packaging Linux build..."
          if [ -d "Builds/Linux" ]; then
            cd Builds/Linux
            zip -r ../../PackagedReleases/LuckyRobots-Linux.zip .
            cd ../..
          fi
          
          echo "=== Packaged releases ==="
          ls -la PackagedReleases/
      
      - name: Create Tag
        if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop'
        run: |
          # 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/luckyrobots/luckyworld.git"
          
          # Set git to not prompt for input
          $env: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
      
      - name: Create Release
        uses: https://gitea.com/actions/gitea-release-action@main
        with:
          files: |-
            PackagedReleases/*.zip
          token: '${{ secrets.GITEA_TOKEN }}'
          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: true
          fetch-depth: 0

      - name: Get Release Tag
        run: |
          # Fetch all tags
          git fetch --tags
          
          # Get the latest version tag
          LATEST_TAG=$(git tag -l "v[0-9]*.[0-9]*.[0-9]*" | sort -V | tail -n1)
          
          if [ -z "$LATEST_TAG" ]; then
            NEW_VERSION="1.0.0"
          else
            VERSION=${LATEST_TAG#v}
            MAJOR=$(echo $VERSION | cut -d. -f1)
            MINOR=$(echo $VERSION | cut -d. -f2)
            PATCH=$(echo $VERSION | cut -d. -f3)
            PATCH=$((PATCH + 1))
            NEW_VERSION="${MAJOR}.${MINOR}.${PATCH}"
          fi
          
          TAG="v${NEW_VERSION}"
          echo "RELEASE_TAG=$TAG" >> $GITHUB_ENV
          echo "Using release tag: $TAG"

      - 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 with chunking
        run: |
          echo "Preparing packaged files for release..."
          
          # Create directories for packaging
          mkdir -p PackagedReleases/chunks
          
          # Find the app bundle in the Builds directory
          APP_PATH=$(find Builds -type d -name "*.app" | head -1)
          BUILD_DIR=""
          ZIP_BASE_NAME=""
          
          if [ -n "$APP_PATH" ]; then
            echo "Found app bundle: $APP_PATH"
            BUILD_DIR=$(dirname "$APP_PATH")
            APP_NAME=$(basename "$APP_PATH")
            ZIP_BASE_NAME="${APP_NAME%.app}-macOS"
          else
            echo "No .app bundle found, searching for other build directories"
            
            # Look for a directory that might be a build output
            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"
              BUILD_DIR=$(dirname "$MAIN_BUILD_DIR")
              DIR_NAME=$(basename "$MAIN_BUILD_DIR")
              ZIP_BASE_NAME="${DIR_NAME}-macOS"
            else
              echo "No build directory found, using entire Builds folder"
              BUILD_DIR="."
              ZIP_BASE_NAME="LuckyRobots-macOS"
            fi
          fi
          
          # Create chunks directory if it doesn't exist
          CHUNK_DIR="PackagedReleases/chunks"
          mkdir -p "$CHUNK_DIR"
          
          echo "Splitting build into 1.8GB chunks..."
          
          if [ -n "$BUILD_DIR" ]; then
            # Create a chunked zip archive directly
            (cd "$BUILD_DIR" && tar -c * | split -b 1800m - "$CHUNK_DIR/${ZIP_BASE_NAME}-part")
            echo "Created chunked build files"
            
            # Create a checksum file
            (cd "$CHUNK_DIR" && md5 ${ZIP_BASE_NAME}-part* > ${ZIP_BASE_NAME}-checksums.md5)
            
            # Create download scripts for different platforms
            
            # Windows batch script
            cat > "PackagedReleases/download-mac-build.bat" << 'EOL'
            @echo off
            echo LuckyRobots macOS Build Downloader
            echo ==================================
            echo.
            
            REM Get the release tag from command line or prompt user
            set TAG=%1
            if "%TAG%"=="" (
                echo Enter the release tag (e.g. v1.0.0):
                set /p TAG=
            )
            
            echo Downloading macOS build parts for %TAG%...
            echo.
            
            REM Create directory for downloads
            mkdir macos-build 2>nul
            cd macos-build
            
            REM Get the list of files to download
            curl -s -L -O https://luckyrobots.com/luckyrobots/luckyworld/releases/download/%TAG%/LuckyRobots-macOS-checksums.md5
            
            REM Extract filenames from the checksums file
            for /f "tokens=2 delims= " %%f in (LuckyRobots-macOS-checksums.md5) do (
                echo Downloading %%f...
                curl -L -O https://luckyrobots.com/luckyrobots/luckyworld/releases/download/%TAG%/%%f
            )
            
            echo All parts downloaded. Combining...
            copy /b LuckyRobots-macOS-part* LuckyRobots-macOS.tar
            
            echo Extracting files...
            tar -xf LuckyRobots-macOS.tar
            
            echo Done! macOS build downloaded and extracted.
            cd ..
            EOL
            
            # macOS/Linux bash script
            cat > "PackagedReleases/download-mac-build.sh" << 'EOL'
            #!/bin/bash
            
            echo "LuckyRobots macOS Build Downloader"
            echo "=================================="
            echo
            
            # Get the release tag from command line or prompt user
            TAG=$1
            if [ -z "$TAG" ]; then
                echo "Enter the release tag (e.g. v1.0.0):"
                read TAG
            fi
            
            echo "Downloading macOS build parts for $TAG..."
            echo
            
            # Create directory for downloads
            mkdir -p macos-build
            cd macos-build
            
            # Get the list of files to download
            curl -s -L -O "https://luckyrobots.com/luckyrobots/luckyworld/releases/download/$TAG/LuckyRobots-macOS-checksums.md5"
            
            # Extract filenames from the checksums file
            for file in $(awk '{print $2}' LuckyRobots-macOS-checksums.md5); do
                echo "Downloading $file..."
                curl -L -O "https://luckyrobots.com/luckyrobots/luckyworld/releases/download/$TAG/$file"
            done
            
            echo "All parts downloaded. Combining..."
            cat LuckyRobots-macOS-part* > LuckyRobots-macOS.tar
            
            echo "Extracting files..."
            tar -xf LuckyRobots-macOS.tar
            
            echo "Done! macOS build downloaded and extracted."
            cd ..
            EOL
            
            # Make the shell script executable
            chmod +x "PackagedReleases/download-mac-build.sh"
            
            # Create a simple README
            cat > "PackagedReleases/README-macOS.txt" << 'EOL'
            # LuckyRobots macOS Build
            
            This build is split into multiple files due to size limitations.
            
            ## Easy Download
            
            For the easiest download experience:
            
            - Windows: Download and run download-mac-build.bat
            - macOS/Linux: Download and run download-mac-build.sh
            
            Both scripts will automatically download all needed files, combine them,
            and extract the build to a folder called "macos-build".
            
            ## Manual Download
            
            If you prefer to download manually:
            
            1. Download all the part files (LuckyRobots-macOS-part*)
            2. Combine them:
               - Windows: copy /b LuckyRobots-macOS-part* LuckyRobots-macOS.tar
               - macOS/Linux: cat LuckyRobots-macOS-part* > LuckyRobots-macOS.tar
            3. Extract the tar file:
               - Using tar -xf LuckyRobots-macOS.tar
            
            Enjoy playing!
            EOL
            
            # Zip the instructions and scripts for easy download
            zip -j "PackagedReleases/LuckyRobots-macOS-downloader.zip" \
              "PackagedReleases/README-macOS.txt" \
              "PackagedReleases/download-mac-build.bat" \
              "PackagedReleases/download-mac-build.sh"
            
            # Also copy the checksum file up one level for the downloader
            cp "$CHUNK_DIR/${ZIP_BASE_NAME}-checksums.md5" "PackagedReleases/${ZIP_BASE_NAME}-checksums.md5"
            
            # List the files
            echo "Created files:"
            ls -la "$CHUNK_DIR"
            echo "Created downloader package:"
            ls -la "PackagedReleases"
          else
            echo "Error: Could not find any build directory to package"
            exit 1
          fi
      
      - 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 }}"
          body: |
            ## Automated release from CI build #${{ github.run_number }}
            
            ### macOS Build Instructions
            
            **Quick setup:** Download the LuckyRobots-macOS-downloader.zip file first!
            This contains scripts that will automatically download and extract all parts.
            
            For manual setup:
            1. Download all part files
            2. Combine them using: `cat LuckyRobots-macOS-part* > LuckyRobots-macOS.tar`
            3. Extract with: `tar -xf LuckyRobots-macOS.tar`
            
            Built from commit: ${{ github.sha }}
          files: |-
            PackagedReleases/*.zip
            PackagedReleases/*.md5
            PackagedReleases/chunks/*