package mongo

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
	"matchmaking-system/internal/conf"
)

// NewMongodb
//
//	@Description:
//	@param c
//	@return *mongo.Client
func NewMongodb(c *conf.Data) *mongo.Client {
	mongodb := c.Mongodb.Db
	urlStr := fmt.Sprintf("mongodb://%v:%v@%v/%v?ssl=false&authSource=admin", c.Mongodb.User, c.Mongodb.Password, c.Mongodb.Addr, mongodb)
	clientOptions := options.Client().ApplyURI(urlStr)
	client, err := mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		panic(err)
	}
	// Check the connection
	err = client.Ping(context.TODO(), nil)
	if err != nil {
		panic(err)
	}

	return &mongo.Client{}
}

// mgoConnect
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@return *mongo.Collection
func mgoConnect(mgoDb *mongo.Client, DataBase string, collection string) *mongo.Collection {
	return mgoDb.Database(DataBase).Collection(collection)
}

// MgoConnect
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@return *mongo.Collection
func MgoConnect(mgoDb *mongo.Client, DataBase string, collection string) *mongo.Collection {
	return mgoConnect(mgoDb, DataBase, collection)
}

// MgoInsertOne
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@param docs
//	@return error
func MgoInsertOne(mgoDb *mongo.Client, DataBase string, collection string, docs interface{}) error {
	c := mgoConnect(mgoDb, DataBase, collection)
	if _, err := c.InsertOne(context.TODO(), docs); err != nil {
		return err
	}

	return nil
}

// MgoInsertMany
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@param docs
//	@return error
func MgoInsertMany(mgoDb *mongo.Client, DataBase string, collection string, docs []interface{}) error {
	c := mgoConnect(mgoDb, DataBase, collection)
	if _, err := c.InsertMany(context.TODO(), docs); err != nil {
		return err
	}

	return nil
}

// MgoUpdateID
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@param id
//	@param update
//	@return error
func MgoUpdateID(mgoDb *mongo.Client, DataBase string, collection string, id interface{}, update interface{}) error {
	c := mgoConnect(mgoDb, DataBase, collection)
	if _, err := c.UpdateByID(context.TODO(), id, update); err != nil {
		return err
	}

	return nil
}

// MgoUpdateOne
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@param filter
//	@param update
//	@return error
func MgoUpdateOne(mgoDb *mongo.Client, DataBase string, collection string, filter interface{}, update interface{}) error {
	c := mgoConnect(mgoDb, DataBase, collection)
	if _, err := c.UpdateOne(context.TODO(), filter, update); err != nil {
		return err
	}

	return nil
}

// MgoUpdateMany
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@param filter
//	@param update
//	@return error
func MgoUpdateMany(mgoDb *mongo.Client, DataBase string, collection string, filter interface{}, update []interface{}) error {
	c := mgoConnect(mgoDb, DataBase, collection)
	if _, err := c.UpdateMany(context.TODO(), filter, update); err != nil {
		return err
	}

	return nil
}

// MgoBulkWrite
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@param models
//	@return error
func MgoBulkWrite(mgoDb *mongo.Client, DataBase string, collection string, models []mongo.WriteModel) error {
	c := mgoConnect(mgoDb, DataBase, collection)
	_, err := c.BulkWrite(context.TODO(), models)

	if err != nil {
		return err
	}

	return err
}

// MgoIsExist
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@param filter
//	@return bool
func MgoIsExist(mgoDb *mongo.Client, DataBase string, collection string, filter interface{}) bool {
	c := mgoConnect(mgoDb, DataBase, collection)
	cur, err := c.Find(context.TODO(), filter)
	if err != nil {
		return false
	}

	var numDocs int
	for cur.Next(context.Background()) {
		numDocs++
	}

	return numDocs > 0
}

// MgoFind
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@param filter
//	@return interface{}
//	@return error
func MgoFind(mgoDb *mongo.Client, DataBase string, collection string, filter interface{}) (interface{}, error) {
	c := mgoConnect(mgoDb, DataBase, collection)
	cursor, err := c.Find(context.TODO(), filter)
	if err != nil {
		return nil, err
	}
	var results []bson.M
	if err = cursor.All(context.TODO(), &results); err != nil {
		log.Fatal(err)
	}

	return results, nil
}

// MgoFindOne
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@param filter
//	@return bson.D
//	@return error
func MgoFindOne(mgoDb *mongo.Client, DataBase string, collection string, filter interface{}) (bson.D, error) {
	c := mgoConnect(mgoDb, DataBase, collection)
	cur := c.FindOne(context.TODO(), filter)
	var res bson.D
	if err := cur.Decode(&res); err != nil {
		return nil, err
	}

	return res, nil
}

// MgoFindAll
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@param filter
//	@return interface{}
//	@return error
func MgoFindAll(mgoDb *mongo.Client, DataBase string, collection string, filter interface{}) (interface{}, error) {
	c := mgoConnect(mgoDb, DataBase, collection)
	cur, err := c.Find(context.TODO(), filter)
	if err != nil {
		return nil, err
	}
	var res interface{}
	if err := cur.All(context.TODO(), &res); err != nil {
		return nil, err
	}

	return res, err
}

// MgoDeleteOne
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@param filter
//	@return error
func MgoDeleteOne(mgoDb *mongo.Client, DataBase string, collection string, filter interface{}) error {
	c := mgoConnect(mgoDb, DataBase, collection)
	_, err := c.DeleteOne(context.TODO(), filter)
	if err != nil {
		return err
	}

	return nil
}

// MgoDeleteMany
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@param filter
//	@return error
func MgoDeleteMany(mgoDb *mongo.Client, DataBase string, collection string, filter interface{}) error {
	c := mgoConnect(mgoDb, DataBase, collection)
	_, err := c.DeleteMany(context.TODO(), filter)
	if err != nil {
		return err
	}

	return nil
}

// MgoPagingFind
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@param filter
//	@param limit
//	@param page
//	@param sort
//	@return []bson.M
//	@return error
func MgoPagingFind(mgoDb *mongo.Client, DataBase string, collection string, filter interface{}, limit, page int64, sort int) ([]bson.M, error) {
	c := mgoConnect(mgoDb, DataBase, collection)

	var optionStr *options.FindOptions
	if sort != 0 {
		optionStr = options.Find().SetLimit(limit).SetSkip((limit * page) - limit).SetSort(bson.M{"Code": sort})
	} else {
		optionStr = options.Find().SetLimit(limit).SetSkip((limit * page) - limit)
	}

	cur, err := c.Find(context.Background(), filter, optionStr)
	if err != nil {
		return nil, err
	}

	var results []bson.M
	if err = cur.All(context.TODO(), &results); err != nil {
		log.Fatal(err)
	}

	return results, err
}

// MgoFindTotal
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@param filter
//	@return int64
//	@return error
func MgoFindTotal(mgoDb *mongo.Client, DataBase string, collection string, filter interface{}) (int64, error) {
	c := mgoConnect(mgoDb, DataBase, collection)

	total, err := c.CountDocuments(context.TODO(), filter)
	if err != nil {
		return 0, err
	}

	return total, nil
}

// MgoAggregate
//
//	@Description:
//	@param mgoDb
//	@param DataBase
//	@param collection
//	@param filter
//	@return interface{}
//	@return error
func MgoAggregate(mgoDb *mongo.Client, DataBase string, collection string, filter mongo.Pipeline) (interface{}, error) {
	c := mgoConnect(mgoDb, DataBase, collection)

	aggregate, err := c.Aggregate(context.TODO(), filter)
	if err != nil {
		return 0, err
	}

	var showsWithInfo []map[string]interface{}
	if err = aggregate.All(context.TODO(), &showsWithInfo); err != nil {
		log.Printf("collection %s", err)
		panic(err)
	}

	return showsWithInfo, nil
}