package bootstrap

import (
	"fmt"
	"time"

	kustomizeApiV1 "github.com/fluxcd/kustomize-controller/api/v1"
	kustomizeApiV1beta2 "github.com/fluxcd/kustomize-controller/api/v1beta2"
	meta2 "github.com/fluxcd/pkg/apis/meta"
	sourceApiV1beta2 "github.com/fluxcd/source-controller/api/v1beta2"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"sigs.k8s.io/controller-runtime/pkg/client"
)

const (
	// bucket
	gcpEndpoint = "storage.googleapis.com"
	gcpProvider = "gcp"

	// kustomize
	kindBucket = "Bucket"
)

var (
	// both
	defaultTimeout  = 5 * time.Minute
	defaultInterval = 60 * time.Second

	// bucket
	defaultInsecure = false

	// kustomize
	defaultForce = true
	defaultPrune = true
)

type FluxBucket struct {
	name       string
	namespace  string
	interval   time.Duration
	secretName string
	timeout    time.Duration
	ignore     string
	provider   string
	endpoint   string
	bucketName string
	insecure   bool
}

func BucketFluxConfig() *FluxBucket {
	return &FluxBucket{timeout: defaultTimeout, interval: defaultInterval, provider: gcpProvider,
		endpoint: gcpEndpoint, insecure: defaultInsecure}
}

func (b *FluxBucket) Name(name string) *FluxBucket {
	b.name = name
	return b
}

func (b *FluxBucket) Namespace(ns string) *FluxBucket {
	b.namespace = ns
	return b
}

func (b *FluxBucket) Interval(interval time.Duration) *FluxBucket {
	b.interval = interval
	return b
}

func (b *FluxBucket) SecretName(secretName string) *FluxBucket {
	b.secretName = secretName
	return b
}

func (b *FluxBucket) Timeout(timeout time.Duration) *FluxBucket {
	b.timeout = timeout
	return b
}

func (b *FluxBucket) ForCluster(cluster string) *FluxBucket {
	b.ignore = fmt.Sprintf("# exclude all\n/*\n# include deploy dir\n!/%s", cluster)
	return b
}

func (b *FluxBucket) BucketName(bn string) *FluxBucket {
	b.bucketName = bn
	return b
}

func (b *FluxBucket) Build() client.Object {
	retV1Beta2 := &sourceApiV1beta2.Bucket{
		TypeMeta: metav1.TypeMeta{
			Kind:       sourceApiV1beta2.BucketKind,
			APIVersion: sourceApiV1beta2.GroupVersion.String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      b.name,
			Namespace: b.namespace,
		},
		Spec: sourceApiV1beta2.BucketSpec{
			Interval: metav1.Duration{
				Duration: b.interval,
			},
			Provider:   b.provider,
			BucketName: b.bucketName,
			Endpoint:   b.endpoint,
			Insecure:   b.insecure,
			Timeout: &metav1.Duration{
				Duration: b.timeout,
			},
			Ignore: &b.ignore,
		},
	}
	if b.secretName != "" {
		retV1Beta2.Spec.SecretRef = &meta2.LocalObjectReference{
			Name: b.secretName,
		}
	}
	return retV1Beta2
}

type FluxKustomize struct {
	name            string
	namespace       string
	interval        time.Duration
	path            string
	timeout         time.Duration
	bucketName      string
	bucketNamespace string
	kind            string
	force           bool
	prune           bool
	annotations     map[string]string
	clusterVersion  string
}

func KustomizeFluxConfig() *FluxKustomize {
	return &FluxKustomize{timeout: defaultTimeout, interval: defaultInterval,
		kind: kindBucket, force: defaultForce, prune: defaultPrune}
}

func (k *FluxKustomize) Name(name string) *FluxKustomize {
	k.name = name
	return k
}

func (k *FluxKustomize) Namespace(ns string) *FluxKustomize {
	k.namespace = ns
	return k
}

func (k *FluxKustomize) Interval(interval time.Duration) *FluxKustomize {
	k.interval = interval
	return k
}

func (k *FluxKustomize) Path(path string) *FluxKustomize {
	k.path = path
	return k
}

func (k *FluxKustomize) Force(force bool) *FluxKustomize {
	k.force = force
	return k
}

func (k *FluxKustomize) Timeout(timeout time.Duration) *FluxKustomize {
	k.timeout = timeout
	return k
}

func (k *FluxKustomize) BucketName(bn string) *FluxKustomize {
	k.bucketName = bn
	return k
}

func (k *FluxKustomize) BucketNamespace(ns string) *FluxKustomize {
	k.bucketNamespace = ns
	return k
}

func (k *FluxKustomize) Prune(p bool) *FluxKustomize {
	k.prune = p
	return k
}

func (k *FluxKustomize) Annotations(annotations map[string]string) *FluxKustomize {
	k.annotations = annotations
	return k
}

func (k *FluxKustomize) ForStoreVersion(version string) *FluxKustomize {
	k.clusterVersion = version
	return k
}

func (k *FluxKustomize) Build() client.Object {
	var res client.Object
	supports := SupportsFluxV024(k.clusterVersion)
	if !supports {
		res = &kustomizeApiV1beta2.Kustomization{
			TypeMeta: metav1.TypeMeta{
				Kind:       kustomizeApiV1beta2.KustomizationKind,
				APIVersion: kustomizeApiV1beta2.GroupVersion.String(),
			},
			ObjectMeta: metav1.ObjectMeta{
				Name:        k.name,
				Namespace:   k.namespace,
				Annotations: k.annotations,
			},

			Spec: kustomizeApiV1beta2.KustomizationSpec{
				Interval: metav1.Duration{
					Duration: k.interval,
				},
				Force: k.force,
				Path:  k.path,
				Prune: k.prune,
				SourceRef: kustomizeApiV1beta2.CrossNamespaceSourceReference{
					APIVersion: sourceApiV1beta2.GroupVersion.String(),
					Kind:       k.kind,
					Name:       k.bucketName,
					Namespace:  k.bucketNamespace,
				},
				Timeout: &metav1.Duration{
					Duration: k.timeout,
				},
			},
		}
	} else {
		res = &kustomizeApiV1.Kustomization{
			TypeMeta: metav1.TypeMeta{
				Kind:       kustomizeApiV1.KustomizationKind,
				APIVersion: kustomizeApiV1.GroupVersion.String(),
			},
			ObjectMeta: metav1.ObjectMeta{
				Name:        k.name,
				Namespace:   k.namespace,
				Annotations: k.annotations,
			},

			Spec: kustomizeApiV1.KustomizationSpec{
				Interval: metav1.Duration{
					Duration: k.interval,
				},
				Force: k.force,
				Path:  k.path,
				Prune: k.prune,
				SourceRef: kustomizeApiV1.CrossNamespaceSourceReference{
					APIVersion: sourceApiV1beta2.GroupVersion.String(),
					Kind:       k.kind,
					Name:       k.bucketName,
					Namespace:  k.bucketNamespace,
				},
				Timeout: &metav1.Duration{
					Duration: k.timeout,
				},
			},
		}
	}
	return res
}