var touchScript = `
    if redis.call("GET", KEYS[1]) == ARGV[1] then
        return redis.call("PEXPIRE", KEYS[1], ARGV[2])
    else
        return 0
    end
`

package rmutex

import (
    "crypto/rand"
    "encoding/base64"
    "fmt"
)

const (
    minRetryDelayMilliSec = 50
    maxRetryDelayMilliSec = 250
)

func genValue() string {
    b := make([]byte, 16)
    _, err := rand.Read(b)
    if err != nil {
        return ""
    }
    result := base64.StdEncoding.EncodeToString(b)
    fmt.Println(result)
    return result
}

var deleteScript = `
    if redis.call("GET", KEYS[1]) == ARGV[1] then
        return redis.call("DEL", KEYS[1])
    else
        return 0
    end
`

var touchScript = `
    if redis.call("GET", KEYS[1]) == ARGV[1] then
        return redis.call("PEXPIRE", KEYS[1], ARGV[2])
    else
        return 0
    end
`

package rmutex

import (
    "errors"
    "fmt"
)

// ErrFailed 获取锁失败，且用掉所有重试次数
var ErrFailed = errors.New("rmutex: failed to acquire lock")

// ErrExtendFailed 无法延长锁的持有时间
var ErrExtendFailed = errors.New("rmutex: failed to extend lock")

// ErrTaken happens when the lock is already taken in a quorum on nodes.
type ErrTaken struct {
    Nodes []int
}

func (err ErrTaken) Error() string {
    return fmt.Sprintf("lock already taken, locked nodes: %v", err.Nodes)
}

// ErrNodeTaken is the error resulting if the lock is already taken in one of
// the cluster's nodes
type ErrNodeTaken struct {
    Node int
}

func (err ErrNodeTaken) Error() string {
    return fmt.Sprintf("node #%d: lock already taken", err.Node)
}

// A RedisError is an error communicating with one of the Redis nodes.
type RedisError struct {
    Node int
    Err  error
}

func (err RedisError) Error() string {
    return fmt.Sprintf("node #%d: %s", err.Node, err.Err)
}

package rmutex

import (
    "context"
    "errors"
    "math/rand"
    "time"

    "github.com/redis/go-redis/v9"
)

type DelayFunc func(tries int) time.Duration

type Mutex struct {
    name   string
    expiry time.Duration

    tries     int
    delayFunc DelayFunc

    genValueFunc func() string
    value        string
    until        time.Time

    quorum int

    driftFactor   float64
    timeoutFactor float64

    clients []*redis.Client // Redis客户端
}

func NewMutex(name string, clients []*redis.Client, expiry time.Duration, tries int, genValueFunc func() string) *Mutex {
    m := &Mutex{
        name:   name,
        expiry: expiry,
        tries:  tries,
        delayFunc: func(tries int) time.Duration {
            source := (maxRetryDelayMilliSec - minRetryDelayMilliSec) + minRetryDelayMilliSec
            return time.Duration(rand.Intn(source)) * time.Millisecond
        },
        genValueFunc:  genValueFunc,
        value:         "",
        until:         time.Time{},
        quorum:        len(clients)/2 + 1,
        driftFactor:   0.01,
        timeoutFactor: 0.05,
        clients:       clients,
    }

    if genValueFunc != nil {
        m.genValueFunc = genValueFunc
    } else {
        m.genValueFunc = genValue
    }

    m.value = m.genValueFunc()

    return m
}

func (m *Mutex) Name() string {
    return m.name
}

func (m *Mutex) Value() string {
    return m.value
}

func (m *Mutex) Until() time.Time {
    return m.until
}

func (m *Mutex) Lock() error {
    return m.LockContext(context.Background())
}

func (m *Mutex) LockContext(ctx context.Context) error {
    if ctx == nil {
        ctx = context.Background()
    }

    for i := 0; i < m.tries; i++ {
        if i != 0 {
            select {
            case <-ctx.Done():
                // Exit early if the context is done.
                return ErrFailed
            case <-time.After(m.delayFunc(i)):
                // Fall-through when the delay timer completes.
            }
        }

        start := time.Now()

        n, err := func() (int, error) {
            ctx, cancel := context.WithTimeout(ctx, time.Duration(int64(float64(m.expiry)*m.timeoutFactor)))
            defer cancel()
            return m.actOnPoolsAsync(func(client *redis.Client) (bool, error) {
                return m.acquire(ctx, client)
            })
        }()

        now := time.Now()
        until := now.Add(m.expiry - now.Sub(start) - time.Duration(int64(float64(m.expiry)*m.driftFactor)))
        if n >= m.quorum && now.Before(until) {
            m.until = until
            return nil
        }

        func() (int, error) {
            ctx, cancel := context.WithTimeout(ctx, time.Duration(int64(float64(m.expiry)*m.timeoutFactor)))
            defer cancel()
            return m.actOnPoolsAsync(func(client *redis.Client) (bool, error) {
                return m.release(ctx, client)
            })
        }()
        if i == m.tries-1 && err != nil {
            return err
        }
    }

    return ErrFailed
}

func (m *Mutex) acquire(ctx context.Context, client *redis.Client) (bool, error) {
    reply, err := client.SetNX(ctx, m.name, m.value, m.expiry).Result()
    if err != nil {
        return false, err
    }
    return reply, nil
}

// Unlock unlocks m and returns the status of unlock.
func (m *Mutex) Unlock() (bool, error) {
    return m.UnlockContext(context.Background())
}

// UnlockContext unlocks m and returns the status of unlock.
func (m *Mutex) UnlockContext(ctx context.Context) (bool, error) {
    n, err := m.actOnPoolsAsync(func(client *redis.Client) (bool, error) {
        return m.release(ctx, client)
    })
    if n < m.quorum {
        return false, err
    }
    return true, nil
}

func (m *Mutex) release(ctx context.Context, client *redis.Client) (bool, error) {
    status, err := client.Eval(ctx, deleteScript, []string{m.name}, m.value).Result()
    if err != nil {
        return false, err
    }
    return status != int64(0), nil
}

func (m *Mutex) Extend() (bool, error) {
    return m.ExtendContext(context.Background())
}

func (m *Mutex) ExtendContext(ctx context.Context) (bool, error) {
    start := time.Now()
    n, err := m.actOnPoolsAsync(func(client *redis.Client) (bool, error) {
        return m.touch(ctx, client, int(m.expiry/time.Millisecond))
    })
    if n < m.quorum {
        return false, err
    }
    now := time.Now()
    until := now.Add(m.expiry - now.Sub(start) - time.Duration(int64(float64(m.expiry)*m.driftFactor)))
    if now.Before(until) {
        m.until = until
        return true, nil
    }
    return false, ErrExtendFailed
}

// Valid returns true if the lock acquired through m is still valid. It may
// also return true erroneously if quorum is achieved during the call and at
// least one node then takes long enough to respond for the lock to expire.
//
// Deprecated: Use Until instead. See https://github.com/go-redsync/redsync/issues/72.
func (m *Mutex) Valid() (bool, error) {
    return m.ValidContext(context.Background())
}

// ValidContext returns true if the lock acquired through m is still valid. It may
// also return true erroneously if quorum is achieved during the call and at
// least one node then takes long enough to respond for the lock to expire.
//
// Deprecated: Use Until instead. See https://github.com/go-redsync/redsync/issues/72.
func (m *Mutex) ValidContext(ctx context.Context) (bool, error) {
    n, err := m.actOnPoolsAsync(func(client *redis.Client) (bool, error) {
        return m.valid(ctx, client)
    })
    return n >= m.quorum, err
}

func (m *Mutex) valid(ctx context.Context, client *redis.Client) (bool, error) {
    reply, err := client.Get(ctx, m.name).Result()
    if err != nil {
        return false, err
    }
    return m.value == reply, nil
}

func (m *Mutex) touch(ctx context.Context, client *redis.Client, expiry int) (bool, error) {
    status, err := client.Eval(ctx, touchScript, []string{m.name}, m.value, expiry).Result()
    if err != nil {
        return false, err
    }
    return status != int64(0), nil
}

func (m *Mutex) actOnPoolsAsync(actFn func(*redis.Client) (bool, error)) (int, error) {
    type result struct {
        Node   int
        Status bool
        Err    error
    }

    ch := make(chan result)
    for node, client := range m.clients {
        go func(node int, client *redis.Client) {
            r := result{Node: node}
            r.Status, r.Err = actFn(client)
            ch <- r
        }(node, client)
    }
    n := 0
    var taken []int
    var err error
    for range m.clients {
        r := <-ch
        if r.Status {
            n++
        } else if r.Err != nil {
            err = errors.Join(err, &RedisError{Node: r.Node, Err: r.Err})
        } else {
            taken = append(taken, r.Node)
            err = errors.Join(err, &ErrNodeTaken{Node: r.Node})
        }
    }

    if len(taken) >= m.quorum {
        return n, &ErrTaken{Nodes: taken}
    }
    return n, err
}