package cushion

import (
	"flag"
	"fmt"
	"os"
	"time"

	metaApi "edge-infra.dev/pkg/edge/apis/meta"
	"edge-infra.dev/pkg/edge/datasync/couchdb"

	"github.com/peterbourgon/ff/v3"
)

type Config struct {
	Port int

	//
	BannerBSLID  string
	BannerEdgeID string
	ProjectID    string
	Subscription string
	Topic        string
	MaxMessages  int

	// CouchDB Config
	CouchURL      string
	CouchPort     string
	CouchUsername string
	CouchPassword string

	BulkSize        int
	MaxWaitInterval time.Duration

	CouchNamespace string
}

func NewConfig() (*Config, error) {
	cfg := &Config{}

	fs := flag.NewFlagSet("couchctl", flag.ExitOnError)

	cfg.BindFlags(fs)

	if err := ff.Parse(fs, os.Args[1:], ff.WithEnvVarNoPrefix(), ff.WithIgnoreUndefined(true)); err != nil {
		return cfg, err
	}

	if err := cfg.Validate(); err != nil {
		return cfg, err
	}

	return cfg, nil
}

func (c *Config) BindFlags(fs *flag.FlagSet) {
	fs.IntVar(
		&c.Port,
		"Port",
		8082,
		"Metrics port",
	)

	fs.StringVar(
		&c.BannerBSLID,
		"banner-id",
		"",
		"BSL Banner ID",
	)

	fs.StringVar(
		&c.BannerEdgeID,
		"banner-edge-id",
		"",
		"Banner Edge ID",
	)

	fs.StringVar(
		&c.ProjectID,
		"foreman-id",
		"",
		"the foreman gcp project id",
	)

	fs.StringVar(
		&c.Subscription,
		"subscription-id",
		"",
		"the pubsub subscription id",
	)

	fs.StringVar(
		&c.Topic,
		"topic-id",
		"data-sync-c2e",
		"the pubsub topic id",
	)

	fs.IntVar(
		&c.MaxMessages,
		"max-mess",
		500,
		"Maximum messages to pull at once",
	)

	fs.StringVar(
		&c.CouchURL,
		"couch-url",
		couchdb.URI,
		"Couch URL to ingest data into",
	)

	fs.StringVar(
		&c.CouchPort,
		"couch-port",
		couchdb.Port,
		"Couch DB port to ingest data into",
	)

	fs.StringVar(
		&c.CouchUsername,
		"couch-username",
		"",
		"Couch DB username to ingest data into",
	)

	fs.StringVar(
		&c.CouchPassword,
		"couch-password",
		"",
		"Couch DB password to ingest data into",
	)

	fs.IntVar(&c.BulkSize,
		"bulk-size",
		1000,
		"couchdb bulk document size",
	)

	fs.DurationVar(&c.MaxWaitInterval,
		"max-wait-interval",
		5*time.Second,
		"how long to wait for bulk insert",
	)

	fs.StringVar(
		&c.CouchNamespace,
		"couch-namespace",
		"data-sync-couchdb",
		"Couch DB namespace",
	)
}

func (c *Config) Validate() error {
	if c.Port == 0 {
		return fmt.Errorf("missing PORT environment variable")
	}

	if c.BannerEdgeID == "" {
		return fmt.Errorf("missing BANNER_EDGE_ID environment variable")
	}

	if c.ProjectID == "" {
		return fmt.Errorf("missing FOREMAN_ID environment variable")
	}

	if c.Subscription == "" {
		return fmt.Errorf("missing SUBSCRIPTION_ID environment variable")
	}

	if c.Topic == "" {
		return fmt.Errorf("missing TOPIC_ID environment variable")
	}

	if c.MaxMessages == 0 {
		return fmt.Errorf("missing MAX_MESS environment variable")
	}

	if c.CouchURL == "" {
		return fmt.Errorf("missing COUCH_URL environment variable")
	}

	if c.CouchPort == "" {
		return fmt.Errorf("missing COUCH_PORT environment variable")
	}

	if c.CouchUsername == "" {
		return fmt.Errorf("missing COUCH_USERNAME environment variable")
	}

	if c.CouchPassword == "" {
		return fmt.Errorf("missing COUCH_PASSWORD environment variable")
	}

	if c.BulkSize == 0 {
		return fmt.Errorf("missing BULK_SIZE environment variable")
	}

	if c.MaxWaitInterval == 0 {
		return fmt.Errorf("missing MAX_WAIT_INTERVAL environment variable")
	}

	if c.CouchNamespace == "" {
		return fmt.Errorf("missing COUCH_NAMESPACE environment variable")
	}
	return nil
}

func (c *Config) ReplicationDB() string {
	return couchdb.ReplicationDBPrefix + metaApi.Hash(c.BannerEdgeID)
}