dev.ps1

param(
    [Parameter(Position = 0)]
    [string]$Command
)

Write-Host "If you get an execution policy error, run this once:"
Write-Host ""
Write-Host "Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser"
Write-Host ""

# DroneWorld Development Helper Script (PowerShell)
# Usage: .\dev.ps1 [command]

function Test-Token {
    # Check if token is in environment
    if (-not [string]::IsNullOrWhiteSpace($env:GITHUB_TOKEN)) {
        return $true
    }
    
    # Check if token is in .env file and auto-export it
    if (Test-Path ".env") {
        $envContent = Get-Content ".env"
        $tokenLine = $envContent | Where-Object { $_ -match "^GITHUB_TOKEN=" }
        if ($tokenLine) {
            $token = $tokenLine -replace "^GITHUB_TOKEN=", ""
            if (-not [string]::IsNullOrWhiteSpace($token)) {
                $env:GITHUB_TOKEN = $token
                Write-Host " Loaded GITHUB_TOKEN from .env" -ForegroundColor Green
                return $true
            }
        }
    }
    
    Write-Host "  GITHUB_TOKEN not found." -ForegroundColor Yellow
    Write-Host "Run '.\dev.ps1 token' to set it up." -ForegroundColor Yellow
    return $false
}

function Set-Token {
    Write-Host " Setting up GITHUB_TOKEN..." -ForegroundColor Green
    Write-Host ""
    
    # Check if token already exists in .env
    if (Test-Path ".env") {
        $envContent = Get-Content ".env"
        $tokenLine = $envContent | Where-Object { $_ -match "^GITHUB_TOKEN=" }
        if ($tokenLine) {
            $currentToken = $tokenLine -replace "^GITHUB_TOKEN=", ""
            if (-not [string]::IsNullOrWhiteSpace($currentToken)) {
                $preview = $currentToken.Substring(0, [Math]::Min(10, $currentToken.Length))
                Write-Host " Found existing token in .env: $preview..." -ForegroundColor Green
                $response = Read-Host "Use existing token? (Y/n)"
                if ([string]::IsNullOrWhiteSpace($response) -or $response -match "^[Yy]$") {
                    $env:GITHUB_TOKEN = $currentToken
                    Write-Host " Token exported for current session" -ForegroundColor Green
                    return
                }
            }
        }
    }
    
    # Prompt for new token
    $secureToken = Read-Host "Enter your GitHub Personal Access Token" -AsSecureString
    $BSTR = [System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($secureToken)
    $token = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto($BSTR)
    [System.Runtime.InteropServices.Marshal]::ZeroFreeBSTR($BSTR)
    
    if ([string]::IsNullOrWhiteSpace($token)) {
        Write-Host " No token provided" -ForegroundColor Red
        return
    }
    
    # Set environment variable for current session
    $env:GITHUB_TOKEN = $token
    
    # Save to .env file in root
    $envFile = ".env"
    $tokenLine = "GITHUB_TOKEN=$token"
    
    if (Test-Path $envFile) {
        $content = Get-Content $envFile
        $found = $false
        $newContent = $content | ForEach-Object {
            if ($_ -match "^GITHUB_TOKEN=") {
                $found = $true
                $tokenLine
            }
            else {
                $_
            }
        }
        
        if ($found) {
            $newContent | Set-Content $envFile
            Write-Host " Updated GITHUB_TOKEN in .env" -ForegroundColor Green
        }
        else {
            Add-Content $envFile "`n$tokenLine"
            Write-Host " Added GITHUB_TOKEN to .env" -ForegroundColor Green
        }
    }
    else {
        $tokenLine | Set-Content $envFile
        Write-Host " Created .env with GITHUB_TOKEN" -ForegroundColor Green
    }
    
    Write-Host " Token exported for current session" -ForegroundColor Green
}

function Get-FrontendEnvValue {
    param(
        [Parameter(Mandatory = $true)]
        [string]$Name
    )

    if (-not (Test-Path "frontend/.env")) {
        return $null
    }

    $line = Get-Content "frontend/.env" | Where-Object { $_ -match "^\s*$Name\s*=" } | Select-Object -Last 1
    if (-not $line) {
        return $null
    }

    $value = ($line -replace "^\s*$Name\s*=\s*", "").Trim()
    if ($value.Length -ge 2) {
        if (($value.StartsWith('"') -and $value.EndsWith('"')) -or ($value.StartsWith("'") -and $value.EndsWith("'"))) {
            $value = $value.Substring(1, $value.Length - 2)
        }
    }

    return $value
}

function Test-FrontendLockAutoSyncEnabled {
    $value = $null

    if (-not [string]::IsNullOrWhiteSpace($env:AUTO_SYNC_FRONTEND_LOCKFILE)) {
        $value = $env:AUTO_SYNC_FRONTEND_LOCKFILE
    }
    else {
        $value = Get-FrontendEnvValue -Name "AUTO_SYNC_FRONTEND_LOCKFILE"
    }

    if ([string]::IsNullOrWhiteSpace($value)) {
        return $true
    }

    switch ($value.Trim().ToLowerInvariant()) {
        "0" { return $false }
        "false" { return $false }
        "no" { return $false }
        "off" { return $false }
        default { return $true }
    }
}

function Sync-FrontendLockfileIfNeeded {
    if (-not (Test-FrontendLockAutoSyncEnabled)) {
        Write-Host " Frontend lockfile auto-sync disabled (AUTO_SYNC_FRONTEND_LOCKFILE=false)." -ForegroundColor Yellow
        return
    }

    if (-not (Test-Path "frontend/package.json")) {
        return
    }

    $frontendPath = (Resolve-Path ".\frontend").Path
    Write-Host " Checking frontend lockfile consistency (node:20/npm)..." -ForegroundColor Cyan

    & docker run --rm -v "${frontendPath}:/app" -w /app node:20 npm ci --dry-run --ignore-scripts --no-audit --no-fund *> $null
    if ($LASTEXITCODE -eq 0) {
        Write-Host " Frontend lockfile is in sync." -ForegroundColor Green
        return
    }

    Write-Host " Frontend lockfile out of sync. Regenerating package-lock.json..." -ForegroundColor Yellow
    & docker run --rm -v "${frontendPath}:/app" -w /app node:20 npm install --package-lock-only --no-audit --no-fund
    if ($LASTEXITCODE -ne 0) {
        Write-Host " Failed to regenerate frontend/package-lock.json." -ForegroundColor Red
        exit 1
    }

    Write-Host " Updated frontend/package-lock.json using node:20/npm." -ForegroundColor Green
}

function Show-Usage {
    Write-Host ""
    Write-Host "Usage: .\dev.ps1 [command]" -ForegroundColor Cyan
    Write-Host ""
    Write-Host "Commands:" -ForegroundColor Yellow
    Write-Host "  token       - Set GITHUB_TOKEN for building simulator (required for 'full' and 'simulator')"
    Write-Host "  full        - Start all services (frontend, backend, simulator)"
    Write-Host "  full-rebuild - Rebuild and start full stack (frontend, backend, simulator)"
    Write-Host "  dev         - Start development services only (frontend, backend)"
    Write-Host "  dev-rebuild - Rebuild and start development services (frontend, backend)"
    Write-Host "  dev-rebuild-frontend - Rebuild frontend image, then start frontend in dev compose"
    Write-Host "  dev-rebuild-backend - Rebuild backend image, then start backend in dev compose"
    Write-Host "  frontend    - Start frontend only"
    Write-Host "  backend     - Start backend only"
    Write-Host "  simulator   - Start simulator only"
    Write-Host "  logs        - Follow logs for dev services"
    Write-Host "  logs-all    - Follow logs for all services"
    Write-Host "  stop        - Stop all services"
    Write-Host "  stop-dev    - Stop development services only"
    Write-Host "  clean       - Stop and remove all containers and volumes"
    Write-Host "  help        - Show this help message"
    Write-Host ""
    Write-Host "Examples:" -ForegroundColor Cyan
    Write-Host "  .\dev.ps1 token        # Set GitHub token (needed before 'full' or 'simulator')"
    Write-Host "  .\dev.ps1 dev          # Quick start for development"
    Write-Host "  .\dev.ps1 dev-rebuild  # Rebuild frontend/backend images, then start dev services"
    Write-Host "  .\dev.ps1 dev-rebuild-frontend # Rebuild only frontend image for faster UI iteration"
    Write-Host "  .\dev.ps1 dev-rebuild-backend  # Rebuild only backend image for faster API iteration"
    Write-Host "  .\dev.ps1 full         # Start everything including simulator"
    Write-Host "  .\dev.ps1 full-rebuild # Rebuild all images, then start full stack"
    Write-Host "  frontend/.env: AUTO_SYNC_FRONTEND_LOCKFILE=false # Opt out of auto lockfile sync"
    Write-Host ""
    Write-Host "If you get an execution policy error, run this once:" -ForegroundColor Red
    Write-Host ""
    Write-Host "Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser"
    Write-Host ""
}

switch ($Command) {
    "token" {
        Set-Token
    }
    "full" {
        if (-not (Test-Token)) {
            Write-Host ""
            $response = Read-Host "Continue without token? The simulator will fail to build. (y/N)"
            if ($response -notmatch "^[Yy]$") {
                exit 1
            }
        }
        Write-Host " Starting full stack (frontend + backend + simulator)..." -ForegroundColor Green
        docker-compose up
    }
    "full-rebuild" {
        if (-not (Test-Token)) {
            Write-Host ""
            $response = Read-Host "Continue without token? The simulator will fail to build. (y/N)"
            if ($response -notmatch "^[Yy]$") {
                exit 1
            }
        }
        Write-Host " Rebuilding and starting full stack (frontend + backend + simulator)..." -ForegroundColor Green
        Sync-FrontendLockfileIfNeeded
        docker-compose down
        docker-compose build
        docker-compose up
    }
    "dev" {
        Write-Host " Starting development services (frontend + backend only)..." -ForegroundColor Green
        docker-compose -f docker-compose.dev.yaml up
    }
    "dev-rebuild" {
        Write-Host " Rebuilding and starting development services (frontend + backend only)..." -ForegroundColor Green
        Sync-FrontendLockfileIfNeeded
        docker-compose -f docker-compose.dev.yaml down
        docker-compose -f docker-compose.dev.yaml build frontend backend
        docker-compose -f docker-compose.dev.yaml up --renew-anon-volumes
    }
    "dev-rebuild-frontend" {
        Write-Host " Rebuilding frontend image and starting frontend in development compose..." -ForegroundColor Green
        Sync-FrontendLockfileIfNeeded
        docker-compose -f docker-compose.dev.yaml build frontend
        docker-compose -f docker-compose.dev.yaml up --force-recreate --renew-anon-volumes frontend
    }
    "dev-rebuild-backend" {
        Write-Host " Rebuilding backend image and starting backend in development compose..." -ForegroundColor Green
        docker-compose -f docker-compose.dev.yaml build backend
        docker-compose -f docker-compose.dev.yaml up backend
    }
    "frontend" {
        Write-Host "  Starting frontend only..." -ForegroundColor Green
        docker-compose up frontend
    }
    "backend" {
        Write-Host " Starting backend only..." -ForegroundColor Green
        docker-compose up backend
    }
    "simulator" {
        if (-not (Test-Token)) {
            Write-Host ""
            $response = Read-Host "Continue without token? The simulator will fail to build. (y/N)"
            if ($response -notmatch "^[Yy]$") {
                exit 1
            }
        }
        Write-Host " Starting simulator only..." -ForegroundColor Green
        docker-compose up drv-unreal
    }
    "logs" {
        Write-Host " Following development service logs..." -ForegroundColor Green
        docker-compose -f docker-compose.dev.yaml logs -f frontend backend
    }
    "logs-all" {
        Write-Host " Following all service logs..." -ForegroundColor Green
        docker-compose logs -f
    }
    "stop" {
        Write-Host " Stopping all services..." -ForegroundColor Yellow
        docker-compose down
    }
    "stop-dev" {
        Write-Host " Stopping development services..." -ForegroundColor Yellow
        docker-compose -f docker-compose.dev.yaml down
    }
    "clean" {
        Write-Host " Cleaning up all containers and volumes..." -ForegroundColor Yellow
        docker-compose down -v
        docker-compose -f docker-compose.dev.yaml down -v
        Write-Host " Cleanup complete" -ForegroundColor Green
    }
    { $_ -eq "help" -or $_ -eq "" -or $null -eq $_ } {
        Show-Usage
    }
    default {
        Write-Host " Unknown command: $Command" -ForegroundColor Red
        Show-Usage
        exit 1
    }
}