type Pool struct {
	Config
	// 創(chuàng)建對象
	newObject func() (any, error)
	// 釋放對象
	freeObject func(x any)
	// 空閑對象池
	idles chan any
	mu          sync.Mutex
	activeCount int// 已經(jīng)創(chuàng)建的對象個數(shù)
	waiting     []chan any // 阻塞等待
	closed bool// 是否已關(guān)閉
}
func NewPool(new func() (any, error), free func(x any), conf Config) *Pool {
	ifnew == nil {
		logger.Error("NewPool argument new func is nil")
		returnnil
	}
	if free == nil {
		free = func(x any) {}
	}
	p := Pool{
		Config:      conf,
		newObject:   new,
		freeObject:  free,
		activeCount: 0,
		closed:      false,
	}
	p.idles = make(chan any, p.MaxIdles)
	return &p
}

func (p *Pool) Get() (any, error) {
	p.mu.Lock()
	if p.closed {
		p.mu.Unlock()
		returnnil, ErrClosed
	}
	select {
	case x := <-p.idles: // 從空閑中獲取
		p.mu.Unlock() // 解鎖
		return x, nil
	default:
		return p.getOne() // 獲取一個新的
	}
}
func (p *Pool) getOne() (any, error) {
	// 說明已經(jīng)創(chuàng)建了太多對象
	if p.activeCount >= p.Config.MaxActive {
		wait := make(chan any, 1)
		p.waiting = append(p.waiting, wait)
		p.mu.Unlock()
		// 阻塞等待
		x, ok := <-wait
		if !ok {
			returnnil, ErrClosed
		}
		return x, nil
	}
	p.activeCount++
	p.mu.Unlock()
	// 創(chuàng)建新對象
	x, err := p.newObject()
	if err != nil {
		p.mu.Lock()
		p.activeCount--
		p.mu.Unlock()
		returnnil, err
	}
	return x, nil
}

func (p *Pool) Put(x any) {
	p.mu.Lock()
	if p.closed {
		p.mu.Unlock()
		p.freeObject(x) // 直接釋放
		return
	}

	//1.先判斷等待中
	iflen(p.waiting) > 0 {
		// 彈出一個（從頭部）
		wait := p.waiting[0]
		temp := make([]chan any, len(p.waiting)-1)
		copy(temp, p.waiting[1:])
		p.waiting = temp
		wait <- x // 取消阻塞
		p.mu.Unlock()
		return

	}
	// 2.直接放回空閑緩沖
	select {
	case p.idles <- x:
		p.mu.Unlock()
	default: // 說明空閑已滿
		p.activeCount-- // 對象個數(shù)-1
		p.mu.Unlock()
		p.freeObject(x) // 釋放
	}

}

type RedisConnPool struct {
	connDict *dict.ConcurrentDict // addr -> *pool.Pool
}
func NewRedisConnPool() *RedisConnPool {
	return &RedisConnPool{
		connDict: dict.NewConcurrentDict(16),
	}
}
func (r *RedisConnPool) GetConn(addr string) (*client.RedisClent, error) {
	var connectionPool *pool.Pool // 對象池
	// 通過不同的地址addr，獲取不同的對象池
	raw, ok := r.connDict.Get(addr)
	if ok {
		connectionPool = raw.(*pool.Pool)
	} else {
		// 創(chuàng)建對象函數(shù)
		newClient := func() (any, error) {
			// redis的客戶端連接
			cli, err := client.NewRedisClient(addr)
			if err != nil {
				returnnil, err
			}
			// 啟動
			cli.Start()
			if conf.GlobalConfig.RequirePass != "" { // 說明服務(wù)需要密碼
				reply, err := cli.Send(aof.Auth([]byte(conf.GlobalConfig.RequirePass)))
				if err != nil {
					returnnil, err
				}
				if !protocol.IsOKReply(reply) {
					returnnil, errors.New("auth failed:" + string(reply.ToBytes()))
				}
				return cli, nil
			}
			return cli, nil
		}
		// 釋放對象函數(shù)
		freeClient := func(x any) {
			cli, ok := x.(*client.RedisClent)
			if ok {
				cli.Stop() // 釋放
			}
		}
		// 針對addr地址，創(chuàng)建一個新的對象池
		connectionPool = pool.NewPool(newClient, freeClient, pool.Config{
			MaxIdles:  1,
			MaxActive: 20,
		})
		// addr -> *pool.Pool
		r.connDict.Put(addr, connectionPool)
	}
	// 從對象池中獲取一個對象
	raw, err := connectionPool.Get()
	if err != nil {
		returnnil, err
	}
	conn, ok := raw.(*client.RedisClent)
	if !ok {
		returnnil, errors.New("connection pool make wrong type")
	}
	return conn, nil
}
func (r *RedisConnPool) ReturnConn(peer string, cli *client.RedisClent) error {
	raw, ok := r.connDict.Get(peer)
	if !ok {
		return errors.New("connection pool not found")
	}
	raw.(*pool.Pool).Put(cli)
	returnnil
}