//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.jeecg.modules.doc.component;

import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import javax.annotation.Resource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.connection.ReturnType;
import org.springframework.data.redis.connection.RedisStringCommands.SetOption;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.stereotype.Component;

@Component
public class RedisLock {
    private static final Logger log = LoggerFactory.getLogger(RedisLock.class);
    private static final int DEFAULT_ACQUIRE_RESOLUTION_MILLIS = 100;
    private static final String UNLOCK_LUA;
    private static final long LOCK_EXPIRE_TIME = 300L;
    @Resource
    RedisTemplate<String, Object> redisTemplate;
    private final ThreadLocal<Map<String, LockVO>> lockMap = new ThreadLocal();

    public RedisLock() {
    }

    public void lock(final String key) {
        try {
            this.acquireLock(key, 300L, -1L);
        } catch (Exception var3) {
            throw new RuntimeException("acquire lock exception", var3);
        }
    }

    public void unlock(String key) {
        try {
            this.release(key);
        } catch (Exception var3) {
            throw new RuntimeException("release lock exception", var3);
        }
    }

    public boolean tryLock(final String key) {
        try {
            return this.acquireLock(key, 300L, -1L);
        } catch (Exception var3) {
            throw new RuntimeException("acquire lock exception", var3);
        }
    }

    public boolean tryLock(String key, long time, TimeUnit unit) {
        try {
            return this.acquireLock(key, 300L, unit.toSeconds(time));
        } catch (Exception var6) {
            throw new RuntimeException("acquire lock exception", var6);
        }
    }

    private boolean acquireLock(String key, long expire, long waitTime) throws InterruptedException {
        boolean acquired = this.acquired(key);
        if (acquired) {
            return true;
        } else {
            long acquireTime = waitTime == -1L ? -1L : waitTime * 1000L + System.currentTimeMillis();
            synchronized(key.intern()) {
                String lockId = UUID.randomUUID().toString();

                while(true) {
                    long before = System.currentTimeMillis();
                    boolean hasLock = this.tryLock(key, expire, lockId);
                    if (hasLock) {
                        long after = System.currentTimeMillis();
                        Map<String, LockVO> map = (Map)this.lockMap.get();
                        if (map == null) {
                            map = new HashMap(2);
                            this.lockMap.set(map);
                        }

                        ((Map)map).put(key, new LockVO(1, lockId, expire * 1000L + before, expire * 1000L + after));
                        log.debug("acquire lock {} {} ", key, 1);
                        return true;
                    }

                    Thread.sleep(100L);
                    if (acquireTime != -1L && acquireTime <= System.currentTimeMillis()) {
                        break;
                    }
                }
            }

            log.info("acquire lock {} fail，because timeout ", key);
            return false;
        }
    }

    private void release(String key) {
        Map<String, LockVO> map = (Map)this.lockMap.get();
        if (map != null && map.size() != 0 && map.containsKey(key)) {
            LockVO vo = (LockVO)map.get(key);
            if (vo.afterExpireTime < System.currentTimeMillis()) {
                log.debug("release lock {}, because timeout ", key);
                map.remove(key);
            } else {
                int after = --vo.count;
                log.debug("release lock {} {} ", key, after);
                if (after <= 0) {
                    map.remove(key);
                    RedisCallback<Boolean> callback = (connection) -> {
                        return (Boolean)connection.eval(UNLOCK_LUA.getBytes(StandardCharsets.UTF_8), ReturnType.BOOLEAN, 1, new byte[][]{key.getBytes(StandardCharsets.UTF_8), vo.lockId.getBytes(StandardCharsets.UTF_8)});
                    };
                    this.redisTemplate.execute(callback);
                }
            }
        }
    }

    private boolean tryLock(String key, long expire, String lockId) {
        try {
            RedisCallback<Boolean> callback = (connection) -> {
                return connection.set(key.getBytes(StandardCharsets.UTF_8), lockId.getBytes(StandardCharsets.UTF_8), Expiration.seconds(expire), SetOption.SET_IF_ABSENT);
            };
            return (Boolean)this.redisTemplate.execute(callback);
        } catch (Exception var6) {
            log.error("redis lock error.", var6);
            return false;
        }
    }

    private boolean acquired(String key) {
        Map<String, LockVO> map = (Map)this.lockMap.get();
        if (map != null && map.size() != 0 && map.containsKey(key)) {
            LockVO vo = (LockVO)map.get(key);
            if (vo.beforeExpireTime < System.currentTimeMillis()) {
                log.debug("lock {} maybe release, because timeout ", key);
                return false;
            } else {
                int after = ++vo.count;
                log.debug("acquire lock {} {} ", key, after);
                return true;
            }
        } else {
            return false;
        }
    }

    static {
        StringBuilder lua = new StringBuilder();
        lua.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
        lua.append("then ");
        lua.append("    return redis.call(\"del\",KEYS[1]) ");
        lua.append("else ");
        lua.append("    return 0 ");
        lua.append("end ");
        UNLOCK_LUA = lua.toString();
    }

    private static class LockVO {
        private int count;
        private String lockId;
        private long beforeExpireTime;
        private long afterExpireTime;

        LockVO(int count, String lockId, long beforeExpireTime, long afterExpireTime) {
            this.count = count;
            this.lockId = lockId;
            this.beforeExpireTime = beforeExpireTime;
            this.afterExpireTime = afterExpireTime;
        }
    }
}