package integrationv2

import (
	"bytes"
	"fmt"
	"io"
	"io/fs"
	"strings"

	"edge-infra.dev/pkg/k8s/decoder"
	"edge-infra.dev/pkg/k8s/unstructured"

	"github.com/google/uuid"
	"sigs.k8s.io/kustomize/api/filters/namespace"
	"sigs.k8s.io/kustomize/api/types"
	"sigs.k8s.io/kustomize/kyaml/kio"
	"sigs.k8s.io/kustomize/kyaml/yaml"
)

const (
	configMapKind string = "ConfigMap"
	secretKind    string = "Secret"
)

const (
	jwtTokenSecret string = "abcd"
)

func getManifests(fs fs.FS, path string) (string, error) {
	file, err := fs.Open(path)
	if err != nil {
		return "", fmt.Errorf("error when opening file: %w", err)
	}
	manifestBytes, err := io.ReadAll(file)
	if err != nil {
		return "", fmt.Errorf("failed to read file: %w", err)
	}

	return string(manifestBytes), nil
}

func processManifests(manifests string, namespace string, filters ...kio.Filter) ([]*unstructured.Unstructured, error) {
	reader := kio.ByteReader{
		Reader: strings.NewReader(manifests),
	}

	out, err := reader.Read()
	if err != nil {
		return nil, err
	}

	_, err = processNamespace(namespace, out)
	if err != nil {
		return nil, err
	}
	for _, i := range filters {
		out, err = i.Filter(out)
		if err != nil {
			return nil, err
		}
	}

	buf := bytes.Buffer{}
	writer := kio.ByteWriter{
		Writer: &buf,
	}

	err = writer.Write(out)
	if err != nil {
		return nil, err
	}

	return decoder.DecodeYAML(buf.Bytes())
}

// processAuthProxyManifests updates the auth-proxy config map to add the
// correct value for the `BFF_ENDPOINT` and `EA_GATEWAY_ENDPOINT`. It also
// updates the session and auth secrets to include a random uuid and the jwt
// secret respectively.
func processAuthProxyManifests(ns *string) kio.FilterFunc {
	return func(nodes []*yaml.RNode) ([]*yaml.RNode, error) {
		var err error
		for _, n := range nodes {
			if n.GetKind() == configMapKind && n.GetName() == "auth-proxy" {
				if err = n.LoadMapIntoConfigMapData(map[string]string{
					"BFF_ENDPOINT":        fmt.Sprintf("http://ee-bff-golang.%s.svc.cluster.local:80", *ns),
					"EA_GATEWAY_ENDPOINT": fmt.Sprintf("http://eagateway.%s.svc.cluster.local:80", *ns),
				}); err != nil {
					break
				}
				continue
			}

			if n.GetKind() == secretKind && n.GetName() == "session" {
				if err = n.LoadMapIntoSecretData(map[string]string{
					"SESSION_SECRET": uuid.NewString(),
				}); err != nil {
					break
				}
				continue
			}

			if n.GetKind() == secretKind && n.GetName() == "auth" {
				if err = n.LoadMapIntoSecretData(map[string]string{
					"APP_SECRET": jwtTokenSecret,
				}); err != nil {
					break
				}
				continue
			}
		}
		return nodes, err
	}
}

// adds the pubsub emulator host envvar to eagateway cm
func processEAGatewayCM(ns *string) kio.FilterFunc {
	return func(nodes []*yaml.RNode) ([]*yaml.RNode, error) {
		var err error
		for _, n := range nodes {
			if n.GetKind() == configMapKind && n.GetName() == "eagateway" {
				err = n.LoadMapIntoConfigMapData(map[string]string{"PUBSUB_EMULATOR_HOST": fmt.Sprintf("pubsub-service.%s.svc.cluster.local.:8085", *ns)})
				break
			}
		}
		return nodes, err
	}
}

// adds local database details to a cm with a given name in the test namespace
func addPostGresDetailsToCM(name string, pgConfigMapData *map[string]string) kio.FilterFunc {
	return func(nodes []*yaml.RNode) ([]*yaml.RNode, error) {
		var err error
		for _, n := range nodes {
			if n.GetKind() == configMapKind && n.GetName() == name {
				err = n.LoadMapIntoConfigMapData(*pgConfigMapData)
				break
			}
		}
		return nodes, err
	}
}

func processNamespace(ns string, nodes []*yaml.RNode) ([]*yaml.RNode, error) {
	fss := types.FsSlice{
		{
			Path:               "metadata/namespace",
			CreateIfNotPresent: true,
		},
	}
	filter := namespace.Filter{
		Namespace: ns,
		FsSlice:   fss,
	}
	return filter.Filter(nodes)
}