package com.example.chiljagossow.yeay

import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.JUnit4

import io.reactivex.observers.TestObserver
import io.reactivex.subjects.PublishSubject

import org.hamcrest.CoreMatchers.`is`
import org.junit.Assert.assertThat


@RunWith(JUnit4::class)
class RxSemaphoreTest {

    private lateinit var lock: PublishSubject<Boolean>
    private lateinit var observer: TestObserver<Boolean>

    @Before
    fun setup() {

        observer = TestObserver.create()
        lock = PublishSubject.create<Boolean>()

        lock.scan(1, { counter, flag -> if (flag) counter - 1 else counter + 1 })
                .skip(1)
                .map { counter -> (counter > 0) }
                .subscribe(observer)
    }

    @Test
    @Throws(Exception::class)
    fun singleEvent_result_locked() {

        lock.onNext(true)

        with(observer) {
            assertNotComplete()
            assertNoErrors()
            assertValueCount(1)
            assertValue(false)
        }
    }

    @Test
    @Throws(Exception::class)
    fun lockAndUnlock_result_unlocked() {

        with(lock) {
            onNext(true)
            onNext(false)
        }

        with(observer) {
            assertNotComplete()
            assertNoErrors()
            assertValueCount(2)
            assertThat(values()[0], `is`(false))
            assertThat(values()[1], `is`(true))
        }
    }

    @Test
    @Throws(Exception::class)
    fun multipleLock_singleUnlock_result_locked() {

        with(lock) {
            onNext(true)
            onNext(true)
            onNext(true)
            onNext(false)
        }

        with(observer) {
            assertNotComplete()
            assertNoErrors()
            assertValueCount(4)
            assertThat(values()[0], `is`(false))
            assertThat(values()[1], `is`(false))
            assertThat(values()[2], `is`(false))
            assertThat(values()[3], `is`(false))
        }
    }

    @Test
    @Throws(Exception::class)
    fun multipleLock_multipleUnlock_result_unlocked() {

        with(lock) {
            onNext(true)
            onNext(true)
            onNext(true)
            onNext(false)
            onNext(false)
            onNext(false)
        }

        with(observer) {
            assertNotComplete()
            assertNoErrors()
            assertValueCount(6)
            assertThat(values()[0], `is`(false))
            assertThat(values()[1], `is`(false))
            assertThat(values()[2], `is`(false))
            assertThat(values()[3], `is`(false))
            assertThat(values()[4], `is`(false))
            assertThat(values()[5], `is`(true))
        }
    }

    @Test
    @Throws(Exception::class)
    fun singleLock_multipleUnlock_result_unlock() {

        with(lock) {
            onNext(true)
            onNext(false)
            onNext(false)
            onNext(false)
        }

        with(observer) {
            assertNotComplete()
            assertNoErrors()
            assertValueCount(4)
            assertThat(values()[0], `is`(false))
            assertThat(values()[1], `is`(true))
            assertThat(values()[2], `is`(true))
            assertThat(values()[3], `is`(true))
        }
    }

    @Test
    @Throws(Exception::class)
    fun singleLock_unsubscribe_result_locked() {

        with(lock) {
            onNext(true)
            onComplete()
            onNext(false)
        }

        with(observer) {
            assertComplete()
            assertNoErrors()
            assertValueCount(1)
            assertThat(values()[0], `is`(false))
        }
    }

    @Test
    @Throws(Exception::class)
    fun singleLock_error_result_locked() {
        val t = Throwable()

        with(lock) {
            onNext(true)
            onError(t)
            onNext(false)
        }

        with(observer) {
            assertTerminated()
            assertError(t)
            assertValueCount(1)
            assertThat(values()[0], `is`(false))
        }
    }

    @Test
    fun multipleUnlock_singleLock_result_unlocked() {

        with(lock) {
            onNext(false)
            onNext(false)
            onNext(false)
            onNext(true)
        }

        with(observer) {
            assertNotComplete()
            assertNoErrors()
            assertValueCount(4)
            assertThat(values()[0], `is`(true))
            assertThat(values()[1], `is`(true))
            assertThat(values()[2], `is`(true))
            assertThat(values()[3], `is`(true))
        }
    }

    @Test
    fun disposed_observer_result_noEvents() {
        with(observer) {
            onComplete()
            dispose()

            lock.onNext(true)

            assertNoErrors()
            assertComplete()
            assertNoValues()
        }
    }

    @Test
    fun unlock_multipleSubscribersDisposed_result_noValuesEmitted() {

        val observer2 = TestObserver.create<Boolean>()
        lock.subscribe(observer2)

        observer.dispose()
        observer2.dispose()

        lock.onNext(false)

        with(observer) {
            assertNoValues()
            assertNoErrors()
        }

        with(observer2) {
            assertNoValues()
            assertNoErrors()
        }
    }

    @Test
    fun unlock_singleSubscribersDisposed_result_valuesEmittedForOne() {

        // I do not understand this test

        val observer2 = TestObserver.create<Boolean>()

        with (lock) {
            subscribe(observer2)
            onNext(true)
            observer2.dispose()
            onNext(false)
        }

        with(observer) {
            assertNotComplete()
            assertNoErrors()
            assertValueCount(2)
            assertThat(values()[0], `is`(false))
            assertThat(values()[1], `is`(true))
        }

        with(observer2) {
            assertNoErrors()
            assertValueCount(1)
            assertThat(values()[0], `is`(false))
        }
    }
}