const (
	ManifestTypeExternalSecret = "external-secret"
	ManifestTypeStorageClass   = "storage-class"
	ManifestTypeConfigMap      = "config-map"
	ManifestTypeNamespace      = "namespace"
)

var ErrClusterVersionNotFound = errors.New("not found")

var ErrOriginalClusterVersionNotFound = errors.New("not found")

var ErrUpgradeNotFound = errors.New("not found")

type AWSLoadBalancerController struct {
	Policy         *ManagedPolicy
	ServiceAccount *ServiceAccount
	Chart          *Helm
}

type AWSLoadBalancerControllerService interface {
	CreateAWSLoadBalancerController(ctx context.Context, opts CreateAWSLoadBalancerControllerOpts) (*AWSLoadBalancerController, error)
	DeleteAWSLoadBalancerController(ctx context.Context, id api.ID) error
}

type AWSLoadBalancerControllerState interface {
	HasAWSLoadBalancerController() (bool, error)
}

type AddPostgresToApplicationOpts struct {
	Cluster     v1alpha1.Cluster
	Application v1alpha1.Application

	DatabaseName string
}

type ApplicationManifestService interface {
	// SaveManifest knows how to store a Kubernetes manifest and update Kustomize resources
	SaveManifest(ctx context.Context, opts SaveManifestOpts) error
	// SavePatch knows how to store a Kustomize patch
	SavePatch(ctx context.Context, opts SavePatchOpts) error
	// GetPatch knows how to retrieve a Kustomize patch
	GetPatch(ctx context.Context, opts GetPatchOpts) (jsonpatch.Patch, error)
	// SaveNamespace knows how to store a namespace
	SaveNamespace(ctx context.Context, opts SaveNamespaceOpts) error
}

type ApplicationPostgresService interface {
	AddPostgresToApplication(ctx context.Context, opts AddPostgresToApplicationOpts) error
	RemovePostgresFromApplication(ctx context.Context, opts RemovePostgresFromApplicationOpts) error
	HasPostgresIntegration(ctx context.Context, opts HasPostgresIntegrationOpts) (bool, error)
}

type ApplicationService interface {
	// ScaffoldApplication implements functionality for converting an Application.yaml to deployment resources
	ScaffoldApplication(context.Context, *ScaffoldApplicationOpts) error
	// DeleteApplicationManifests implements functionality for deleting application manifests
	DeleteApplicationManifests(context.Context, DeleteApplicationManifestsOpts) error
	// CreateArgoCDApplicationManifest implements functionality for integrating an app with ArgoCD
	CreateArgoCDApplicationManifest(opts CreateArgoCDApplicationManifestOpts) error
	// DeleteArgoCDApplicationManifest implements functionality for removing an ArgoCD integration for an app
	DeleteArgoCDApplicationManifest(opts DeleteArgoCDApplicationManifestOpts) error
	// HasArgoCDIntegration implements functionality for verifying if there is an existing ArgoCD integration for the app
	HasArgoCDIntegration(context.Context, HasArgoCDIntegrationOpts) (bool, error)
}

type Applier interface {
	// Apply knows how to apply a manifest to a Kubernetes cluster
	Apply(io.Reader) error
}

type ArgoCD struct {
	ID             api.ID
	ArgoDomain     string
	ArgoURL        string
	AuthDomain     string
	Certificate    *Certificate
	IdentityClient *IdentityPoolClient
	PrivateKey     *KubernetesManifest
	Secret         *KubernetesManifest
	ClientSecret   *SecretParameter
	SecretKey      *SecretParameter
	Chart          *Helm
}

type ArgoCDService interface {
	// CreateArgoCD defines functionality for installing ArgoCD into a cluster
	CreateArgoCD(context.Context, CreateArgoCDOpts) (*ArgoCD, error)
	// DeleteArgoCD defines functionality for uninstalling ArgoCD from a cluster
	DeleteArgoCD(context.Context, DeleteArgoCDOpts) error
	// SetupApplicationsSync defines functionality for preparing a directory where ArgoCD application manifests will be
	// automatically synced
	SetupApplicationsSync(context.Context, Applier, v1alpha1.Cluster) error
	// SetupNamespacesSync defines functionality for preparing a directory where namespace manifests will be
	// automatically synced
	SetupNamespacesSync(context.Context, Applier, v1alpha1.Cluster) error
}

type ArgoCDState interface {
	SaveArgoCD(cd *ArgoCD) error
	GetArgoCD() (*ArgoCD, error)
	HasArgoCD() (bool, error)
	RemoveArgoCD() error
}

type Autoscaler struct {
	Policy         *ManagedPolicy
	ServiceAccount *ServiceAccount
	Chart          *Helm
}

type AutoscalerService interface {
	CreateAutoscaler(ctx context.Context, opts CreateAutoscalerOpts) (*Autoscaler, error)
	DeleteAutoscaler(ctx context.Context, id api.ID) error
}

type AutoscalerState interface {
	HasAutoscaler() (bool, error)
}

type Blockstorage struct {
	Policy         *ManagedPolicy
	ServiceAccount *ServiceAccount
	Chart          *Helm
}

type BlockstorageService interface {
	CreateBlockstorage(ctx context.Context, opts CreateBlockstorageOpts) (*Blockstorage, error)
	DeleteBlockstorage(ctx context.Context, id api.ID) error
}

type BlockstorageState interface {
	HasBlockstorage() (bool, error)
}

type Certificate struct {
	ID                     api.ID
	FQDN                   string
	Domain                 string
	HostedZoneID           string
	ARN                    string
	StackName              string
	CloudFormationTemplate []byte
}

type CertificateAPI interface {
	CreateCertificate(opts api.CreateCertificateOpts) (*api.Certificate, error)
	DeleteCertificate(opts api.DeleteCertificateOpts) error
	DeleteCognitoCertificate(opts api.DeleteCognitoCertificateOpts) error
}

type CertificateService interface {
	CreateCertificate(ctx context.Context, opts CreateCertificateOpts) (*Certificate, error)
	DeleteCertificate(ctx context.Context, opts DeleteCertificateOpts) error
	DeleteCognitoCertificate(ctx context.Context, opts DeleteCognitoCertificateOpts) error
}

type CertificateState interface {
	SaveCertificate(certificate *Certificate) error
	GetCertificate(domain string) (*Certificate, error)
	HasCertificate(domain string) (bool, error)
	RemoveCertificate(domain string) error
}

type Cluster struct {
	ID     api.ID
	Name   string
	Config *v1alpha5.ClusterConfig
}

type ClusterAPI interface {
	CreateCluster(opts api.ClusterCreateOpts) (*api.Cluster, error)
	DeleteCluster(opts api.ClusterDeleteOpts) error
	GetClusterSecurityGroupID(opts api.ClusterSecurityGroupIDGetOpts) (*api.ClusterSecurityGroupID, error)
}

type ClusterCreateOpts struct {
	ID                api.ID
	Cidr              string
	Version           string
	VpcID             string
	VpcPrivateSubnets []VpcSubnet
	VpcPublicSubnets  []VpcSubnet
}

type ClusterDeleteOpts struct {
	ID                 api.ID
	FargateProfileName string
}

type ClusterService interface {
	CreateCluster(context.Context, ClusterCreateOpts) (*Cluster, error)
	DeleteCluster(context.Context, ClusterDeleteOpts) error
	GetClusterSecurityGroupID(ctx context.Context, opts GetClusterSecurityGroupIDOpts) (*api.ClusterSecurityGroupID, error)
}

type ClusterState interface {
	SaveCluster(cluster *Cluster) error
	GetCluster(name string) (*Cluster, error)
	RemoveCluster(name string) error
	HasCluster(name string) (bool, error)
}

type ClusterVersion struct {
	ID    api.ID
	Value string
}

type ComponentAPI interface {
	CreatePostgresDatabase(opts api.CreatePostgresDatabaseOpts) (*api.PostgresDatabase, error)
	DeletePostgresDatabase(opts api.DeletePostgresDatabaseOpts) error
	CreateS3Bucket(opts api.CreateS3BucketOpts) (*api.S3Bucket, error)
	DeleteS3Bucket(opts api.DeleteS3BucketOpts) error
}

type ComponentService interface {
	CreatePostgresDatabase(ctx context.Context, opts CreatePostgresDatabaseOpts) (*PostgresDatabase, error)
	DeletePostgresDatabase(ctx context.Context, opts DeletePostgresDatabaseOpts) error
	GetPostgresDatabase(ctx context.Context, opts GetPostgresDatabaseOpts) (*PostgresDatabase, error)
}

type ComponentState interface {
	SavePostgresDatabase(database *PostgresDatabase) error
	RemovePostgresDatabase(stackName string) error
	GetPostgresDatabase(stackName string) (*PostgresDatabase, error)
	GetPostgresDatabases() ([]*PostgresDatabase, error)
}

type ContainerRepository struct {
	ClusterID              api.ID
	ImageName              string
	StackName              string
	CloudFormationTemplate string
	ApplicationName        string
}

type ContainerRepositoryAPI interface {
	CreateContainerRepository(opts api.CreateContainerRepositoryOpts) (*api.ContainerRepository, error)
	DeleteContainerRepository(opts api.DeleteContainerRepositoryOpts) error
	EmptyContainerRepository(opts api.EmptyContainerRepositoryOpts) error
}

type ContainerRepositoryService interface {
	CreateContainerRepository(ctx context.Context, opts CreateContainerRepositoryOpts) (*ContainerRepository, error)
	DeleteContainerRepository(ctx context.Context, opts DeleteContainerRepositoryOpts) error
	EmptyContainerRepository(ctx context.Context, opts EmptyContainerRepositoryOpts) error
}

type ContainerRepositoryState interface {
	SaveContainerRepository(repository *ContainerRepository) error
	RemoveContainerRepository(imageName string) error
	GetContainerRepository(imageName string) (*ContainerRepository, error)
	GetContainerRepositoryFromApplication(applicationName string) (*ContainerRepository, error)
	ApplicationHasImage(applicationName string) (bool, error)
}

type CreateAWSLoadBalancerControllerOpts struct {
	ID    api.ID
	VPCID string
}

type CreateArgoCDApplicationManifestOpts struct {
	Cluster     v1alpha1.Cluster
	Application v1alpha1.Application
}

type CreateArgoCDOpts struct {
	ClusterManifest v1alpha1.Cluster
	Domain          string
	FQDN            string
	HostedZoneID    string
	UserPoolID      string
	AuthDomain      string
	Repository      *GithubRepository
}

type CreateAutoscalerOpts struct {
	ID api.ID
}

type CreateBlockstorageOpts struct {
	ID api.ID
}

type CreateCertificateOpts struct {
	ID           api.ID
	FQDN         string
	Domain       string
	HostedZoneID string
}

type CreateConfigMapOpts struct {
	ID        api.ID
	Name      string
	Namespace string
	Data      map[string]string
	Labels    map[string]string
}

type CreateContainerRepositoryOpts struct {
	ClusterID       api.ID
	ImageName       string
	ApplicationName string
}

type CreateExternalDNSOpts struct {
	ID           api.ID
	HostedZoneID string
	Domain       string
}

type CreateExternalSecretOpts struct {
	ID        api.ID
	Name      string
	Namespace string
	Manifest  api.Manifest
}

type CreateExternalSecretsOpts struct {
	ID api.ID
}

type CreateGithubDeployKeyOpts struct {
	ID           api.ID
	Organisation string
	Repository   string
	Title        string
}

type CreateGithubRepositoryOpts struct {
	ID           api.ID
	Host         string
	Organization string
	Name         string
}

type CreateHelmReleaseOpts struct {
	ID             api.ID
	RepositoryName string
	RepositoryURL  string
	ReleaseName    string
	Version        string
	Chart          string
	Namespace      string
	Values         []byte
}

type CreateIdentityPoolClientOpts struct {
	ID          api.ID
	UserPoolID  string
	Purpose     string
	CallbackURL string
}

type CreateIdentityPoolOpts struct {
	ID           api.ID
	AuthDomain   string
	AuthFQDN     string
	HostedZoneID string
}

type CreateIdentityPoolUserOpts struct {
	ID         api.ID
	Email      string
	UserPoolID string
}

type CreateKubePromStackOpts struct {
	ID           api.ID
	Domain       string
	HostedZoneID string
	AuthDomain   string
	UserPoolID   string
}

type CreatePolicyOpts struct {
	ID                     api.ID
	StackName              string
	PolicyOutputName       string
	CloudFormationTemplate []byte
}

type CreatePostgresDatabaseOpts struct {
	ID                api.ID
	ApplicationName   string
	UserName          string
	VpcID             string
	DBSubnetGroupName string
	DBSubnetIDs       []string
	DBSubnetCIDRs     []string
	Namespace         string
}

type CreatePrimaryHostedZoneOpts struct {
	ID            api.ID
	Domain        string
	FQDN          string
	NameServerTTL int64
}

type CreateSecretOpts struct {
	ID     api.ID
	Name   string
	Secret string
}

type CreateServiceAccountOpts struct {
	ID        api.ID
	Name      string
	PolicyArn string
	Config    *v1alpha5.ClusterConfig
}

type CreateVpcOpts struct {
	ID      api.ID
	Cidr    string
	Minimal bool
}

type DeleteApplicationManifestsOpts struct {
	Cluster     v1alpha1.Cluster
	Application v1alpha1.Application
}

type DeleteArgoCDApplicationManifestOpts struct {
	Cluster     v1alpha1.Cluster
	Application v1alpha1.Application
}

type DeleteArgoCDOpts struct {
	ID api.ID
}

type DeleteCertificateOpts struct {
	ID     api.ID
	Domain string
}

type DeleteCognitoCertificateOpts struct {
	ID     api.ID
	Domain string
}

type DeleteConfigMapOpts struct {
	ID        api.ID
	Name      string
	Namespace string
}

type DeleteContainerRepositoryOpts struct {
	ClusterID api.ID
	ImageName string
}

type DeleteExternalSecretOpts struct {
	ID      api.ID
	Name    string
	Secrets map[string]string
}

type DeleteGithubDeployKeyOpts struct {
	ID           api.ID
	Organisation string
	Repository   string
	Identifier   int64
}

type DeleteGithubRepositoryOpts struct {
	ID           api.ID
	Organisation string
	Name         string
}

type DeleteHelmReleaseOpts struct {
	ID          api.ID
	ReleaseName string
	Namespace   string
}

type DeleteIdentityPoolClientOpts struct {
	ID      api.ID
	Purpose string
}

type DeleteIdentityPoolOpts struct {
	ID         api.ID
	UserPoolID string
	Domain     string
}

type DeleteIdentityPoolUserOpts struct {
	ClusterID api.ID
	UserEmail string
}

type DeleteKubePromStackOpts struct {
	ID     api.ID
	Domain string
}

type DeletePolicyOpts struct {
	ID        api.ID
	StackName string
}

type DeletePostgresDatabaseOpts struct {
	ID              api.ID
	ApplicationName string
	Namespace       string
	VpcID           string
}

type DeletePrimaryHostedZoneOpts struct {
	ID           api.ID
	HostedZoneID string
}

type DeleteSecretOpts struct {
	ID   api.ID
	Name string
}

type DeleteServiceAccountOpts struct {
	ID     api.ID
	Name   string
	Config *v1alpha5.ClusterConfig
}

type DeleteVpcOpts struct {
	ID api.ID
}

type DomainAPI interface {
	CreatePrimaryHostedZone(opts CreatePrimaryHostedZoneOpts) (*HostedZone, error)
	DeletePrimaryHostedZone(domain string, opts DeletePrimaryHostedZoneOpts) error
}

type DomainService interface {
	CreatePrimaryHostedZone(ctx context.Context, opts CreatePrimaryHostedZoneOpts) (*HostedZone, error)
	GetPrimaryHostedZone(ctx context.Context) (*HostedZone, error)
	DeletePrimaryHostedZone(ctx context.Context, opts DeletePrimaryHostedZoneOpts) error
	SetHostedZoneDelegation(ctx context.Context, domain string, delegated bool) error
}

type DomainState interface {
	SaveHostedZone(zone *HostedZone) error
	UpdateHostedZone(zone *HostedZone) error
	RemoveHostedZone(domain string) error
	GetHostedZone(domain string) (*HostedZone, error)
	GetPrimaryHostedZone() (*HostedZone, error)
	GetHostedZones() ([]*HostedZone, error)
	HasPrimaryHostedZone() (bool, error)
}

type EmptyContainerRepositoryOpts struct {
	Name string
}

type ExternalDNS struct {
	Policy         *ManagedPolicy
	ServiceAccount *ServiceAccount
	Kube           *ExternalDNSKube
}

type ExternalDNSAPI interface {
	CreateExternalDNSKubeDeployment(opts api.CreateExternalDNSKubeDeploymentOpts) (*api.ExternalDNSKube, error)
}

type ExternalDNSKube struct {
	ID           api.ID
	HostedZoneID string
	DomainFilter string
	Manifests    map[string][]byte
}

type ExternalDNSService interface {
	CreateExternalDNS(ctx context.Context, opts CreateExternalDNSOpts) (*ExternalDNS, error)
	DeleteExternalDNS(ctx context.Context, id api.ID) error
}

type ExternalDNSState interface {
	SaveExternalDNS(dns *ExternalDNS) error
	GetExternalDNS() (*ExternalDNS, error)
	RemoveExternalDNS() error
	HasExternalDNS() (bool, error)
}

type ExternalSecrets struct {
	Policy         *ManagedPolicy
	ServiceAccount *ServiceAccount
	Chart          *Helm
}

type ExternalSecretsService interface {
	CreateExternalSecrets(ctx context.Context, opts CreateExternalSecretsOpts) (*ExternalSecrets, error)
	DeleteExternalSecrets(ctx context.Context, id api.ID) error
}

type ExternalSecretsState interface {
	HasExternalSecrets() (bool, error)
}

type GetClusterSecurityGroupIDOpts struct {
	ID api.ID
}

type GetHelmReleaseOpts struct {
	ClusterID   api.ID
	ReleaseName string
	Namespace   string
}

type GetPatchOpts struct {
	ApplicationName string
	ClusterName     string

	Kind string
}

type GetPostgresDatabaseOpts struct {
	ClusterID    api.ID
	DatabaseName string
}

type GitRemoteFileDeleter interface {
	// Delete deletes a remote file from a Git repository
	Delete(repositoryURL string, targetPath string, commitMessage string) error
}

type GithubDeployKey struct {
	Organisation     string
	Repository       string
	Identifier       int64
	Title            string
	PublicKey        string
	PrivateKeySecret *GithubSecret
}

type GithubRepository struct {
	ID           api.ID
	Organisation string
	Repository   string
	FullName     string
	GitURL       string
	DeployKey    *GithubDeployKey
}

type GithubSecret struct {
	Name    string
	Path    string
	Version int64
}

type GithubService interface {
	CreateGithubRepository(ctx context.Context, opts CreateGithubRepositoryOpts) (*GithubRepository, error)
	DeleteGithubRepository(ctx context.Context, opts DeleteGithubRepositoryOpts) error
	CreateRepositoryDeployKey(opts CreateGithubDeployKeyOpts) (*GithubDeployKey, error)
	DeleteRepositoryDeployKey(opts DeleteGithubDeployKeyOpts) error
	ListReleases(owner, repo string) ([]*github.RepositoryRelease, error)
}

type GithubState interface {
	SaveGithubRepository(repository *GithubRepository) error
	GetGithubRepository(fullName string) (*GithubRepository, error)
	RemoveGithubRepository(fullName string) error
}

type HasArgoCDIntegrationOpts struct {
	Cluster     v1alpha1.Cluster
	Application v1alpha1.Application
}

type HasPostgresIntegrationOpts struct {
	Cluster     v1alpha1.Cluster
	Application v1alpha1.Application

	DatabaseName string
}

type Helm struct {
	ID      api.ID
	Release *release.Release
	Chart   *helm.Chart
}

type HelmAPI interface {
	CreateHelmRelease(opts api.CreateHelmReleaseOpts) (*api.Helm, error)
	DeleteHelmRelease(opts api.DeleteHelmReleaseOpts) error
	GetHelmRelease(opts api.GetHelmReleaseOpts) (*api.Helm, error)
}

type HelmService interface {
	CreateHelmRelease(ctx context.Context, opts CreateHelmReleaseOpts) (*Helm, error)
	DeleteHelmRelease(ctx context.Context, opts DeleteHelmReleaseOpts) error
	GetHelmRelease(ctx context.Context, opts GetHelmReleaseOpts) (*Helm, error)
}

type HelmState interface {
	SaveHelmRelease(helm *Helm) error
	RemoveHelmRelease(releaseName string) error
	GetHelmRelease(releaseName string) (*Helm, error)
}

type HostedZone struct {
	ID                     api.ID
	IsDelegated            bool
	Primary                bool
	Managed                bool
	FQDN                   string
	Domain                 string
	HostedZoneID           string
	NameServers            []string
	StackName              string
	CloudFormationTemplate []byte
}

type IdentityManagerAPI interface {
	CreateIdentityPool(opts api.CreateIdentityPoolOpts) (*api.IdentityPool, error)
	DeleteIdentityPool(opts api.DeleteIdentityPoolOpts) error
	CreateIdentityPoolClient(opts api.CreateIdentityPoolClientOpts) (*api.IdentityPoolClient, error)
	DeleteIdentityPoolClient(opts api.DeleteIdentityPoolClientOpts) error
	CreateIdentityPoolUser(opts api.CreateIdentityPoolUserOpts) (*api.IdentityPoolUser, error)
	DeleteIdentityPoolUser(opts api.DeleteIdentityPoolUserOpts) error
}

type IdentityManagerService interface {
	CreateIdentityPool(ctx context.Context, opts CreateIdentityPoolOpts) (*IdentityPool, error)
	DeleteIdentityPool(ctx context.Context, opts api.ID) error
	CreateIdentityPoolClient(ctx context.Context, opts CreateIdentityPoolClientOpts) (*IdentityPoolClient, error)
	DeleteIdentityPoolClient(ctx context.Context, opts DeleteIdentityPoolClientOpts) error
	CreateIdentityPoolUser(ctx context.Context, opts CreateIdentityPoolUserOpts) (*IdentityPoolUser, error)
	DeleteIdentityPoolUser(ctx context.Context, opts DeleteIdentityPoolUserOpts) error
}

type IdentityManagerState interface {
	SaveIdentityPool(pool *IdentityPool) error
	RemoveIdentityPool(stackName string) error
	GetIdentityPool(stackName string) (*IdentityPool, error)
	HasIdentityPool() (bool, error)
	SaveIdentityPoolClient(client *IdentityPoolClient) error
	GetIdentityPoolClient(stackName string) (*IdentityPoolClient, error)
	RemoveIdentityPoolClient(stackName string) error
	SaveIdentityPoolUser(user *IdentityPoolUser) error
	GetIdentityPoolUser(stackName string) (*IdentityPoolUser, error)
	RemoveIdentityPoolUser(stackName string) error
	GetIdentityPoolUsers() ([]IdentityPoolUser, error)
}

type IdentityPool struct {
	ID                      api.ID
	UserPoolID              string
	AuthDomain              string
	HostedZoneID            string
	StackName               string
	CloudFormationTemplates []byte
	Certificate             *Certificate
	RecordSetAlias          *RecordSetAlias
}

type IdentityPoolClient struct {
	ID                      api.ID
	UserPoolID              string
	Purpose                 string
	CallbackURL             string
	ClientID                string
	ClientSecret            string
	StackName               string
	CloudFormationTemplates []byte
}

type IdentityPoolUser struct {
	ID                     api.ID
	Email                  string
	UserPoolID             string
	StackName              string
	CloudFormationTemplate []byte
}

type InitiateDomainDelegationOpts struct {
	ClusterID api.ID

	PrimaryHostedZoneFQDN string
	Nameservers           []string
	Labels                []string
}

type KubePromStack struct {
	ID                                api.ID
	AuthHostname                      string
	CertificateARN                    string
	ClientID                          string
	FargateCloudWatchPolicyARN        string
	FargateProfilePodExecutionRoleARN string
	Hostname                          string
	SecretsAdminPassKey               string
	SecretsAdminUserKey               string
	SecretsClientSecretKey            string
	SecretsConfigName                 string
	SecretsCookieSecretKey            string
	Certificate                       *Certificate
	Chart                             *Helm
	ExternalSecret                    *KubernetesManifest
	IdentityPoolClient                *IdentityPoolClient
}

type KubernetesManifest struct {
	ID        api.ID
	Name      string
	Namespace string
	Type      ManifestType
	Content   []byte
}

type KubernetesState interface {
	HasResource(kind, namespace, name string) (bool, error)
}

type Locker interface {
	// AcquireStateLock knows how to activate a locking mechanism preventing others from mutating state
	AcquireStateLock(clusterID api.ID) error
	// ReleaseStateLock knows how to deactivate a locking mechanism allowing others to mutate state
	ReleaseStateLock(clusterID api.ID) error
}

type LokiState interface {
	HasLoki() (bool, error)
}

type ManagedPolicy struct {
	ID                     api.ID
	StackName              string
	PolicyARN              string
	CloudFormationTemplate []byte
}

type ManagedPolicyAPI interface {
	CreatePolicy(opts api.CreatePolicyOpts) (*api.ManagedPolicy, error)
	DeletePolicy(opts api.DeletePolicyOpts) error
}

type ManagedPolicyService interface {
	CreatePolicy(ctx context.Context, opts CreatePolicyOpts) (*ManagedPolicy, error)
	DeletePolicy(ctx context.Context, opts DeletePolicyOpts) error
}

type ManagedPolicyState interface {
	SavePolicy(policy *ManagedPolicy) error
	GetPolicy(stackName string) (*ManagedPolicy, error)
	RemovePolicy(stackName string) error
}

type ManifestAPI interface {
	CreateStorageClass(opts api.CreateStorageClassOpts) (*api.StorageClassKube, error)
	CreateExternalSecret(opts CreateExternalSecretOpts) (*api.ExternalSecretsKube, error)
	DeleteExternalSecret(opts api.DeleteExternalSecretsOpts) error
	CreateConfigMap(opts api.CreateConfigMapOpts) (*api.ConfigMap, error)
	DeleteConfigMap(opts api.DeleteConfigMapOpts) error
	CreateNamespace(opts api.CreateNamespaceOpts) (*api.Namespace, error)
	DeleteNamespace(opts api.DeleteNamespaceOpts) error
	ScaleDeployment(opts api.ScaleDeploymentOpts) error
}

type ManifestService interface {
	CreateStorageClass(ctx context.Context, opts api.CreateStorageClassOpts) (*KubernetesManifest, error)
	CreateExternalSecret(ctx context.Context, opts CreateExternalSecretOpts) (*KubernetesManifest, error)
	DeleteExternalSecret(ctx context.Context, opts DeleteExternalSecretOpts) error
	CreateConfigMap(ctx context.Context, opts CreateConfigMapOpts) (*KubernetesManifest, error)
	DeleteConfigMap(ctx context.Context, opts DeleteConfigMapOpts) error
	CreateNamespace(ctx context.Context, opts api.CreateNamespaceOpts) (*KubernetesManifest, error)
	DeleteNamespace(ctx context.Context, opts api.DeleteNamespaceOpts) error
	ScaleDeployment(ctx context.Context, opts api.ScaleDeploymentOpts) error
}

type ManifestState interface {
	SaveKubernetesManifests(manifests *KubernetesManifest) error
	GetKubernetesManifests(name string) (*KubernetesManifest, error)
	RemoveKubernetesManifests(name string) error
}

type ManifestType string

type MonitoringService interface {
	CreateKubePromStack(ctx context.Context, opts CreateKubePromStackOpts) (*KubePromStack, error)
	DeleteKubePromStack(ctx context.Context, opts DeleteKubePromStackOpts) error
	CreateLoki(ctx context.Context, id api.ID) (*Helm, error)
	DeleteLoki(ctx context.Context, id api.ID) error
	CreatePromtail(ctx context.Context, id api.ID) (*Helm, error)
	DeletePromtail(ctx context.Context, id api.ID) error
	CreateTempo(ctx context.Context, id api.ID) (*Helm, error)
	DeleteTempo(ctx context.Context, id api.ID) error
}

type MonitoringState interface {
	SaveKubePromStack(stack *KubePromStack) error
	RemoveKubePromStack() error
	GetKubePromStack() (*KubePromStack, error)
	HasKubePromStack() (bool, error)
}

type NSRecordDelegationService interface {
	InitiateDomainDelegation(opts InitiateDomainDelegationOpts) error
	RevokeDomainDelegation(opts RevokeDomainDelegationOpts) error
}

type OriginalClusterVersion struct {
	ID    api.ID
	Value string
}

type ParameterAPI interface {
	CreateSecret(opts api.CreateSecretOpts) (*api.SecretParameter, error)
	DeleteSecret(opts api.DeleteSecretOpts) error
}

type ParameterService interface {
	CreateSecret(ctx context.Context, opts CreateSecretOpts) (*SecretParameter, error)
	DeleteSecret(ctx context.Context, opts DeleteSecretOpts) error
}

type ParameterState interface {
	SaveSecret(parameter *SecretParameter) error
	GetSecret(name string) (*SecretParameter, error)
	RemoveSecret(name string) error
}

type PostgresDatabase struct {
	ID                           api.ID
	ApplicationName              string
	UserName                     string
	StackName                    string
	AdminSecretFriendlyName      string
	EndpointAddress              string
	EndpointPort                 int
	OutgoingSecurityGroupID      string
	SecretsManagerAdminSecretARN string
	LambdaPolicyARN              string
	LambdaRoleARN                string
	LambdaFunctionARN            string
	CloudFormationTemplate       string
	Namespace                    string
	AdminSecretName              string
	AdminSecretARN               string
	DatabaseConfigMapName        string
	RotaterBucket                *S3Bucket
}

type PromtailState interface {
	HasPromtail() (bool, error)
}

type RecordSetAlias struct {
	AliasDomain            string
	AliasHostedZones       string
	StackName              string
	CloudFormationTemplate []byte
}

type RemoteStateService interface {
	// Purge knows how to tear down all traces of remote state
	Purge(clusterID api.ID) error
	Stater
	Locker
}

type RemovePostgresFromApplicationOpts struct {
	Cluster     v1alpha1.Cluster
	Application v1alpha1.Application

	DatabaseName string
}

type RevokeDomainDelegationOpts struct {
	ClusterID             api.ID
	PrimaryHostedZoneFQDN string
	Labels                []string
}

type S3Bucket struct {
	Name                   string
	StackName              string
	CloudFormationTemplate string
}

type SaveManifestOpts struct {
	ApplicationName string

	Filename string
	Content  []byte
}

type SaveNamespaceOpts struct {
	Filename    string
	ClusterName string
	Payload     io.Reader
}

type SavePatchOpts struct {
	ApplicationName string
	ClusterName     string

	Kind  string
	Patch jsonpatch.Patch
}

type ScaffoldApplicationOpts struct {
	Cluster     v1alpha1.Cluster
	Application v1alpha1.Application

	CertificateARN string
}

type SecretParameter struct {
	ID      api.ID
	Name    string
	Path    string
	Version int64
	Content string
}

type SecurityGroupAPI interface {
	api.SecurityGroupCRUDer
	api.SecurityGroupRuleCRUDer
}

type ServiceAccount struct {
	ID        api.ID
	Name      string
	PolicyArn string
	Config    *v1alpha5.ClusterConfig
}

type ServiceAccountAPI interface {
	CreateServiceAccount(opts api.CreateServiceAccountOpts) (*api.ServiceAccount, error)
	DeleteServiceAccount(opts api.DeleteServiceAccountOpts) error
}

type ServiceAccountService interface {
	CreateServiceAccount(ctx context.Context, opts CreateServiceAccountOpts) (*ServiceAccount, error)
	DeleteServiceAccount(ctx context.Context, opts DeleteServiceAccountOpts) error
}

type ServiceAccountState interface {
	SaveServiceAccount(account *ServiceAccount) error
	RemoveServiceAccount(name string) error
	GetServiceAccount(name string) (*ServiceAccount, error)
	UpdateServiceAccount(account *ServiceAccount) error
}

type Stater interface {
	// Upload knows how to upload state to a remote location
	Upload(clusterID api.ID, reader io.Reader) error
	// Download knows how to download state from a remote location
	Download(clusterID api.ID) (io.Reader, error)
}

type TempoState interface {
	HasTempo() (bool, error)
}

type Upgrade struct {
	ID      api.ID
	Version string
}

type UpgradeState interface {
	SaveUpgrade(upgrade *Upgrade) error
	GetUpgrades() ([]*Upgrade, error)
	SaveOriginalClusterVersionIfNotExists(originalClusterVersion *OriginalClusterVersion) error
	GetOriginalClusterVersion() (*OriginalClusterVersion, error)
	SaveClusterVersion(version *ClusterVersion) error
	GetClusterVersion() (*ClusterVersion, error)
}

type VPCAPI interface {
	CreateVpc(opts api.CreateVpcOpts) (*api.Vpc, error)
	DeleteVpc(opts api.DeleteVpcOpts) error
}

type VPCService interface {
	CreateVpc(ctx context.Context, opts CreateVpcOpts) (*Vpc, error)
	DeleteVpc(ctx context.Context, opts DeleteVpcOpts) error
	GetVPC(ctx context.Context, id api.ID) (*Vpc, error)
}

type VPCState interface {
	SaveVpc(vpc *Vpc) error
	GetVpc(stackName string) (*Vpc, error)
	RemoveVpc(stackName string) error
	HasVPC(clusterName string) (bool, error)
}

type Vpc struct {
	ID                     api.ID
	StackName              string
	CloudFormationTemplate []byte

	VpcID                    string
	Cidr                     string
	PublicSubnets            []VpcSubnet
	PrivateSubnets           []VpcSubnet
	DatabaseSubnets          []VpcSubnet
	DatabaseSubnetsGroupName string
}

type VpcSubnet struct {
	ID               string
	Cidr             string
	AvailabilityZone string
}