package httpd

import (
	"net/http"
	"os"
	"path/filepath"
	"runtime"
	"strings"
)

// runnerBinary is github.com/barerepo/runner, which ships beside the server and is handed out by it.
const runnerBinary = "barerepo-runner"

// platform is what this binary was built for, which is the only one the server can hand out.
func platform() string { return runtime.GOOS + "/" + runtime.GOARCH }

// serveRunnerScript is the other half of the line on the setup page, which 404'd until now.
func (s *Server) serveRunnerScript(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/x-shellscript; charset=utf-8")
	// A script is not a page, and a stale copy of an install script is a support ticket.
	w.Header().Set("Cache-Control", "no-store")
	w.Write([]byte(runnerScript(s.Cfg.Server.ExternalURL)))
}

// serveRunnerPS1 is the same script for the platform that has no sh. Chapter 15 shows all three.
func (s *Server) serveRunnerPS1(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
	w.Header().Set("Cache-Control", "no-store")
	w.Write([]byte(runnerPS1(s.Cfg.Server.ExternalURL)))
}

// serveRunnerBinary hands out the runner installed beside this server, so the pair cannot skew.
func (s *Server) serveRunnerBinary(w http.ResponseWriter, r *http.Request) {
	// The token is the whole authorisation, because the script has one and a stranger does not.
	if _, err := s.runnerAuth(r, r.URL.Query().Get("token")); err != nil {
		http.Error(w, "that token is not valid", http.StatusUnauthorized)
		return
	}
	self, err := os.Executable()
	if err != nil {
		http.Error(w, "this server cannot find its own binary", http.StatusInternalServerError)
		return
	}
	// The runner is its own program now, installed beside this one, so no path has to be configured.
	f, err := os.Open(filepath.Join(filepath.Dir(self), runnerBinary))
	if err != nil {
		http.Error(w, "no "+runnerBinary+" is installed beside this server", http.StatusNotFound)
		return
	}
	defer f.Close()
	info, err := f.Stat()
	if err != nil {
		http.Error(w, "this server cannot stat its own binary", http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", "application/octet-stream")
	w.Header().Set("Barerepo-Platform", platform())
	http.ServeContent(w, r, runnerBinary, info.ModTime(), f)
}

// runnerScript builds the posix half. The token arrives as $1, from sh -s <token>.
func runnerScript(external string) string {
	base := strings.TrimRight(external, "/")
	return `#!/bin/sh
# barerepo runner install. one paste, one machine attached. chapter 15.
set -eu

TOKEN="${1:-}"
if [ -z "$TOKEN" ]; then
  echo "usage: curl -sL ` + base + `/runner.sh | sh -s <token>" >&2
  exit 1
fi

SERVER="` + base + `"
HAVE="` + platform() + `"

OS=$(uname -s | tr '[:upper:]' '[:lower:]')
ARCH=$(uname -m)
case "$ARCH" in
  x86_64 | amd64) ARCH=amd64 ;;
  aarch64 | arm64) ARCH=arm64 ;;
esac
WANT="$OS/$ARCH"

# The server can only hand out the binary it is running, so say so rather than install the wrong one.
if [ "$WANT" != "$HAVE" ]; then
  echo "this barerepo runs $HAVE and cannot hand you a $WANT binary." >&2
  echo "build one and run it yourself:" >&2
  echo "  GOOS=$OS GOARCH=$ARCH go build -o barerepo-runner ./cmd/barerepo-runner" >&2
  echo "  ./barerepo-runner $TOKEN --server $SERVER" >&2
  exit 1
fi

DIR="${BAREREPO_BIN_DIR:-$HOME/.local/bin}"
mkdir -p "$DIR"

# Downloaded beside the target and moved, so an interrupted install leaves no half a binary.
TMP="$DIR/.barerepo-runner.$$"
trap 'rm -f "$TMP"' EXIT INT TERM
if command -v curl >/dev/null 2>&1; then
  curl -fsSL "$SERVER/runner/binary?token=$TOKEN" -o "$TMP"
elif command -v wget >/dev/null 2>&1; then
  wget -qO "$TMP" "$SERVER/runner/binary?token=$TOKEN"
else
  echo "neither curl nor wget is installed." >&2
  exit 1
fi
chmod +x "$TMP"
mv -f "$TMP" "$DIR/barerepo-runner"
trap - EXIT INT TERM

echo "the runner is at $DIR/barerepo-runner. attaching."
exec "$DIR/barerepo-runner" "$TOKEN" --server "$SERVER"
`
}

// runnerPS1 is the windows half, which the mockup shows beside the others rather than behind a tab.
func runnerPS1(external string) string {
	base := strings.TrimRight(external, "/")
	return `# barerepo runner install. one paste, one machine attached. chapter 15.
$ErrorActionPreference = "Stop"

function barerepo-runner {
  param([Parameter(Mandatory=$true)][string]$Token)

  $server = "` + base + `"
  $have = "` + platform() + `"

  $arch = if ([Environment]::Is64BitOperatingSystem) { "amd64" } else { "386" }
  $want = "windows/$arch"
  if ($want -ne $have) {
    Write-Error "this barerepo runs $have and cannot hand you a $want binary. build one: GOOS=windows GOARCH=$arch go build -o barerepo-runner.exe ./cmd/barerepo-runner"
    return
  }

  $dir = Join-Path $env:LOCALAPPDATA "barerepo"
  New-Item -ItemType Directory -Force -Path $dir | Out-Null
  $exe = Join-Path $dir "barerepo-runner.exe"
  Invoke-WebRequest -Uri "$server/runner/binary?token=$Token" -OutFile $exe

  Write-Host "the runner is at $exe. attaching."
  & $exe $Token --server $server
}
`
}