// Copyright (C) MongoDB, Inc. 2019-present.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0

package operation

import (
	"context"
	"errors"

	"go.mongodb.org/mongo-driver/event"
	"go.mongodb.org/mongo-driver/mongo/description"
	"go.mongodb.org/mongo-driver/mongo/writeconcern"
	"go.mongodb.org/mongo-driver/x/bsonx/bsoncore"
	"go.mongodb.org/mongo-driver/x/mongo/driver"
	"go.mongodb.org/mongo-driver/x/mongo/driver/session"
)

// Create represents a create operation.
type Create struct {
	capped                       *bool
	collation                    bsoncore.Document
	changeStreamPreAndPostImages bsoncore.Document
	collectionName               *string
	indexOptionDefaults          bsoncore.Document
	max                          *int64
	pipeline                     bsoncore.Document
	size                         *int64
	storageEngine                bsoncore.Document
	validationAction             *string
	validationLevel              *string
	validator                    bsoncore.Document
	viewOn                       *string
	session                      *session.Client
	clock                        *session.ClusterClock
	monitor                      *event.CommandMonitor
	crypt                        driver.Crypt
	database                     string
	deployment                   driver.Deployment
	selector                     description.ServerSelector
	writeConcern                 *writeconcern.WriteConcern
	serverAPI                    *driver.ServerAPIOptions
	expireAfterSeconds           *int64
	timeSeries                   bsoncore.Document
	encryptedFields              bsoncore.Document
	clusteredIndex               bsoncore.Document
}

// NewCreate constructs and returns a new Create.
func NewCreate(collectionName string) *Create {
	return &Create{
		collectionName: &collectionName,
	}
}

func (c *Create) processResponse(driver.ResponseInfo) error {
	return nil
}

// Execute runs this operations and returns an error if the operation did not execute successfully.
func (c *Create) Execute(ctx context.Context) error {
	if c.deployment == nil {
		return errors.New("the Create operation must have a Deployment set before Execute can be called")
	}

	return driver.Operation{
		CommandFn:         c.command,
		ProcessResponseFn: c.processResponse,
		Client:            c.session,
		Clock:             c.clock,
		CommandMonitor:    c.monitor,
		Crypt:             c.crypt,
		Database:          c.database,
		Deployment:        c.deployment,
		Selector:          c.selector,
		WriteConcern:      c.writeConcern,
		ServerAPI:         c.serverAPI,
	}.Execute(ctx)
}

func (c *Create) command(dst []byte, desc description.SelectedServer) ([]byte, error) {
	if c.collectionName != nil {
		dst = bsoncore.AppendStringElement(dst, "create", *c.collectionName)
	}
	if c.capped != nil {
		dst = bsoncore.AppendBooleanElement(dst, "capped", *c.capped)
	}
	if c.changeStreamPreAndPostImages != nil {
		dst = bsoncore.AppendDocumentElement(dst, "changeStreamPreAndPostImages", c.changeStreamPreAndPostImages)
	}
	if c.collation != nil {
		if desc.WireVersion == nil || !desc.WireVersion.Includes(5) {
			return nil, errors.New("the 'collation' command parameter requires a minimum server wire version of 5")
		}
		dst = bsoncore.AppendDocumentElement(dst, "collation", c.collation)
	}
	if c.indexOptionDefaults != nil {
		dst = bsoncore.AppendDocumentElement(dst, "indexOptionDefaults", c.indexOptionDefaults)
	}
	if c.max != nil {
		dst = bsoncore.AppendInt64Element(dst, "max", *c.max)
	}
	if c.pipeline != nil {
		dst = bsoncore.AppendArrayElement(dst, "pipeline", c.pipeline)
	}
	if c.size != nil {
		dst = bsoncore.AppendInt64Element(dst, "size", *c.size)
	}
	if c.storageEngine != nil {
		dst = bsoncore.AppendDocumentElement(dst, "storageEngine", c.storageEngine)
	}
	if c.validationAction != nil {
		dst = bsoncore.AppendStringElement(dst, "validationAction", *c.validationAction)
	}
	if c.validationLevel != nil {
		dst = bsoncore.AppendStringElement(dst, "validationLevel", *c.validationLevel)
	}
	if c.validator != nil {
		dst = bsoncore.AppendDocumentElement(dst, "validator", c.validator)
	}
	if c.viewOn != nil {
		dst = bsoncore.AppendStringElement(dst, "viewOn", *c.viewOn)
	}
	if c.expireAfterSeconds != nil {
		dst = bsoncore.AppendInt64Element(dst, "expireAfterSeconds", *c.expireAfterSeconds)
	}
	if c.timeSeries != nil {
		dst = bsoncore.AppendDocumentElement(dst, "timeseries", c.timeSeries)
	}
	if c.encryptedFields != nil {
		dst = bsoncore.AppendDocumentElement(dst, "encryptedFields", c.encryptedFields)
	}
	if c.clusteredIndex != nil {
		dst = bsoncore.AppendDocumentElement(dst, "clusteredIndex", c.clusteredIndex)
	}
	return dst, nil
}

// Capped specifies if the collection is capped.
func (c *Create) Capped(capped bool) *Create {
	if c == nil {
		c = new(Create)
	}

	c.capped = &capped
	return c
}

// Collation specifies a collation. This option is only valid for server versions 3.4 and above.
func (c *Create) Collation(collation bsoncore.Document) *Create {
	if c == nil {
		c = new(Create)
	}

	c.collation = collation
	return c
}

// ChangeStreamPreAndPostImages specifies how change streams opened against the collection can return pre-
// and post-images of updated documents. This option is only valid for server versions 6.0 and above.
func (c *Create) ChangeStreamPreAndPostImages(csppi bsoncore.Document) *Create {
	if c == nil {
		c = new(Create)
	}

	c.changeStreamPreAndPostImages = csppi
	return c
}

// CollectionName specifies the name of the collection to create.
func (c *Create) CollectionName(collectionName string) *Create {
	if c == nil {
		c = new(Create)
	}

	c.collectionName = &collectionName
	return c
}

// IndexOptionDefaults specifies a default configuration for indexes on the collection.
func (c *Create) IndexOptionDefaults(indexOptionDefaults bsoncore.Document) *Create {
	if c == nil {
		c = new(Create)
	}

	c.indexOptionDefaults = indexOptionDefaults
	return c
}

// Max specifies the maximum number of documents allowed in a capped collection.
func (c *Create) Max(max int64) *Create {
	if c == nil {
		c = new(Create)
	}

	c.max = &max
	return c
}

// Pipeline specifies the agggregtion pipeline to be run against the source to create the view.
func (c *Create) Pipeline(pipeline bsoncore.Document) *Create {
	if c == nil {
		c = new(Create)
	}

	c.pipeline = pipeline
	return c
}

// Size specifies the maximum size in bytes for a capped collection.
func (c *Create) Size(size int64) *Create {
	if c == nil {
		c = new(Create)
	}

	c.size = &size
	return c
}

// StorageEngine specifies the storage engine to use for the index.
func (c *Create) StorageEngine(storageEngine bsoncore.Document) *Create {
	if c == nil {
		c = new(Create)
	}

	c.storageEngine = storageEngine
	return c
}

// ValidationAction specifies what should happen if a document being inserted does not pass validation.
func (c *Create) ValidationAction(validationAction string) *Create {
	if c == nil {
		c = new(Create)
	}

	c.validationAction = &validationAction
	return c
}

// ValidationLevel specifies how strictly the server applies validation rules to existing documents in the collection
// during update operations.
func (c *Create) ValidationLevel(validationLevel string) *Create {
	if c == nil {
		c = new(Create)
	}

	c.validationLevel = &validationLevel
	return c
}

// Validator specifies validation rules for the collection.
func (c *Create) Validator(validator bsoncore.Document) *Create {
	if c == nil {
		c = new(Create)
	}

	c.validator = validator
	return c
}

// ViewOn specifies the name of the source collection or view on which the view will be created.
func (c *Create) ViewOn(viewOn string) *Create {
	if c == nil {
		c = new(Create)
	}

	c.viewOn = &viewOn
	return c
}

// Session sets the session for this operation.
func (c *Create) Session(session *session.Client) *Create {
	if c == nil {
		c = new(Create)
	}

	c.session = session
	return c
}

// ClusterClock sets the cluster clock for this operation.
func (c *Create) ClusterClock(clock *session.ClusterClock) *Create {
	if c == nil {
		c = new(Create)
	}

	c.clock = clock
	return c
}

// CommandMonitor sets the monitor to use for APM events.
func (c *Create) CommandMonitor(monitor *event.CommandMonitor) *Create {
	if c == nil {
		c = new(Create)
	}

	c.monitor = monitor
	return c
}

// Crypt sets the Crypt object to use for automatic encryption and decryption.
func (c *Create) Crypt(crypt driver.Crypt) *Create {
	if c == nil {
		c = new(Create)
	}

	c.crypt = crypt
	return c
}

// Database sets the database to run this operation against.
func (c *Create) Database(database string) *Create {
	if c == nil {
		c = new(Create)
	}

	c.database = database
	return c
}

// Deployment sets the deployment to use for this operation.
func (c *Create) Deployment(deployment driver.Deployment) *Create {
	if c == nil {
		c = new(Create)
	}

	c.deployment = deployment
	return c
}

// ServerSelector sets the selector used to retrieve a server.
func (c *Create) ServerSelector(selector description.ServerSelector) *Create {
	if c == nil {
		c = new(Create)
	}

	c.selector = selector
	return c
}

// WriteConcern sets the write concern for this operation.
func (c *Create) WriteConcern(writeConcern *writeconcern.WriteConcern) *Create {
	if c == nil {
		c = new(Create)
	}

	c.writeConcern = writeConcern
	return c
}

// ServerAPI sets the server API version for this operation.
func (c *Create) ServerAPI(serverAPI *driver.ServerAPIOptions) *Create {
	if c == nil {
		c = new(Create)
	}

	c.serverAPI = serverAPI
	return c
}

// ExpireAfterSeconds sets the seconds to wait before deleting old time-series data.
func (c *Create) ExpireAfterSeconds(eas int64) *Create {
	if c == nil {
		c = new(Create)
	}

	c.expireAfterSeconds = &eas
	return c
}

// TimeSeries sets the time series options for this operation.
func (c *Create) TimeSeries(timeSeries bsoncore.Document) *Create {
	if c == nil {
		c = new(Create)
	}

	c.timeSeries = timeSeries
	return c
}

// EncryptedFields sets the EncryptedFields for this operation.
func (c *Create) EncryptedFields(ef bsoncore.Document) *Create {
	if c == nil {
		c = new(Create)
	}

	c.encryptedFields = ef
	return c
}

// ClusteredIndex sets the ClusteredIndex option for this operation.
func (c *Create) ClusteredIndex(ci bsoncore.Document) *Create {
	if c == nil {
		c = new(Create)
	}

	c.clusteredIndex = ci
	return c
}
