"""
Java java.util.concurrent.atomic standard library APIs implemented in Python.
java.util.concurrent.atomic package - AtomicBoolean, AtomicInteger, AtomicLong, etc.
"""

from __future__ import annotations

from .._core import Stub
from ..java.lang import RuntimeException
import threading as _threading
import math as _py_math

__all__ = [
    "AtomicBoolean", "AtomicInteger", "AtomicLong", "AtomicReference",
    "AtomicIntegerArray", "AtomicLongArray", "AtomicReferenceArray",
    "AtomicIntegerFieldUpdater", "AtomicLongFieldUpdater",
    "AtomicReferenceFieldUpdater",
    "AtomicMarkableReference", "AtomicStampedReference",
    "DoubleAccumulator", "DoubleAdder",
    "LongAccumulator", "LongAdder", "Striped64",
]


# ============================================================
# AtomicBoolean
# ============================================================

class AtomicBoolean(Stub):
    """java.util.concurrent.atomic.AtomicBoolean"""
    def __init__(self, initial_value=False):
        super().__init__()
        self._lock = _threading.Lock()
        self._value = bool(initial_value)

    def get(self):
        with self._lock:
            return self._value

    def set(self, new_value):
        with self._lock:
            self._value = bool(new_value)

    def lazySet(self, new_value):
        self.set(new_value)

    def getAndSet(self, new_value):
        with self._lock:
            old = self._value
            self._value = bool(new_value)
            return old

    def compareAndSet(self, expect, update):
        with self._lock:
            if self._value == expect:
                self._value = update
                return True
            return False

    def weakCompareAndSet(self, expect, update):
        return self.compareAndSet(expect, update)

    def toString(self):
        return str(self._value)

    def hashCode(self):
        return hash(self._value)

    def equals(self, other):
        if not isinstance(other, AtomicBoolean):
            return False
        return self._value == other._value


# ============================================================
# AtomicInteger
# ============================================================

class AtomicInteger(Stub):
    """java.util.concurrent.atomic.AtomicInteger"""
    def __init__(self, initial_value=0):
        super().__init__()
        self._lock = _threading.Lock()
        self._value = int(initial_value)

    def get(self):
        with self._lock:
            return self._value

    def set(self, new_value):
        with self._lock:
            self._value = int(new_value)

    def lazySet(self, new_value):
        self.set(new_value)

    def getAndSet(self, new_value):
        with self._lock:
            old = self._value
            self._value = int(new_value)
            return old

    def compareAndSet(self, expect, update):
        with self._lock:
            if self._value == expect:
                self._value = int(update)
                return True
            return False

    def weakCompareAndSet(self, expect, update):
        return self.compareAndSet(expect, update)

    def getAndIncrement(self):
        with self._lock:
            old = self._value
            self._value += 1
            return old

    def getAndDecrement(self):
        with self._lock:
            old = self._value
            self._value -= 1
            return old

    def getAndAdd(self, delta):
        with self._lock:
            old = self._value
            self._value += delta
            return old

    def incrementAndGet(self):
        with self._lock:
            self._value += 1
            return self._value

    def decrementAndGet(self):
        with self._lock:
            self._value -= 1
            return self._value

    def addAndGet(self, delta):
        with self._lock:
            self._value += delta
            return self._value

    def getAndUpdate(self, update_func):
        with self._lock:
            old = self._value
            self._value = update_func.applyAsInt(old)
            return old

    def updateAndGet(self, update_func):
        with self._lock:
            self._value = update_func.applyAsInt(self._value)
            return self._value

    def getAndAccumulate(self, x, accumulator_func):
        with self._lock:
            old = self._value
            self._value = accumulator_func.applyAsInt(old, x)
            return old

    def accumulateAndGet(self, x, accumulator_func):
        with self._lock:
            self._value = accumulator_func.applyAsInt(self._value, x)
            return self._value

    def toString(self):
        return str(self.get())

    def intValue(self):
        return self.get()

    def longValue(self):
        return self.get()

    def floatValue(self):
        return float(self.get())

    def doubleValue(self):
        return float(self.get())

    def hashCode(self):
        return self.get()


# ============================================================
# AtomicLong
# ============================================================

class AtomicLong(Stub):
    """java.util.concurrent.atomic.AtomicLong"""
    def __init__(self, initial_value=0):
        super().__init__()
        self._lock = _threading.Lock()
        self._value = int(initial_value)

    def get(self):
        with self._lock:
            return self._value

    def set(self, new_value):
        with self._lock:
            self._value = int(new_value)

    def lazySet(self, new_value):
        self.set(new_value)

    def getAndSet(self, new_value):
        with self._lock:
            old = self._value
            self._value = int(new_value)
            return old

    def compareAndSet(self, expect, update):
        with self._lock:
            if self._value == expect:
                self._value = int(update)
                return True
            return False

    def weakCompareAndSet(self, expect, update):
        return self.compareAndSet(expect, update)

    def getAndIncrement(self):
        with self._lock:
            old = self._value
            self._value += 1
            return old

    def getAndDecrement(self):
        with self._lock:
            old = self._value
            self._value -= 1
            return old

    def getAndAdd(self, delta):
        with self._lock:
            old = self._value
            self._value += delta
            return old

    def incrementAndGet(self):
        with self._lock:
            self._value += 1
            return self._value

    def decrementAndGet(self):
        with self._lock:
            self._value -= 1
            return self._value

    def addAndGet(self, delta):
        with self._lock:
            self._value += delta
            return self._value

    def getAndUpdate(self, update_func):
        with self._lock:
            old = self._value
            self._value = update_func.applyAsLong(old)
            return old

    def updateAndGet(self, update_func):
        with self._lock:
            self._value = update_func.applyAsLong(self._value)
            return self._value

    def getAndAccumulate(self, x, accumulator_func):
        with self._lock:
            old = self._value
            self._value = accumulator_func.applyAsLong(old, x)
            return old

    def accumulateAndGet(self, x, accumulator_func):
        with self._lock:
            self._value = accumulator_func.applyAsLong(self._value, x)
            return self._value

    def toString(self):
        return str(self.get())

    def intValue(self):
        return int(self.get())

    def longValue(self):
        return self.get()

    def floatValue(self):
        return float(self.get())

    def doubleValue(self):
        return float(self.get())

    def hashCode(self):
        return hash(self.get())


# ============================================================
# AtomicReference
# ============================================================

class AtomicReference(Stub):
    """java.util.concurrent.atomic.AtomicReference"""
    def __init__(self, initial_value=None):
        super().__init__()
        self._lock = _threading.Lock()
        self._value = initial_value

    def get(self):
        with self._lock:
            return self._value

    def set(self, new_value):
        with self._lock:
            self._value = new_value

    def lazySet(self, new_value):
        self.set(new_value)

    def getAndSet(self, new_value):
        with self._lock:
            old = self._value
            self._value = new_value
            return old

    def compareAndSet(self, expect, update):
        with self._lock:
            if self._value is expect or (self._value == expect):
                self._value = update
                return True
            return False

    def weakCompareAndSet(self, expect, update):
        return self.compareAndSet(expect, update)

    def getAndUpdate(self, update_func):
        with self._lock:
            old = self._value
            self._value = update_func.apply(old)
            return old

    def updateAndGet(self, update_func):
        with self._lock:
            self._value = update_func.apply(self._value)
            return self._value

    def getAndAccumulate(self, x, accumulator_func):
        with self._lock:
            old = self._value
            self._value = accumulator_func.apply(old, x)
            return old

    def accumulateAndGet(self, x, accumulator_func):
        with self._lock:
            self._value = accumulator_func.apply(self._value, x)
            return self._value

    def toString(self):
        return str(self.get())

    def hashCode(self):
        return hash(self._value)


# ============================================================
# AtomicIntegerArray
# ============================================================

class AtomicIntegerArray(Stub):
    """java.util.concurrent.atomic.AtomicIntegerArray"""
    def __init__(self, length_or_array):
        super().__init__()
        if isinstance(length_or_array, int):
            self._array = [0] * length_or_array
        else:
            self._array = list(length_or_array)
        self._lock = _threading.Lock()

    def length(self):
        return len(self._array)

    def get(self, i):
        with self._lock:
            return self._array[i]

    def set(self, i, new_value):
        with self._lock:
            self._array[i] = int(new_value)

    def lazySet(self, i, new_value):
        self.set(i, new_value)

    def getAndSet(self, i, new_value):
        with self._lock:
            old = self._array[i]
            self._array[i] = int(new_value)
            return old

    def compareAndSet(self, i, expect, update):
        with self._lock:
            if self._array[i] == expect:
                self._array[i] = int(update)
                return True
            return False

    def weakCompareAndSet(self, i, expect, update):
        return self.compareAndSet(i, expect, update)

    def getAndIncrement(self, i):
        with self._lock:
            old = self._array[i]
            self._array[i] += 1
            return old

    def getAndDecrement(self, i):
        with self._lock:
            old = self._array[i]
            self._array[i] -= 1
            return old

    def getAndAdd(self, i, delta):
        with self._lock:
            old = self._array[i]
            self._array[i] += delta
            return old

    def incrementAndGet(self, i):
        with self._lock:
            self._array[i] += 1
            return self._array[i]

    def decrementAndGet(self, i):
        with self._lock:
            self._array[i] -= 1
            return self._array[i]

    def addAndGet(self, i, delta):
        with self._lock:
            self._array[i] += delta
            return self._array[i]

    def toString(self):
        return str(self._array)


# ============================================================
# AtomicLongArray
# ============================================================

class AtomicLongArray(Stub):
    """java.util.concurrent.atomic.AtomicLongArray"""
    def __init__(self, length_or_array):
        super().__init__()
        if isinstance(length_or_array, int):
            self._array = [0] * length_or_array
        else:
            self._array = list(length_or_array)
        self._lock = _threading.Lock()

    def length(self):
        return len(self._array)

    def get(self, i):
        with self._lock:
            return self._array[i]

    def set(self, i, new_value):
        with self._lock:
            self._array[i] = int(new_value)

    def lazySet(self, i, new_value):
        self.set(i, new_value)

    def getAndSet(self, i, new_value):
        with self._lock:
            old = self._array[i]
            self._array[i] = int(new_value)
            return old

    def compareAndSet(self, i, expect, update):
        with self._lock:
            if self._array[i] == expect:
                self._array[i] = int(update)
                return True
            return False

    def weakCompareAndSet(self, i, expect, update):
        return self.compareAndSet(i, expect, update)

    def getAndIncrement(self, i):
        with self._lock:
            old = self._array[i]
            self._array[i] += 1
            return old

    def getAndDecrement(self, i):
        with self._lock:
            old = self._array[i]
            self._array[i] -= 1
            return old

    def getAndAdd(self, i, delta):
        with self._lock:
            old = self._array[i]
            self._array[i] += delta
            return old

    def incrementAndGet(self, i):
        with self._lock:
            self._array[i] += 1
            return self._array[i]

    def decrementAndGet(self, i):
        with self._lock:
            self._array[i] -= 1
            return self._array[i]

    def addAndGet(self, i, delta):
        with self._lock:
            self._array[i] += delta
            return self._array[i]

    def toString(self):
        return str(self._array)


# ============================================================
# AtomicReferenceArray
# ============================================================

class AtomicReferenceArray(Stub):
    """java.util.concurrent.atomic.AtomicReferenceArray"""
    def __init__(self, length_or_array):
        super().__init__()
        if isinstance(length_or_array, int):
            self._array = [None] * length_or_array
        else:
            self._array = list(length_or_array)
        self._lock = _threading.Lock()

    def length(self):
        return len(self._array)

    def get(self, i):
        with self._lock:
            return self._array[i]

    def set(self, i, new_value):
        with self._lock:
            self._array[i] = new_value

    def lazySet(self, i, new_value):
        self.set(i, new_value)

    def getAndSet(self, i, new_value):
        with self._lock:
            old = self._array[i]
            self._array[i] = new_value
            return old

    def compareAndSet(self, i, expect, update):
        with self._lock:
            if self._array[i] is expect or self._array[i] == expect:
                self._array[i] = update
                return True
            return False

    def weakCompareAndSet(self, i, expect, update):
        return self.compareAndSet(i, expect, update)

    def toString(self):
        return str(self._array)


# ============================================================
# AtomicMarkableReference
# ============================================================

class AtomicMarkableReference(Stub):
    """java.util.concurrent.atomic.AtomicMarkableReference"""
    def __init__(self, initial_ref, initial_mark):
        super().__init__()
        self._lock = _threading.Lock()
        self._reference = initial_ref
        self._mark = bool(initial_mark)

    def getReference(self):
        with self._lock:
            return self._reference

    def isMarked(self):
        with self._lock:
            return self._mark

    def get(self):
        with self._lock:
            return [self._reference, self._mark]

    def attemptMark(self, expected_reference, new_mark):
        with self._lock:
            if self._reference is expected_reference or self._reference == expected_reference:
                self._mark = bool(new_mark)
                return True
            return False

    def compareAndSet(self, expected_reference, new_reference,
                      expected_mark, new_mark):
        with self._lock:
            if (self._reference is expected_reference or self._reference == expected_reference):
                if self._mark == expected_mark:
                    self._reference = new_reference
                    self._mark = bool(new_mark)
                    return True
            return False

    def weakCompareAndSet(self, expected_reference, new_reference,
                          expected_mark, new_mark):
        return self.compareAndSet(expected_reference, new_reference,
                                  expected_mark, new_mark)


# ============================================================
# AtomicStampedReference
# ============================================================

class AtomicStampedReference(Stub):
    """java.util.concurrent.atomic.AtomicStampedReference"""
    def __init__(self, initial_ref, initial_stamp):
        super().__init__()
        self._lock = _threading.Lock()
        self._reference = initial_ref
        self._stamp = int(initial_stamp)

    def getReference(self):
        with self._lock:
            return self._reference

    def getStamp(self):
        with self._lock:
            return self._stamp

    def get(self):
        with self._lock:
            return [self._reference, self._stamp]

    def attemptStamp(self, expected_reference, new_stamp):
        with self._lock:
            if self._reference is expected_reference or self._reference == expected_reference:
                self._stamp = int(new_stamp)
                return True
            return False

    def compareAndSet(self, expected_reference, new_reference,
                      expected_stamp, new_stamp):
        with self._lock:
            if (self._reference is expected_reference or self._reference == expected_reference):
                if self._stamp == expected_stamp:
                    self._reference = new_reference
                    self._stamp = int(new_stamp)
                    return True
            return False

    def weakCompareAndSet(self, expected_reference, new_reference,
                          expected_stamp, new_stamp):
        return self.compareAndSet(expected_reference, new_reference,
                                  expected_stamp, new_stamp)


# ============================================================
# Field Updaters
# ============================================================

class AtomicIntegerFieldUpdater(Stub):
    """java.util.concurrent.atomic.AtomicIntegerFieldUpdater"""
    def __init__(self, tclass, field_name):
        super().__init__()
        self._tclass = tclass
        self._field_name = field_name

    @staticmethod
    def newUpdater(tclass, field_name):
        return AtomicIntegerFieldUpdater(tclass, field_name)

    def get(self, obj):
        return getattr(obj, self._field_name, 0)

    def set(self, obj, new_value):
        setattr(obj, self._field_name, int(new_value))

    def lazySet(self, obj, new_value):
        self.set(obj, new_value)

    def getAndSet(self, obj, new_value):
        old = self.get(obj)
        self.set(obj, new_value)
        return old

    def compareAndSet(self, obj, expect, update):
        if self.get(obj) == expect:
            self.set(obj, update)
            return True
        return False

    def weakCompareAndSet(self, obj, expect, update):
        return self.compareAndSet(obj, expect, update)

    def getAndIncrement(self, obj):
        old = self.get(obj)
        self.set(obj, old + 1)
        return old

    def getAndDecrement(self, obj):
        old = self.get(obj)
        self.set(obj, old - 1)
        return old

    def getAndAdd(self, obj, delta):
        old = self.get(obj)
        self.set(obj, old + delta)
        return old

    def incrementAndGet(self, obj):
        val = self.get(obj) + 1
        self.set(obj, val)
        return val

    def decrementAndGet(self, obj):
        val = self.get(obj) - 1
        self.set(obj, val)
        return val

    def addAndGet(self, obj, delta):
        val = self.get(obj) + delta
        self.set(obj, val)
        return val


class AtomicLongFieldUpdater(Stub):
    """java.util.concurrent.atomic.AtomicLongFieldUpdater"""
    def __init__(self, tclass, field_name):
        super().__init__()
        self._tclass = tclass
        self._field_name = field_name

    @staticmethod
    def newUpdater(tclass, field_name):
        return AtomicLongFieldUpdater(tclass, field_name)

    def get(self, obj):
        return getattr(obj, self._field_name, 0)

    def set(self, obj, new_value):
        setattr(obj, self._field_name, int(new_value))

    def lazySet(self, obj, new_value):
        self.set(obj, new_value)

    def getAndSet(self, obj, new_value):
        old = self.get(obj)
        self.set(obj, new_value)
        return old

    def compareAndSet(self, obj, expect, update):
        if self.get(obj) == expect:
            self.set(obj, update)
            return True
        return False

    def weakCompareAndSet(self, obj, expect, update):
        return self.compareAndSet(obj, expect, update)

    def getAndIncrement(self, obj):
        old = self.get(obj)
        self.set(obj, old + 1)
        return old

    def getAndDecrement(self, obj):
        old = self.get(obj)
        self.set(obj, old - 1)
        return old

    def getAndAdd(self, obj, delta):
        old = self.get(obj)
        self.set(obj, old + delta)
        return old

    def incrementAndGet(self, obj):
        val = self.get(obj) + 1
        self.set(obj, val)
        return val

    def decrementAndGet(self, obj):
        val = self.get(obj) - 1
        self.set(obj, val)
        return val

    def addAndGet(self, obj, delta):
        val = self.get(obj) + delta
        self.set(obj, val)
        return val


class AtomicReferenceFieldUpdater(Stub):
    """java.util.concurrent.atomic.AtomicReferenceFieldUpdater"""
    def __init__(self, tclass, vclass, field_name):
        super().__init__()
        self._tclass = tclass
        self._vclass = vclass
        self._field_name = field_name

    @staticmethod
    def newUpdater(tclass, vclass, field_name):
        return AtomicReferenceFieldUpdater(tclass, vclass, field_name)

    def get(self, obj):
        return getattr(obj, self._field_name, None)

    def set(self, obj, new_value):
        setattr(obj, self._field_name, new_value)

    def lazySet(self, obj, new_value):
        self.set(obj, new_value)

    def getAndSet(self, obj, new_value):
        old = self.get(obj)
        self.set(obj, new_value)
        return old

    def compareAndSet(self, obj, expect, update):
        if self.get(obj) is expect or self.get(obj) == expect:
            self.set(obj, update)
            return True
        return False

    def weakCompareAndSet(self, obj, expect, update):
        return self.compareAndSet(obj, expect, update)


# ============================================================
# DoubleAccumulator
# ============================================================

class DoubleAccumulator(Stub):
    """java.util.concurrent.atomic.DoubleAccumulator"""
    def __init__(self, accumulator_func, identity):
        super().__init__()
        self._lock = _threading.Lock()
        self._value = float(identity)
        self._func = accumulator_func

    def accumulate(self, x):
        with self._lock:
            self._value = self._func.applyAsDouble(self._value, float(x))

    def get(self):
        with self._lock:
            return self._value

    def reset(self):
        with self._lock:
            self._value = 0.0

    def getThenReset(self):
        with self._lock:
            old = self._value
            self._value = 0.0
            return old

    def toString(self):
        return str(self.get())

    def doubleValue(self):
        return self.get()

    def floatValue(self):
        return float(self.get())

    def intValue(self):
        return int(self.get())

    def longValue(self):
        return int(self.get())


# ============================================================
# DoubleAdder
# ============================================================

class DoubleAdder(Stub):
    """java.util.concurrent.atomic.DoubleAdder"""
    def __init__(self):
        super().__init__()
        self._lock = _threading.Lock()
        self._value = 0.0

    def add(self, x):
        with self._lock:
            self._value += float(x)

    def sum(self):
        with self._lock:
            return self._value

    def reset(self):
        with self._lock:
            self._value = 0.0

    def sumThenReset(self):
        with self._lock:
            old = self._value
            self._value = 0.0
            return old

    def toString(self):
        return str(self.sum())

    def doubleValue(self):
        return self.sum()

    def floatValue(self):
        return float(self.sum())

    def intValue(self):
        return int(self.sum())

    def longValue(self):
        return int(self.sum())


# ============================================================
# LongAccumulator
# ============================================================

class LongAccumulator(Stub):
    """java.util.concurrent.atomic.LongAccumulator"""
    def __init__(self, accumulator_func, identity):
        super().__init__()
        self._lock = _threading.Lock()
        self._value = int(identity)
        self._func = accumulator_func

    def accumulate(self, x):
        with self._lock:
            self._value = self._func.applyAsLong(self._value, int(x))

    def get(self):
        with self._lock:
            return self._value

    def reset(self):
        with self._lock:
            self._value = 0

    def getThenReset(self):
        with self._lock:
            old = self._value
            self._value = 0
            return old

    def toString(self):
        return str(self.get())

    def intValue(self):
        return int(self.get())

    def longValue(self):
        return self.get()

    def floatValue(self):
        return float(self.get())

    def doubleValue(self):
        return float(self.get())


# ============================================================
# LongAdder
# ============================================================

class LongAdder(Stub):
    """java.util.concurrent.atomic.LongAdder"""
    def __init__(self):
        super().__init__()
        self._lock = _threading.Lock()
        self._value = 0

    def add(self, x):
        with self._lock:
            self._value += int(x)

    def increment(self):
        self.add(1)

    def decrement(self):
        self.add(-1)

    def sum(self):
        with self._lock:
            return self._value

    def reset(self):
        with self._lock:
            self._value = 0

    def sumThenReset(self):
        with self._lock:
            old = self._value
            self._value = 0
            return old

    def toString(self):
        return str(self.sum())

    def intValue(self):
        return int(self.sum())

    def longValue(self):
        return self.sum()

    def floatValue(self):
        return float(self.sum())

    def doubleValue(self):
        return float(self.sum())


# ============================================================
# Striped64
# ============================================================

class Striped64(Stub):
    """java.util.concurrent.atomic.Striped64"""
    def __init__(self):
        super().__init__()
        self._value = 0
        self._lock = _threading.Lock()

    def _get_value(self):
        with self._lock:
            return self._value

    def _set_value(self, v):
        with self._lock:
            self._value = v