package main

import (
	"context"
	"fmt"
	"reflect"
	"time"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

type mongoClient struct {
	dbName, colName string
	client          *mongo.Client
	col             *mongo.Collection
}

func (mc *mongoClient) init(dbName, colName string) error {
	var err error
	if err = mc.Connect(dbName, colName); err != nil {
		return err
	}
	if err = mc.Drop(); err != nil {
		return err
	}

	return nil
}

func (mc *mongoClient) Connect(dbName, colName string) error {
	var err error
	mc.client, err = mongo.NewClient(options.Client().ApplyURI("mongodb://localhost:27017"))

	if err != nil {
		return err
	}

	ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
	err = mc.client.Connect(ctx)
	if err != nil {
		return err
	}

	mc.col = mc.client.Database(dbName).Collection(colName)
	mc.dbName = dbName
	mc.colName = colName
	return nil
}

func (mc *mongoClient) InsertOne(document interface{}) error {
	_, err := mc.col.InsertOne(context.Background(), document)
	return err
}

func (mc *mongoClient) UpdateOne(filter, update interface{}) error {
	_, err := mc.col.UpdateOne(context.Background(), filter, update)
	return err
}

func (mc *mongoClient) UpdateMany(filter, update interface{}) error {
	_, err := mc.col.UpdateMany(context.Background(), filter, update)
	return err
}

func (mc *mongoClient) ReplaceOne(filter, new interface{}) error {
	_, err := mc.col.ReplaceOne(context.Background(), filter, new)
	return err
}

func (mc *mongoClient) Finddoc(filter bson.M, results interface{}) error {
	sliceValue := reflect.ValueOf(results)

	if sliceValue.Kind() != reflect.Ptr || sliceValue.Elem().Kind() != reflect.Slice {
		return fmt.Errorf("Error: result argument must be pointer to slice")
	}
	cur, err := mc.col.Find(context.TODO(), filter)
	if err != nil {
		return err
	}
	defer cur.Close(context.TODO())

	elemType := sliceValue.Elem().Type().Elem()

	sliceValue = sliceValue.Elem()

	for cur.Next(context.TODO()) {
		elem := reflect.New(elemType).Interface()
		err := cur.Decode(elem)
		if err != nil {
			return err
		}
		sliceValue = reflect.Append(sliceValue, reflect.ValueOf(elem).Elem())
	}

	reflect.ValueOf(results).Elem().Set(sliceValue)
	return nil
}

func (mc *mongoClient) FindOneAndDelete(filter bson.M) (bson.M, error) {
	res := mc.col.FindOneAndDelete(context.Background(), filter)
	var result bson.M
	err := res.Decode(&result)
	return result, err
}

func (mc *mongoClient) Drop() error {
	return mc.col.Drop(context.Background())
}

func (mc *mongoClient) Disconnect() error {
	err := mc.client.Disconnect(context.Background())
	if err != nil {
		return err
	}
	mc.col = nil
	mc.client = nil
	mc.dbName = ""
	mc.colName = ""
	return nil
}