package helper

import (
	"context"
	"fmt"
	"reflect"

	"gitee.com/ktcatv/mgohelper/abstr"
	"gitee.com/ktcatv/mgohelper/session"
	"github.com/go-chassis/openlog"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

const (
	MsgFindFailed    = "find failed, deadline exceeded"
	FmtErrFindFailed = "can not find in %ss"
)

func aggreagte(ctx context.Context, collname string, pipeline []map[string]interface{}) (*mongo.Cursor, error) {
	return session.GetDB().Collection(collname).Aggregate(ctx, pipeline)
}

func countDocuments(ctx context.Context, collname string, filter interface{}) (int64, error) {
	return session.GetDB().Collection(collname).CountDocuments(ctx, filter)
}

func createOne(ctx context.Context, coll string, rec interface{}) error {
	var err error
	collection := session.GetDB().Collection(coll)
	_, err = collection.InsertOne(ctx, rec)
	if err != nil {
		openlog.Error("create error", openlog.WithTags(openlog.Tags{
			"err": err.Error(),
			"rec": rec,
		}))
		return err
	}
	openlog.Debug(fmt.Sprintf("create %s value [%s]", reflect.TypeOf(rec).Name(), rec))
	return err
}

func createMany(ctx context.Context, coll string, recs ...interface{}) error {
	var err error
	collection := session.GetDB().Collection(coll)
	_, err = collection.InsertMany(ctx, recs)
	if err != nil {
		openlog.Error("create error", openlog.WithTags(openlog.Tags{
			"err": err.Error(),
			"rec": recs,
		}))
		return err
	}
	return nil
}

func findOne(ctx context.Context, coll string, opts abstr.FindOptions) *mongo.SingleResult {
	collection := session.GetDB().Collection(coll)
	opt := &options.FindOneOptions{}
	opt = opt.SetSort(opts.Sort)
	opt.SetProjection(opt.Projection)
	result := collection.FindOne(ctx, opts.Filters, opt)
	return result
}

func findOneAndDelete(ctx context.Context, coll string, filter map[string]interface{}, opts abstr.FindOptions) *mongo.SingleResult {
	collection := session.GetDB().Collection(coll)
	opt := &options.FindOneAndDeleteOptions{}
	result := collection.FindOneAndDelete(ctx, filter, opt)
	return result
}

func find(ctx context.Context, coll string, opts abstr.FindOptions) (*mongo.Cursor, int64, error) {
	collection := session.GetDB().Collection(coll)
	ctx, _ = context.WithTimeout(ctx, opts.Timeout)
	opt := options.Find()
	if opts.Offset != 0 {
		opt = opt.SetSkip(opts.Offset)
	}
	if opts.Limit != 0 {
		opt = opt.SetLimit(opts.Limit)
	}
	if opts.Sort != nil {
		opt = opt.SetSort(opts.Sort)
	}
	opt = opt.SetProjection(opts.Projection)
	curTotal, err := collection.CountDocuments(ctx, opts.Filters)
	if err != nil {
		if err.Error() == context.DeadlineExceeded.Error() {
			openlog.Error(MsgFindFailed, openlog.WithTags(openlog.Tags{
				"timeout": opts.Timeout,
			}))
			return nil, 0, fmt.Errorf(FmtErrFindFailed, opts.Timeout)
		}
		return nil, 0, err
	}

	cur, err := collection.Find(ctx, opts.Filters, opt)
	if err != nil {
		if err.Error() == context.DeadlineExceeded.Error() {
			openlog.Error(MsgFindFailed, openlog.WithTags(openlog.Tags{
				"timeout": opts.Timeout,
			}))
			return nil, 0, fmt.Errorf(FmtErrFindFailed, opts.Timeout)
		}
		return nil, 0, err
	}
	return cur, curTotal, err
}

func pull(ctx context.Context, collname string, filter map[string]interface{}, value interface{}) (*mongo.UpdateResult, error) {
	collection := session.GetDB().Collection(collname)
	opt := &options.UpdateOptions{}
	var v map[string]interface{} = map[string]interface{}{"$pull": value}
	result, err := collection.UpdateOne(ctx, filter, v, opt)
	return result, err
}

func removeMany(ctx context.Context, collname string, filter map[string]interface{}) (*mongo.DeleteResult, error) {
	collection := session.GetDB().Collection(collname)
	opt := &options.DeleteOptions{}
	result, err := collection.DeleteMany(ctx, filter, opt)
	return result, err
}

func unmark(ctx context.Context, collname string, filter map[string]interface{}, value interface{}) (*mongo.UpdateResult, error) {
	collection := session.GetDB().Collection(collname)
	opt := &options.UpdateOptions{}
	var v map[string]interface{} = map[string]interface{}{"$unset": value}
	result, err := collection.UpdateOne(ctx, filter, v, opt)
	return result, err
}

func updateOne(ctx context.Context, collname string, filter map[string]interface{}, value interface{}) (*mongo.UpdateResult, error) {
	collection := session.GetDB().Collection(collname)
	opt := &options.UpdateOptions{}
	var v map[string]interface{} = map[string]interface{}{"$set": value}
	result, err := collection.UpdateOne(ctx, filter, v, opt)
	return result, err
}

func updateOneMore(ctx context.Context, collname string, filter map[string]interface{}, value interface{}) (*mongo.UpdateResult, error) {
	collection := session.GetDB().Collection(collname)
	opt := &options.UpdateOptions{}
	result, err := collection.UpdateOne(ctx, filter, value, opt)
	return result, err
}