name: Mod Build
on: push
env:
    MOD_NAME: "RefinedRDApi"
    MOD_ID: "7q2RnptXynYzEX"
    SML_DIR: "S:/SML"
    ENGINE_DIR: "S:/UE"
    BUILT_MODS_DIR: "${{ gitea.workspace }}/BuiltMods"
    DEV_BUILDS_DIR: "${{ gitea.workspace }}/DevBuilds"
    MODS_TO_BUILD: "RefinedRDApi"
    MOD_DEPENDENCIES: ""
    IS_GAME_FEATURE_PLUGIN: "false"

jobs:
    Details:
        runs-on: ubuntu-docker
        steps:
            - run: |
                  echo "DEPLOY: ${{vars.DEPLOY}}"
                  echo "DEVBUILD: ${{vars.DEVBUILD}}"
                  echo "Branch/Tag: ${{gitea.ref_name}}"
                  echo "Mod Name: ${{env.MOD_NAME}}"
                  echo "SML Directory: ${{env.SML_DIR}}"
                  echo "Engine Directory: ${{env.ENGINE_DIR}}"
                  echo "Built Mods Directory: ${{env.BUILT_MODS_DIR}}"
                  echo "Dev Build Directory: ${{env.DEV_BUILDS_DIR}}"
                  echo "Change Log: ${{vars.CHANGELOG}}"

    Build:
        runs-on: windows-ue
        defaults:
            run:
                shell: pwsh
        outputs:
            version: ${{steps.version.outputs.version}}
        steps:
            - name: Compute Version
              id: version
              run: |
                  $year = (Get-Date).Year
                  $month = (Get-Date).Month
                  $quarter = [math]::Ceiling($month / 3)
                  $quarterKey = "$year.$quarter"

                  $response = curl -s -X POST `
                      -H "x-rp-key: ${{secrets.RRD_API_KEY}}" `
                      -H "Content-Type: application/json" `
                      -d "{`"quarter`":`"$quarterKey`"}" `
                      "${{secrets.RRD_API_URL}}/api/v1/mods/buildnumber/${{env.MOD_NAME}}/increment" | ConvertFrom-Json

                  if (-not $response.build) {
                      Write-Error "Failed to get build number from API"
                      exit 1
                  }

                  $version = "$quarterKey.$($response.build)"
                  Write-Output "version=$version" >> $Env:GITHUB_OUTPUT
                  echo "Computed version: $version"

            - name: Setup SML
              run: |
                  if (Test-Path "${{env.SML_DIR}}/.git" -PathType Container) {
                      cd ${{env.SML_DIR}}
                      git fetch origin dev
                      git reset --hard origin/dev
                  } else {
                      git clone --branch dev https://github.com/satisfactorymodding/SatisfactoryModLoader.git ${{env.SML_DIR}}
                  }

            - name: Pull Wwise Project
              run: |
                  if (!(Test-Path "${{env.SML_DIR}}/SML_WwiseProject" -PathType Container)) {
                      git clone --branch main git@10.10.10.14:RefinedRD/WwiseProject.git "${{env.SML_DIR}}/SML_WwiseProject"
                  }
                  cd ${{env.SML_DIR}}/SML_WwiseProject
                  git fetch --all
                  git reset --hard origin/main
                  git lfs fetch --all
                  git lfs pull
                  git lfs checkout
                  $wwiseConsole = "C:/Program Files (x86)/Audiokinetic/Wwise2023.1.14.8770/Authoring/x64/Release/bin/WwiseConsole.exe"
                  if (!(Test-Path $wwiseConsole)) {
                      Write-Error "WwiseConsole not found at $wwiseConsole"
                      exit 1
                  }
                  & $wwiseConsole generate-soundbank "${{env.SML_DIR}}/SML_WwiseProject/SML_WwiseProject.wproj" --platform Windows Mac --verbose
                  echo "Done"

            - name: Pull Mods
              run: |
                  $modPath = "${{env.SML_DIR}}/Mods/${{env.MOD_NAME}}"
                  $repoName = "sf_mod_${{env.MOD_NAME}}"

                  if ("${{env.IS_GAME_FEATURE_PLUGIN}}" -eq "true") {
                    $modPath = "${{env.SML_DIR}}/Mods/GameFeatures/${{env.MOD_NAME}}"
                  }

                  if (!(Test-Path $modPath -PathType Container)) {
                    git clone git@10.10.10.14:RefinedRD/$repoName.git $modPath
                  }

                  cd $modPath
                  $ref = "${{gitea.ref_name}}"
                  git fetch --all --tags
                  if (git rev-parse --verify --quiet "refs/tags/$ref") {
                      git reset --hard $ref
                  } else {
                      git reset --hard "origin/$ref"
                  }
                  echo "Pulled ${{env.MOD_NAME}} @ latest (${{gitea.ref_name}})"

            - name: Update UPlugin Versions
              run: |
                  $newVersion = "${{steps.version.outputs.version}}"

                  $mod = "${{env.MOD_NAME}}"
                  $modPath = "${{env.SML_DIR}}/Mods/$mod"

                  if ("${{env.IS_GAME_FEATURE_PLUGIN}}" -eq "true") {
                    $modPath = "${{env.SML_DIR}}/Mods/GameFeatures/$mod"
                  }

                  $upluginPath = "$modPath/$mod.uplugin"
                  $UPlugin = (Get-Content $upluginPath | ConvertFrom-Json)

                  $majorVersion = [int]($newVersion -split '\.')[0]

                  $UPlugin.Version = $majorVersion
                  $UPlugin.SemVersion = $newVersion
                  $UPlugin.VersionName = $newVersion
                  echo "Set $mod version to $newVersion (Version=$majorVersion)"

                  ($UPlugin | ConvertTo-Json -Depth 100) -replace '\\u0026', '&' | Set-Content $upluginPath

            - name: Compile Editor
              run: |
                  $buildTool = "${{env.ENGINE_DIR}}/Engine/Binaries/DotNET/UnrealBuildTool/UnrealBuildTool.exe"
                  cd ${{env.SML_DIR}}
                  & $buildTool -projectfiles -project="${{env.SML_DIR}}/FactoryGame.uproject" -game -rocket -progress
                  & $buildTool Development Win64 -project="${{env.SML_DIR}}/FactoryGame.uproject" -TargetType="Editor" -progress

            - name: Build Mods
              run: |
                  $newVersion = "${{steps.version.outputs.version}}"

                  if (!(Test-Path ${{env.BUILT_MODS_DIR}})) {
                      New-Item -ItemType Directory -Force -Path ${{env.BUILT_MODS_DIR}}
                  }
                  $mod = "${{env.MOD_NAME}}"
                  if (Test-Path "${{env.SML_DIR}}/Saved/ArchivedPlugins/$mod") {
                    Remove-Item -Recurse "${{env.SML_DIR}}/Saved/ArchivedPlugins/$mod"
                  }

                  if ("${{env.IS_GAME_FEATURE_PLUGIN}}" -eq "true") {
                    $modPath = "${{env.SML_DIR}}/Mods/GameFeatures/$mod"
                  }else {
                    $modPath = "${{env.SML_DIR}}/Mods/$mod"
                  }

                    $version = $newVersion

                  & "${{env.ENGINE_DIR}}/Engine/Build/BatchFiles/RunUAT.bat" `
                    -ScriptsForProject="${{env.SML_DIR}}/FactoryGame.uproject" `
                    PackagePlugin `
                    -Project="${{env.SML_DIR}}/FactoryGame.uproject" `
                    -dlcname="$mod" `
                    -build -server `
                    -clientconfig=Shipping -serverconfig=Shipping `
                    -platform=Win64 -serverplatform=Win64+Linux `
                    -nocompileeditor -installed -merge

                  Copy-Item "${{env.SML_DIR}}/Saved/ArchivedPlugins/$mod/$mod.zip" "${{env.BUILT_MODS_DIR}}/$mod.$version.zip" -Force

                  echo "Done $mod @ $version"

            - name: Publish Built Version
              run: |
                  $version = "${{steps.version.outputs.version}}"
                  $modPath = "${{env.SML_DIR}}/Mods/${{env.MOD_NAME}}"
                  if ("${{env.IS_GAME_FEATURE_PLUGIN}}" -eq "true") {
                      $modPath = "${{env.SML_DIR}}/Mods/GameFeatures/${{env.MOD_NAME}}"
                  }
                  $commit = (git -C $modPath rev-parse HEAD)
                  $body = "{`"version`":`"$version`",`"commit`":`"$commit`"}"
                  curl -s -X POST `
                  -H "x-rp-key: ${{secrets.RRD_API_KEY}}" `
                  -H "Content-Type: application/json" `
                  -d $body `
                  "${{secrets.RRD_API_URL}}/api/v1/mods/version/${{env.MOD_NAME}}"
                  echo ""
                  echo "Published ${{env.MOD_NAME}} @ $version ($commit)"

            - uses: actions/upload-artifact@v3
              with:
                  name: built-mods
                  path: |
                      ${{env.BUILT_MODS_DIR}}/*.zip
                      ${{env.BUILT_MODS_DIR}}/Install-DevBuild.ps1
                  overwrite: true

    SMRDeploy:
        if: ${{ vars.DEPLOY == 'true' }}
        needs: Build
        runs-on: windows-ue
        defaults:
            run:
                shell: pwsh
        steps:
            - name: Download artifact
              uses: actions/download-artifact@v3
              with:
                  name: built-mods
                  path: ${{env.BUILT_MODS_DIR}}

            - name: Deploy to SMR
              run: |
                  echo "Deploying to SMR"
                  $Version = "${{needs.Build.outputs.version}}"
                  $query = '{ "query": "query { getModByReference(modReference:\"${{env.MOD_NAME}}\"){ versions(filter:{limit: 1}){ version } }}"}'
                  $SMRVersion = (Invoke-RestMethod `
                      -Method POST `
                      -Uri "https://api.ficsit.app/v2/query" `
                      -Body $query `
                      -ContentType "application/json").data.getModByReference.versions[0].version
                  if ($Version -eq $SMRVersion) {
                      echo "SMR Mod Version Already Exists.. Skip"
                      exit 0
                  }
                  $File = (Get-ChildItem "${{env.BUILT_MODS_DIR}}/${{env.MOD_NAME}}*").FullName
                  $APIURL = "https://api.ficsit.app"
                  Write-Host "Uploading $File to $APIURL"
                  & "S:/ficsit_windows_amd64.exe" smr upload `
                      --api-base "$APIURL" `
                      --api-key "${{secrets.FICSIT_TOKEN}}" `
                      "${{env.MOD_ID}}" "$File" "${{vars.CHANGELOG}}"
                  echo "Done"