package mongodb

// 使用连接池
import (
    "context"
    "fmt"
    "log"
    "sync"

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

const (
    maxConnections = 30 // 最大连接数
)

var (
    connectionPool chan *mongo.Client
    poolMutex      sync.Mutex
)

// 初始化连接池
func InitConnectionPool() error {
    poolMutex.Lock()
    defer poolMutex.Unlock()

    if connectionPool != nil {
        return fmt.Errorf("连接池已初始化")
    }

    connectionPool = make(chan *mongo.Client, maxConnections)

    for i := 0; i < maxConnections; i++ {
        client, err := CreateMongoClient()
        if err != nil {
            return err
        }
        // 创建出的连接缓存在通道中
        connectionPool <- client
    }

    return nil
}

// 创建新的 MongoDB 连接
func CreateMongoClient() (*mongo.Client, error) {
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")

    ctx := context.TODO()
    client, err := mongo.Connect(ctx, clientOptions)
    if err != nil {
        return nil, err
    }

    return client, nil
}

// 获取 MongoDB 连接
func GetMongoClientFromPool() (*mongo.Client, error) {
    select {
    // TODO 从缓存通道获取连接
    case client := <-connectionPool:
        return client, nil
    default:
        return nil, fmt.Errorf("连接池已满")
    }
}

// 释放 MongoDB 连接回连接池
func ReleaseMongoClientToPool(client *mongo.Client) {
    connectionPool <- client
}

// 使用连接池执行 MongoDB 操作
func GetMongodbConnection() (*mongo.Client, *mongo.Collection) {
    // 初始化
    InitErr := InitConnectionPool()
    if InitErr != nil {
        log.Fatal(InitErr)
    }

    // 从连接池获取连接使用
    client, err := GetMongoClientFromPool()
    if err != nil {
        log.Fatal(err)
    }

    // 操作指定的数据表
    collection := client.Database("dbname").Collection("collection")

    return client, collection

}