package db

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"go.mongodb.org/mongo-driver/mongo/readpref"
	"go.mongodb.org/mongo-driver/x/bsonx"
	"pro2d/conf"
	"strconv"
	"time"
)
type Database struct {
	Mongo  *mongo.Database
}

//初始化
func (db *Database)Connect(conf *conf.MongoConf) error {
	var uri string
	if conf.User!= "" {
		uri = fmt.Sprintf("mongodb://%s:%s@%s:%d/%s?w=majority", conf.User, conf.Password, conf.Host, conf.Port, conf.DBName)
	}else {
		uri = fmt.Sprintf("mongodb://%s:%d/%s?w=majority", conf.Host, conf.Port, conf.DBName)
	}
	// 设置连接超时时间
	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(conf.TimeOut))
	defer cancel()
	// 通过传进来的uri连接相关的配置
	o := options.Client().ApplyURI(uri)
	// 设置最大连接数 - 默认是100 ，不设置就是最大 max 64
	o.SetMaxPoolSize(uint64(conf.MaxNum))
	// 发起链接
	client, err := mongo.Connect(ctx, o)
	if err != nil {
		fmt.Println("ConnectToDB", err)
		return err
	}
	// 判断服务是不是可用
	if err = client.Ping(context.Background(), readpref.Primary()); err != nil {
		fmt.Println("ConnectToDB", err)
		return err
	}

	db.Mongo = client.Database(conf.DBName)
	return nil
}

type MgoPool struct {
	mgo *mongo.Database

	collection string
}

func GetBsonD(key string, value interface{}) interface{} {
	return bson.D{ {key, value}}
}
func GetBsonM(key string, value interface{}) interface{}  {
	return bson.M{key: value}
}

func NewMongoPool(mgo *Database, collection string)*MgoPool {
	return &MgoPool{
		mgo:        mgo.Mongo,
		collection: collection,
	}
}

func (m *MgoPool)SetDatabase(databases string)  {
	//m.db = databases
}
func (m *MgoPool)SetCollect(coll string)  {
	m.collection = coll
}


//func  (m *MgoPool)Insert(coll string, buffer interface{}) error {
//	_, err := m.mgo.Collection(coll).InsertOne(context.TODO(), buffer)
//	if err != nil {
//		fmt.Println(err)
//	}
//	return err
//}

//func (m *MgoPool)FindOne(coll string, filter interface{}) (interface{}, error){
//	findOptions := options.FindOne()
//	cur := m.MongoDBClient.Collection(coll).FindOne(context.TODO(), filter, findOptions)
//	var role interface{}
//	if err := cur.Decode(role); err != nil {
//		return nil, err
//	}
//	return role, nil
//}
// 查询单个
func (m *MgoPool) FindOneKV(key string, value interface{}) *mongo.SingleResult {
	collection := m.mgo.Collection(m.collection)
	//collection.
	filter := bson.D{ {key, value}}
	singleResult := collection.FindOne(context.TODO(), filter)
	return singleResult
}

func (m *MgoPool) FindOne(pri interface{}) *mongo.SingleResult {
	collection := m.mgo.Collection(m.collection)
	//collection.
	singleResult := collection.FindOne(context.TODO(), pri)
	return singleResult
}

//插入单个
func (m *MgoPool) InsertOne(value interface{}) *mongo.InsertOneResult {
	collection := m.mgo.Collection(m.collection)
	insertResult, err := collection.InsertOne(context.TODO(), value)
	if err != nil {
		fmt.Println(err)
	}
	return insertResult
}

//查询集合里有多少数据
func (m *MgoPool) CollectionCount() (string, int64) {
	collection := m.mgo.Collection(m.collection)
	name := collection.Name()
	size, _ := collection.EstimatedDocumentCount(context.TODO())
	return name, size
}

//按选项查询集合 Skip 跳过 Limit 读取数量 sort 1 ，-1 . 1 为最初时间读取 ， -1 为最新时间读取
func (m *MgoPool) CollectionDocuments(Skip, Limit int64, sort int) *mongo.Cursor {
	collection := m.mgo.Collection(m.collection)
	SORT := bson.D{
		{"_id", sort}} //filter := bson.D{ {key,value}}
	filter := bson.D{
	{}}
	findOptions := options.Find().SetSort(SORT).SetLimit(Limit).SetSkip(Skip)
	//findOptions.SetLimit(i)
	temp, _ := collection.Find(context.Background(), filter, findOptions)
	return temp
}

//获取集合创建时间和编号
func (m *MgoPool) ParsingId(result string) (time.Time, uint64) {
	temp1 := result[:8]
	timestamp, _ := strconv.ParseInt(temp1, 16, 64)
	dateTime := time.Unix(timestamp, 0) //这是截获情报时间 时间格式 2019-04-24 09:23:39 +0800 CST
	temp2 := result[18:]
	count, _ := strconv.ParseUint(temp2, 16, 64) //截获情报的编号
	return dateTime, count
}

//删除文章和查询文章
func (m *MgoPool) DeleteAndFind(key string, value interface{}) (int64, *mongo.SingleResult) {
	collection := m.mgo.Collection(m.collection)
	filter := bson.D{
		{key, value}}
	singleResult := collection.FindOne(context.TODO(), filter)
	DeleteResult, err := collection.DeleteOne(context.TODO(), filter, nil)
	if err != nil {
		fmt.Println("删除时出现错误，你删不掉的~")
	}
	return DeleteResult.DeletedCount, singleResult
}

//删除文章
func (m *MgoPool) Delete(key string, value interface{}) int64 {
	collection := m.mgo.Collection(m.collection)
	filter := bson.D{ {key, value}}
	count, err := collection.DeleteOne(context.TODO(), filter, nil)
	if err != nil {
		fmt.Println(err)
	}
	return count.DeletedCount

}

//删除多个
func (m *MgoPool) DeleteMany(key string, value interface{}) int64 {
	collection := m.mgo.Collection(m.collection)
	filter := bson.D{ {key, value}}

	count, err := collection.DeleteMany(context.TODO(), filter)
	if err != nil {
		fmt.Println(err)
	}
	return count.DeletedCount
}

//索引
func (m *MgoPool) Index(key string){
	collection := m.mgo.Collection(m.collection)
	collection.Indexes().CreateOne(
		context.Background(),
		mongo.IndexModel{
			Keys   : bsonx.Doc{{key, bsonx.Int32(1)}},
			Options: options.Index().SetUnique(true),
		},
	)
}

//更新&保存
func (m *MgoPool) FindOneAndUpdate(filter interface{}, update interface{})*mongo.SingleResult {
	//filter := bson.M{"name": "x", "array.name": "b"}
	//update := bson.M{"array.$[item].detail": "test"}

	collection := m.mgo.Collection(m.collection)
	res := collection.FindOneAndUpdate(context.Background(),
		filter,
		bson.M{"$set": update})
	if res.Err() != nil {
		return nil
	}
	return res
}

func (m *MgoPool) UpdateOne(filter interface{}, update interface{})*mongo.UpdateResult {
	collection := m.mgo.Collection(m.collection)
	res, err := collection.UpdateOne(context.TODO(), filter, update)
	if err != nil {
		return nil
	}

	return res
}