from threading import RLock
from typing import Optional

from reactivex.abc import DisposableBase

from .disposable import Disposable


class RefCountDisposable(DisposableBase):
    """Represents a disposable resource that only disposes its underlying
    disposable resource when all dependent disposable objects have been
    disposed."""

    class InnerDisposable(DisposableBase):
        def __init__(self, parent: "RefCountDisposable") -> None:
            self.parent: Optional[RefCountDisposable] = parent
            self.is_disposed = False
            self.lock = RLock()

        def dispose(self) -> None:
            with self.lock:
                parent = self.parent
                self.parent = None

            if parent is not None:
                parent.release()

    def __init__(self, disposable: DisposableBase) -> None:
        """Initializes a new instance of the RefCountDisposable class with the
        specified disposable."""

        self.underlying_disposable = disposable
        self.is_primary_disposed = False
        self.is_disposed = False
        self.lock = RLock()
        self.count = 0

        super().__init__()

    def dispose(self) -> None:
        """Disposes the underlying disposable only when all dependent
        disposable have been disposed."""

        if self.is_disposed:
            return

        underlying_disposable = None
        with self.lock:
            if not self.is_primary_disposed:
                self.is_primary_disposed = True
                if not self.count:
                    self.is_disposed = True
                    underlying_disposable = self.underlying_disposable

        if underlying_disposable is not None:
            underlying_disposable.dispose()

    def release(self) -> None:
        if self.is_disposed:
            return

        should_dispose = False
        with self.lock:
            self.count -= 1
            if not self.count and self.is_primary_disposed:
                self.is_disposed = True
                should_dispose = True

        if should_dispose:
            self.underlying_disposable.dispose()

    @property
    def disposable(self) -> DisposableBase:
        """Returns a dependent disposable that when disposed decreases the
        refcount on the underlying disposable."""

        with self.lock:
            if self.is_disposed:
                return Disposable()

            self.count += 1
            return self.InnerDisposable(self)