bootstrap-github.ps1

$ErrorActionPreference = "Stop"

function Write-Info($msg)  { Write-Host "[INFO]  $msg" -ForegroundColor Cyan }
function Write-Ok($msg)    { Write-Host "[OK]    $msg" -ForegroundColor Green }
function Write-Warn($msg)  { Write-Host "[WARN]  $msg" -ForegroundColor Yellow }
function Write-Fail($msg)  { Write-Host "[ERROR] $msg" -ForegroundColor Red }
function Write-Step($msg)  { Write-Host "[STEP]  $msg" -ForegroundColor Magenta }

function Test-CommandExists {
    param([string]$CommandName)
    return $null -ne (Get-Command $CommandName -ErrorAction SilentlyContinue)
}

function Invoke-Git {
    param(
        [Parameter(Mandatory = $true)]
        [string[]]$Args
    )

    $cmdText = "git " + ($Args -join " ")
    Write-Info $cmdText

    $output = & git @Args 2>&1
    $exit = $LASTEXITCODE

    if ($output) {
        ($output | Out-String).TrimEnd() | ForEach-Object {
            if ($_ -ne "") {
                Write-Host "        $_" -ForegroundColor DarkGray
            }
        }
    }

    if ($exit -ne 0) {
        $text = ($output | Out-String).Trim()
        if ([string]::IsNullOrWhiteSpace($text)) {
            $text = "Git command failed: $cmdText"
        }
        throw $text
    }

    return $output
}

function Get-GitOutputSafe {
    param(
        [Parameter(Mandatory = $true)]
        [string[]]$Args
    )

    $output = & git @Args 2>$null
    if ($LASTEXITCODE -ne 0) {
        return $null
    }
    return ($output | Out-String).Trim()
}

function Resolve-ProjectPath {
    $currentPath = (Get-Location).Path
    $scriptPath  = Split-Path -Parent $PSCommandPath

    Write-Host ""
    Write-Host "Detected current folder : $currentPath" -ForegroundColor Gray
    Write-Host "Bootstrap script folder : $scriptPath" -ForegroundColor Gray
    Write-Host ""

    $answer = Read-Host "Use current folder as project folder? (Y/n)"
    if ([string]::IsNullOrWhiteSpace($answer) -or $answer -match "^(y|yes)$") {
        return $currentPath
    }

    $enteredPath = Read-Host "Enter project folder path"
    if ([string]::IsNullOrWhiteSpace($enteredPath)) {
        throw "Project folder path must not be empty."
    }
    if (-not (Test-Path -LiteralPath $enteredPath)) {
        throw "Project folder does not exist: $enteredPath"
    }

    return (Resolve-Path -LiteralPath $enteredPath).Path
}

function Test-IsGitRepo {
    param(
        [Parameter(Mandatory = $true)]
        [string]$ProjectPath
    )

    $gitFolder = Join-Path $ProjectPath ".git"
    return (Test-Path -LiteralPath $gitFolder)
}

function Test-HasCommit {
    $null = & git rev-parse --verify HEAD 2>$null
    return ($LASTEXITCODE -eq 0)
}

function Get-CurrentBranchSafe {
    return (Get-GitOutputSafe -Args @("branch", "--show-current"))
}

function Ensure-RepoInitialized {
    param(
        [Parameter(Mandatory = $true)]
        [string]$ProjectPath
    )

    Write-Step "Checking whether .git exists"
    $gitFolder = Join-Path $ProjectPath ".git"
    Write-Info "Expected .git path: $gitFolder"

    if (Test-IsGitRepo -ProjectPath $ProjectPath) {
        Write-Warn "Git repository already exists in this folder."
        return
    }

    Write-Step "Initializing repository"
    Invoke-Git -Args @("init", "-b", "main") | Out-Null

    if (-not (Test-IsGitRepo -ProjectPath $ProjectPath)) {
        throw "git init reported success, but .git folder was not created."
    }

    Write-Ok "Initialized new git repository with branch main"
}

function Ensure-MainBranch {
    Write-Step "Checking current branch"

    $branch = Get-CurrentBranchSafe

    if ([string]::IsNullOrWhiteSpace($branch)) {
        if (Test-HasCommit) {
            Write-Warn "Could not detect current branch cleanly, but repository already has commits."
        }
        else {
            Write-Warn "Repository has no first commit yet. main will become active after the first commit."
        }
        return
    }

    if ($branch -ne "main") {
        Write-Step "Renaming branch to main"
        Invoke-Git -Args @("branch", "-M", "main") | Out-Null
        Write-Ok "Renamed branch to main"
    }
    else {
        Write-Ok "Branch is already main"
    }
}

function Ensure-Origin {
    param(
        [Parameter(Mandatory = $true)]
        [string]$RepoUrl
    )

    Write-Step "Checking remote origin"

    $remotes = Get-GitOutputSafe -Args @("remote")
    $remoteList = @()

    if (-not [string]::IsNullOrWhiteSpace($remotes)) {
        $remoteList = $remotes -split "`r?`n" | ForEach-Object { $_.Trim() } | Where-Object { $_ }
    }

    if ($remoteList -contains "origin") {
        $existingOrigin = Get-GitOutputSafe -Args @("remote", "get-url", "origin")
        if ([string]::IsNullOrWhiteSpace($existingOrigin)) {
            throw "Remote 'origin' exists but its URL could not be read."
        }

        if ($existingOrigin -eq $RepoUrl) {
            Write-Ok "Remote origin already correct"
            return
        }

        Write-Warn "Remote origin already exists: $existingOrigin"
        $overwrite = Read-Host "Overwrite origin with new URL? (y/n)"
        if ($overwrite -match "^(y|yes)$") {
            Invoke-Git -Args @("remote", "set-url", "origin", $RepoUrl) | Out-Null
            Write-Ok "Updated remote origin to: $RepoUrl"
            return
        }

        throw "Aborted because remote origin points to a different repository."
    }

    Write-Step "Adding remote origin"
    Invoke-Git -Args @("remote", "add", "origin", $RepoUrl) | Out-Null
    Write-Ok "Added remote origin: $RepoUrl"
}

function Ensure-Commit {
    param(
        [Parameter(Mandatory = $true)]
        [string]$CommitMessage
    )

    Write-Step "Staging files"
    Invoke-Git -Args @("add", ".") | Out-Null

    $status = Get-GitOutputSafe -Args @("status", "--porcelain")
    $hasCommit = Test-HasCommit

    if ([string]::IsNullOrWhiteSpace($status)) {
        if ($hasCommit) {
            Write-Warn "Nothing to commit. Repository already has at least one commit."
            return
        }

        throw "Repository has no commit yet and there are no files available for an initial commit."
    }

    if (-not $hasCommit) {
        Write-Warn "No commit exists yet. Creating initial commit now."
    }

    Write-Step "Creating commit"
    Invoke-Git -Args @("commit", "-m", $CommitMessage) | Out-Null

    if (-not $hasCommit) {
        Write-Ok "Initial commit created: $CommitMessage"
    }
    else {
        Write-Ok "Commit created: $CommitMessage"
    }
}

function Ensure-UpstreamPush {
    Write-Step "Pushing branch to GitHub"

    if (-not (Test-HasCommit)) {
        throw "Cannot push because the repository still has no commit."
    }

    $branch = Get-CurrentBranchSafe
    if ([string]::IsNullOrWhiteSpace($branch)) {
        $branch = "main"
        Write-Warn "Current branch could not be detected cleanly. Assuming main for push."
    }

    Invoke-Git -Args @("push", "-u", "origin", $branch) | Out-Null
    Write-Ok "Pushed $branch to origin"
}

try {
    if (-not (Test-CommandExists "git")) {
        throw "Git was not found in PATH."
    }

    $projectPath = Resolve-ProjectPath
    Set-Location -LiteralPath $projectPath

    Write-Host ""
    Write-Host "=== GitHub Bootstrap for Current Project ===" -ForegroundColor White
    Write-Host "Project folder: $projectPath" -ForegroundColor Gray
    Write-Host ""

    Write-Step "Verifying working folder"
    Write-Info "Current location after Set-Location: $((Get-Location).Path)"

    $repoName = Read-Host "GitHub repository name"
    if ([string]::IsNullOrWhiteSpace($repoName)) {
        throw "Repository name must not be empty."
    }

    $commitMessage = Read-Host "Commit message"
    if ([string]::IsNullOrWhiteSpace($commitMessage)) {
        $commitMessage = "Initial commit"
        Write-Warn "Empty commit message entered. Using: Initial commit"
    }

    $repoUrl = "https://github.com/olaf-h/$repoName.git"

    Write-Host ""
    Write-Info "Repository URL will be: $repoUrl"
    Write-Host ""

    Ensure-RepoInitialized -ProjectPath $projectPath
    Ensure-MainBranch
    Ensure-Origin -RepoUrl $repoUrl
    Ensure-Commit -CommitMessage $commitMessage
    Ensure-UpstreamPush

    Write-Host ""
    Write-Ok "Done. Your project is now connected to GitHub."
}
catch {
    Write-Host ""
    Write-Fail $_.Exception.Message
    exit 1
}