controllers

var (
	DBAvailableMetric = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name: "data_science_pipelines_application_database_available",
			Help: "Data Science Pipelines Application - Database Availability Status",
		},
		[]string{
			"dspa_name",
			"dspa_namespace",
		},
	)
	ObjectStoreAvailableMetric = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name: "data_science_pipelines_application_object_store_available",
			Help: "Data Science Pipelines Application - Object Store Availability Status",
		},
		[]string{
			"dspa_name",
			"dspa_namespace",
		},
	)
	APIServerReadyMetric = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name: "data_science_pipelines_application_apiserver_ready",
			Help: "Data Science Pipelines Application - APIServer Ready Status",
		},
		[]string{
			"dspa_name",
			"dspa_namespace",
		},
	)
	PersistenceAgentReadyMetric = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name: "data_science_pipelines_application_persistenceagent_ready",
			Help: "Data Science Pipelines Application - PersistenceAgent Ready Status",
		},
		[]string{
			"dspa_name",
			"dspa_namespace",
		},
	)
	ScheduledWorkflowReadyMetric = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name: "data_science_pipelines_application_scheduledworkflow_ready",
			Help: "Data Science Pipelines Application - ScheduledWorkflow Ready Status",
		},
		[]string{
			"dspa_name",
			"dspa_namespace",
		},
	)
	CrReadyMetric = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name: "data_science_pipelines_application_ready",
			Help: "Data Science Pipelines Application - CustomResource Ready Status",
		},
		[]string{
			"dspa_name",
			"dspa_namespace",
		},
	)
)

var ConnectAndQueryDatabase = func(
	host string,
	log logr.Logger,
	port, username, password, dbname, tls string,
	pemCerts [][]byte,
	extraParams map[string]string) (bool, error) {

	mysqlConfig := createMySQLConfig(
		username,
		password,
		host,
		port,
		"",
		extraParams,
	)

	ctx, cancel := context.WithTimeout(context.Background(), config.DefaultDBConnectionTimeout)
	defer cancel()

	var tlsConfig *cryptoTls.Config
	switch tls {
	case "false", "":

	case "true":
		if len(pemCerts) != 0 {
			var err error
			tlsConfig, err = tLSClientConfig(pemCerts)
			if err != nil {
				log.Info(fmt.Sprintf("Encountered error when processing custom ca bundle, Error: %v", err))
				return false, err
			}
		}
	case "skip-verify", "preferred":
		tlsConfig = &cryptoTls.Config{InsecureSkipVerify: true}
	default:

	}

	if tlsConfig != nil {
		err := mysql.RegisterTLSConfig("custom", tlsConfig)

		if _, ok := mysqlConfig.Params["tls"]; ok {
			mysqlConfig.Params["tls"] = "custom"
		}

		mysqlConfig.TLSConfig = "custom"
		if err != nil {
			return false, err
		}
	}

	db, err := sql.Open("mysql", mysqlConfig.FormatDSN())
	if err != nil {
		return false, err
	}
	defer db.Close()

	testStatement := "SELECT 1;"
	_, err = db.QueryContext(ctx, testStatement)
	if err != nil {
		return false, err
	}
	return true, nil
}

var ConnectAndQueryObjStore = func(
	ctx context.Context,
	log logr.Logger,
	endpoint, bucket string,
	accesskey, secretkey []byte,
	secure bool,
	pemCerts [][]byte) bool {
	cred := createCredentialProvidersChain(string(accesskey), string(secretkey))

	opts := &minio.Options{
		Creds:  cred,
		Secure: secure,
	}

	if len(pemCerts) != 0 {
		tr, err := getHttpsTransportWithCACert(log, pemCerts)
		if err != nil {
			log.Error(err, "Encountered error when processing custom ca bundle.")
			return false
		}
		opts.Transport = tr
	}

	minioClient, err := minio.New(endpoint, opts)
	if err != nil {
		log.Info(fmt.Sprintf("Could not connect to object storage endpoint: %s", endpoint))
		return false
	}

	ctx, cancel := context.WithTimeout(ctx, config.DefaultObjStoreConnectionTimeout)
	defer cancel()

	_, err = minioClient.StatObject(ctx, bucket, "some-random-object", minio.GetObjectOptions{})
	if err != nil {
		switch err := err.(type) {

		case minio.ErrorResponse:
			if err.Code == "NoSuchKey" || err.Code == "NoSuchBucket" {
				return true
			}
		}

		if util.IsX509UnknownAuthorityError(err) {
			log.Info(fmt.Sprintf("Encountered x509 UnknownAuthorityError when connecting to ObjectStore. "+
				"If using an tls S3 connection with  self-signed certs, you may specify a custom CABundle "+
				"to mount on the DSP API Server via the DSPA cr under the spec.cABundle field. If you have already "+
				"provided a CABundle, verify the validity of the provided CABundle. Error: %v", err))
			return false
		}

		log.Info(fmt.Sprintf("Could not connect to (%s), Error: %s", endpoint, err.Error()))
		return false
	}

	return true
}