package utils

import (
	"fmt"
	"gc-infra/config"
	"net"

	"github.com/pulumi/pulumi-hcloud/sdk/go/hcloud"
	"github.com/pulumi/pulumi-tls/sdk/v5/go/tls"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func CreateSshKey(ctx *pulumi.Context) (*tls.PrivateKey, error) {
	return tls.NewPrivateKey(ctx, "sshKey", &tls.PrivateKeyArgs{
		Algorithm: pulumi.String("ED25519"),
	}, pulumi.AdditionalSecretOutputs([]string{"privKey"}))
}

func CreatePlacementGroup(ctx *pulumi.Context, name string) (*hcloud.PlacementGroup, error) {
	pg, err := hcloud.NewPlacementGroup(ctx, name, &hcloud.PlacementGroupArgs{
		Name: pulumi.String(name),
		Type: pulumi.String("spread"),
	})
	return pg, err
}

func CreateClusterNet(ctx *pulumi.Context, cfg config.InfraConfig) (*pulumi.IDOutput, error) {
	var id pulumi.IDOutput
	network, err := hcloud.NewNetwork(ctx, cfg.SwarmNetworkName, &hcloud.NetworkArgs{
		Name:    pulumi.String(cfg.SwarmNetworkName),
		IpRange: pulumi.String(cfg.SwarmIpRange),
	})
	if err != nil {
		return nil, err
	}
	id = network.ID()
	_, err = hcloud.NewNetworkSubnet(ctx, "network-subnet", &hcloud.NetworkSubnetArgs{
		Type:        pulumi.String("cloud"),
		NetworkId:   IDtoIntOutput(id),
		NetworkZone: pulumi.String("eu-central"),
		IpRange:     pulumi.String(cfg.SwarmSubnetIpRange),
	})
	if err != nil {
		return nil, err
	}
	return &id, nil
}

type CreateServerArgs struct {
	NetworkId        pulumi.IDInput
	PlacementGroupId pulumi.IDInput
	// The first assignable IP of the network
	NetworkFirstIP string
	Basename       string
	Count          int
	SshKey         *hcloud.SshKey
	ServerType     string
}

func CreateServer(ctx *pulumi.Context, cfg CreateServerArgs) ([]*hcloud.Server, error) {
	var nodes []*hcloud.Server
	nextIp := cfg.NetworkFirstIP
	for i := range cfg.Count {
		sn := fmt.Sprintf("%s-%d", cfg.Basename, i+1)
		s, err := hcloud.NewServer(ctx, sn, &hcloud.ServerArgs{
			Name:       pulumi.String(sn),
			Image:      pulumi.String("docker-ce"),
			ServerType: pulumi.String(cfg.ServerType),
			Location:   pulumi.StringPtr("hel1"),
			Networks: hcloud.ServerNetworkTypeArray{
				&hcloud.ServerNetworkTypeArgs{
					NetworkId: IDtoIntOutput(cfg.NetworkId),
					Ip:        pulumi.String(nextIp),
				},
			},
			PlacementGroupId: IDtoIntPtrOutput(cfg.PlacementGroupId),
			PublicNets: hcloud.ServerPublicNetArray{
				&hcloud.ServerPublicNetArgs{
					// Ipv4Enabled: pulumi.Bool(true),
					Ipv6Enabled: pulumi.Bool(true),
				},
			},
			SshKeys: pulumi.StringArray{cfg.SshKey.ID()},
		})
		if err != nil {
			return nodes, err
		}

		cephVolume, err := hcloud.NewVolume(ctx, fmt.Sprintf("ceph-%s", sn), &hcloud.VolumeArgs{
			Name:     pulumi.Sprintf("%s-ceph-vol-0%d", s.Name, i+1),
			Size:     pulumi.Int(100),
			Location: s.Location,
		})
		if err != nil {
			return nodes, fmt.Errorf("couldn't create volume: %w", err)
		}

		_, err = hcloud.NewVolumeAttachment(ctx, fmt.Sprintf("ceph-vol-attach-%s", sn), &hcloud.VolumeAttachmentArgs{
			VolumeId: IDtoIntOutput(cephVolume.ID()),
			ServerId: IDtoIntOutput(s.ID()),
		})
		if err != nil {
			return nodes, fmt.Errorf("couldn't attach volume to node %d", i)
		}

		nodes = append(nodes, s)
		nextIp = IncrementIP(net.ParseIP(nextIp)).String()
	}
	return nodes, nil
}