package main

import (
	"fmt"

	"github.com/ctfer-io/chall-manager/sdk"

	appsv1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/apps/v1"
	corev1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/core/v1"
	metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1"
	networkingv1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/networking/v1"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

const hostnameBase = "X.X.X"
const flagFormat = "test{%s}"
const flag = "very-important-test-challenge"
const port = 80

func main() {
	sdk.Run(func(req *sdk.Request, resp *sdk.Response, opts ...pulumi.ResourceOption) error {
		// Dynamic hostname based on identity
		hostname := fmt.Sprintf("%s.%s", req.Config.Identity, hostnameBase)

		// Use chall-manager SDK for flag variation
		flagVariantStringBase := sdk.Variate(req.Config.Identity, flag)
		flagVariantString := fmt.Sprintf(flagFormat, flagVariantStringBase)
		flagVariant := pulumi.Sprintf(flagFormat, flagVariantStringBase)

		// Resource name prefix with identity to ensure uniqueness across deployments
		resourceName := fmt.Sprintf("echo-test-%s", req.Config.Identity)

		labels := pulumi.ToStringMap(map[string]string{
			"chall-manager.ctfer.io/identity": req.Config.Identity,
			"app":                             "echo-test",
		})

		// Create Deployment
		_, err := appsv1.NewDeployment(req.Ctx, resourceName, &appsv1.DeploymentArgs{
			Metadata: metav1.ObjectMetaArgs{
				Labels: labels,
			},
			Spec: appsv1.DeploymentSpecArgs{
				Selector: metav1.LabelSelectorArgs{
					MatchLabels: labels,
				},
				Replicas: pulumi.Int(1),
				Template: corev1.PodTemplateSpecArgs{
					Metadata: metav1.ObjectMetaArgs{
						Labels: labels,
					},
					Spec: corev1.PodSpecArgs{
						Containers: corev1.ContainerArray{
							corev1.ContainerArgs{
								Name:  pulumi.String("echo"),
								Image: pulumi.String("traefik/whoami:latest"),
								Ports: corev1.ContainerPortArray{
									corev1.ContainerPortArgs{
										ContainerPort: pulumi.Int(port),
									},
								},
								Env: corev1.EnvVarArray{
									corev1.EnvVarArgs{
										Name:  pulumi.String("WHOAMI_PORT_NUMBER"),
										Value: pulumi.Sprintf("%d", port),
									},
									corev1.EnvVarArgs{
										Name:  pulumi.String("WHOAMI_NAME"),
										Value: pulumi.String("FLAG=" + flagVariantString),
									},
								},
							},
						},
					},
				},
			},
		}, opts...)
		if err != nil {
			return err
		}

		// Create Service
		svc, err := corev1.NewService(req.Ctx, resourceName, &corev1.ServiceArgs{
			Metadata: metav1.ObjectMetaArgs{
				Labels: labels,
			},
			Spec: corev1.ServiceSpecArgs{
				Selector: labels,
				Ports: corev1.ServicePortArray{
					corev1.ServicePortArgs{
						Port:       pulumi.Int(port),
						TargetPort: pulumi.Int(port),
						Protocol:   pulumi.String("TCP"),
					},
				},
			},
		}, opts...)
		if err != nil {
			return err
		}

		// Create Ingress with TLS
		pathTypePrefix := "Prefix"
		tlsSecretName := fmt.Sprintf("%s-tls", resourceName)
		_, err = networkingv1.NewIngress(req.Ctx, resourceName, &networkingv1.IngressArgs{
			Metadata: metav1.ObjectMetaArgs{
				Labels: labels,
				Annotations: pulumi.ToStringMap(map[string]string{
					"kubernetes.io/ingress.class":    "nginx",
					"cert-manager.io/cluster-issuer": "letsencrypt-production",
				}),
			},
			Spec: networkingv1.IngressSpecArgs{
				Tls: networkingv1.IngressTLSArray{
					networkingv1.IngressTLSArgs{
						Hosts: pulumi.ToStringArray([]string{
							hostname,
						}),
						SecretName: pulumi.String(tlsSecretName),
					},
				},
				Rules: networkingv1.IngressRuleArray{
					networkingv1.IngressRuleArgs{
						Host: pulumi.String(hostname),
						Http: networkingv1.HTTPIngressRuleValueArgs{
							Paths: networkingv1.HTTPIngressPathArray{
								networkingv1.HTTPIngressPathArgs{
									Path:     pulumi.String("/"),
									PathType: pulumi.String(pathTypePrefix),
									Backend: networkingv1.IngressBackendArgs{
										Service: networkingv1.IngressServiceBackendArgs{
											Name: svc.Metadata.Name().Elem(),
											Port: networkingv1.ServiceBackendPortArgs{
												Number: pulumi.Int(port),
											},
										},
									},
								},
							},
						},
					},
				},
			},
		}, opts...)
		if err != nil {
			return err
		}

		// Export outputs matching original format
		resp.ConnectionInfo = pulumi.Sprintf("https://%s", hostname)
		resp.Flag = flagVariant

		return nil
	})
}