package templates

import (
	"bytes"
	"text/template"
)

var serviceTemplate = `[Unit]
Description={{.Name}}
After=network.target

[Service]
Type=simple
User={{.User}}
WorkingDirectory={{.WorkDir}}
EnvironmentFile={{.EnvFile}}
ExecStart={{.BinaryPath}} {{.Args}}
Restart=always
RestartSec=5s
NoNewPrivileges=true
PrivateTmp=true
{{- if .Memory}}
MemoryMax={{.Memory}}
{{- end}}
{{- if .CPU}}
CPUQuota={{.CPU}}
{{- end}}

[Install]
WantedBy=multi-user.target
`

var appCaddyTemplate = `{{.Domain}} {
    reverse_proxy 127.0.0.1:{{.Port}}
}
`

var staticCaddyTemplate = `{{.Domain}} {
    root * {{.RootDir}}
    file_server
    encode gzip
}
`

// SystemdService generates a systemd service unit file
func SystemdService(data map[string]string) (string, error) {
	tmpl, err := template.New("service").Parse(serviceTemplate)
	if err != nil {
		return "", err
	}

	var buf bytes.Buffer
	if err := tmpl.Execute(&buf, data); err != nil {
		return "", err
	}

	return buf.String(), nil
}

// AppCaddy generates a Caddy config for a Go app
func AppCaddy(data map[string]string) (string, error) {
	tmpl, err := template.New("caddy").Parse(appCaddyTemplate)
	if err != nil {
		return "", err
	}

	var buf bytes.Buffer
	if err := tmpl.Execute(&buf, data); err != nil {
		return "", err
	}

	return buf.String(), nil
}

// StaticCaddy generates a Caddy config for a static site
func StaticCaddy(data map[string]string) (string, error) {
	tmpl, err := template.New("caddy").Parse(staticCaddyTemplate)
	if err != nil {
		return "", err
	}

	var buf bytes.Buffer
	if err := tmpl.Execute(&buf, data); err != nil {
		return "", err
	}

	return buf.String(), nil
}

var postReceiveHookTemplate = `#!/bin/bash
set -euo pipefail

REPO=/srv/git/{{.Name}}.git
SRC=/var/lib/{{.Name}}/src
NAME={{.Name}}

while read oldrev newrev refname; do
    branch=$(git rev-parse --symbolic --abbrev-ref "$refname")
    [ "$branch" = "main" ] || { echo "Pushed to $branch, skipping deploy."; exit 0; }
done

# Ensure checkout directory exists
sudo /bin/mkdir -p "$SRC"
sudo /bin/chown -R git:git "/var/lib/${NAME}"

echo "==> Checking out code..."
git --work-tree="$SRC" --git-dir="$REPO" checkout -f main

cd "$SRC"

# If no Dockerfile, nothing to deploy
if [ ! -f Dockerfile ]; then
    echo "No Dockerfile found, skipping deploy."
    exit 0
fi

# Install deployment config from repo (using full paths for sudoers)
if [ -f "$SRC/.ship/service" ]; then
    echo "==> Installing systemd unit..."
    sudo /bin/cp "$SRC/.ship/service" "/etc/systemd/system/${NAME}.service"
    sudo systemctl daemon-reload
fi
if [ -f "$SRC/.ship/Caddyfile" ]; then
    echo "==> Installing Caddy config..."
    sudo /bin/cp "$SRC/.ship/Caddyfile" "/etc/caddy/sites-enabled/${NAME}.caddy"
    sudo systemctl reload caddy
fi

# Ensure data directory exists
sudo /bin/mkdir -p "/var/lib/${NAME}/data"
sudo /bin/chown -R git:git "/var/lib/${NAME}/data"

echo "==> Building Docker image..."
docker build -t ${NAME}:latest .

echo "==> Restarting service..."
sudo systemctl restart ${NAME}

echo "==> Deploy complete!"
`

var postReceiveHookStaticTemplate = `#!/bin/bash
set -euo pipefail

REPO=/srv/git/{{.Name}}.git
WEBROOT=/var/www/{{.Name}}
NAME={{.Name}}

while read oldrev newrev refname; do
    branch=$(git rev-parse --symbolic --abbrev-ref "$refname")
    [ "$branch" = "main" ] || { echo "Pushed to $branch, skipping deploy."; exit 0; }
done

echo "==> Deploying static site..."
git --work-tree="$WEBROOT" --git-dir="$REPO" checkout -f main

if [ -f "$WEBROOT/.ship/Caddyfile" ]; then
    echo "==> Installing Caddy config..."
    sudo /bin/cp "$WEBROOT/.ship/Caddyfile" "/etc/caddy/sites-enabled/${NAME}.caddy"
    sudo systemctl reload caddy
fi

echo "==> Deploy complete!"
`

var codeCaddyTemplate = `{{.BaseDomain}} {
    @goget query go-get=1
    handle @goget {
        root * /opt/ship/vanity
        templates
        rewrite * /index.html
        file_server
    }

    @git path_regexp "^.*/(HEAD|info/refs|objects/info/[^/]+|git-upload-pack|git-receive-pack)$"
    handle @git {
        reverse_proxy unix//run/fcgiwrap.socket {
            transport fastcgi {
                env SCRIPT_FILENAME /usr/lib/git-core/git-http-backend
                env GIT_PROJECT_ROOT /srv/git
                env REQUEST_METHOD {method}
                env QUERY_STRING {query}
                env PATH_INFO {path}
            }
        }
    }

    @cgitassets path /cgit/*
    handle @cgitassets {
        root * /usr/share/cgit
        uri strip_prefix /cgit
        file_server
    }

    handle {
        reverse_proxy unix//run/fcgiwrap.socket {
            transport fastcgi {
                env SCRIPT_FILENAME /usr/lib/cgit/cgit.cgi
                env QUERY_STRING {query}
                env REQUEST_METHOD {method}
                env PATH_INFO {path}
                env HTTP_HOST {host}
                env SERVER_NAME {host}
            }
        }
    }
}
`

var dockerServiceTemplate = `[Unit]
Description={{.Name}}
After=network.target docker.service
Requires=docker.service

[Service]
Type=simple
ExecStartPre=-/usr/bin/docker rm -f {{.Name}}
ExecStart=/usr/bin/docker run --rm --name {{.Name}} \
  -p 127.0.0.1:{{.Port}}:{{.ContainerPort}} \
  --env-file /etc/ship/env/{{.Name}}.env \
  -v /var/lib/{{.Name}}/data:/data \
  {{.Name}}:latest
ExecStop=/usr/bin/docker stop -t 10 {{.Name}}
Restart=always
RestartSec=5s

[Install]
WantedBy=multi-user.target
`

var defaultAppCaddyTemplate = `{{.Domain}} {
    reverse_proxy 127.0.0.1:{{.Port}}
}
`

var defaultStaticCaddyTemplate = `{{.Domain}} {
    root * /var/www/{{.Name}}
    file_server
    encode gzip
}
`

// PostReceiveHook generates a post-receive hook for git-app repos
func PostReceiveHook(data map[string]string) (string, error) {
	return renderTemplate("post-receive", postReceiveHookTemplate, data)
}

// PostReceiveHookStatic generates a post-receive hook for git-static repos
func PostReceiveHookStatic(data map[string]string) (string, error) {
	return renderTemplate("post-receive-static", postReceiveHookStaticTemplate, data)
}

// CodeCaddy generates the base domain Caddy config for vanity imports + git HTTP
func CodeCaddy(data map[string]string) (string, error) {
	return renderTemplate("code-caddy", codeCaddyTemplate, data)
}

var cgitrcTemplate = `virtual-root=/
css=/cgit/cgit.css
logo=/cgit/cgit.png
header=/opt/ship/cgit-header.html
scan-path=/srv/git/
export-ok=git-daemon-export-ok
enable-http-clone=0
clone-url=https://{{.BaseDomain}}/$CGIT_REPO_URL
root-title={{.BaseDomain}}
root-desc=
remove-suffix=.git
`

var cgitHeaderTemplate = `<style>
body, table, td, th, div#cgit { background: #1a1a2e; color: #ccc; }
a { color: #7aa2f7; }
a:hover { color: #9ecbff; }
table.list tr:hover td { background: #222244; }
table.list td, table.list th { border-bottom: 1px solid #333; }
th { background: #16213e; }
td.commitgraph .column1 { color: #7aa2f7; }
td.commitgraph .column2 { color: #9ece6a; }
td.logheader { background: #16213e; }
div#header { background: #16213e; border-bottom: 1px solid #333; }
div#header .sub { color: #888; }
table.tabs { border-bottom: 1px solid #333; }
table.tabs td a { color: #ccc; }
table.tabs td a.active { color: #fff; background: #1a1a2e; border: 1px solid #333; border-bottom: 1px solid #1a1a2e; }
div.footer { color: #555; }
div.footer a { color: #555; }
div.diffstat-header { background: #16213e; }
table.diffstat { border-bottom: 1px solid #333; }
table.diffstat td.graph span.graph-moreremoved { background: #f7768e; }
table.diffstat td.graph span.graph-moreadded { background: #9ece6a; }
table.diffstat td.graph span.graph-removed { background: #f7768e; }
table.diffstat td.graph span.graph-added { background: #9ece6a; }
table.diff { background: #131320; border: 1px solid #333; }
div.diff td { font-family: monospace; }
div.head { color: #ccc; background: #16213e; padding: 2px 4px; }
div.hunk { color: #7aa2f7; background: #1a1a3e; padding: 2px 4px; }
div.add { color: #9ece6a; background: #1a2e1a; padding: 2px 4px; }
div.del { color: #f7768e; background: #2e1a1a; padding: 2px 4px; }
table.diff td.add { color: #9ece6a; background: #1a2e1a; }
table.diff td.del { color: #f7768e; background: #2e1a1a; }
table.diff td.hunk { color: #7aa2f7; background: #1a1a3e; }
table.diff td { border: none; background: #1a1a2e; }
table.blob td.lines { color: #ccc; }
table.blob td.linenumbers { background: #16213e; }
table.blob td.linenumbers a { color: #555; }
table.blob td.linenumbers a:hover { color: #7aa2f7; }
table.ssdiff td.add { color: #9ece6a; background: #1a2e1a; }
table.ssdiff td.del { color: #f7768e; background: #2e1a1a; }
table.ssdiff td { border-right: 1px solid #333; }
table.ssdiff td.hunk { color: #7aa2f7; background: #1a1a3e; }
table.ssdiff td.head { background: #16213e; border-bottom: 1px solid #333; }
table.ssdiff td.foot { background: #16213e; border-top: 1px solid #333; }
table.ssdiff td.lineno { background: #16213e; color: #555; }
pre { color: #ccc; }
input, textarea, select { background: #222; color: #ccc; border: 1px solid #444; }
img#logo { display: none; }
</style>
`

// CgitRC generates the /etc/cgitrc config file
func CgitRC(data map[string]string) (string, error) {
	return renderTemplate("cgitrc", cgitrcTemplate, data)
}

// CgitHeader generates the cgit header HTML file (dark theme)
func CgitHeader() string {
	return cgitHeaderTemplate
}

// DockerService generates a systemd unit for a Docker-based app
func DockerService(data map[string]string) (string, error) {
	return renderTemplate("docker-service", dockerServiceTemplate, data)
}

// DefaultAppCaddy generates a default Caddyfile for a git-app
func DefaultAppCaddy(data map[string]string) (string, error) {
	return renderTemplate("default-app-caddy", defaultAppCaddyTemplate, data)
}

// DefaultStaticCaddy generates a default Caddyfile for a git-static site
func DefaultStaticCaddy(data map[string]string) (string, error) {
	return renderTemplate("default-static-caddy", defaultStaticCaddyTemplate, data)
}

func renderTemplate(name, tmplStr string, data map[string]string) (string, error) {
	tmpl, err := template.New(name).Parse(tmplStr)
	if err != nil {
		return "", err
	}

	var buf bytes.Buffer
	if err := tmpl.Execute(&buf, data); err != nil {
		return "", err
	}

	return buf.String(), nil
}