import sys
import unittest
import pytest
from main import Task, TaskState, InvalidStateError, sleep_forever

class TestTask(unittest.TestCase):

    def test_the_state_and_the_result(self):
        task_state = 'A'
        
        async def async_fn():
            nonlocal task_state
            task_state = 'B'
            await sleep_forever()
            task_state = 'C'
            return 'result'

        task = Task(async_fn())
        self.assertIs(task.state, TaskState.CREATED)
        self.assertIs(task._exc_caught, None)
        self.assertEqual(task_state, 'A')
        with self.assertRaises(InvalidStateError):
            task.result

        task.start()
        self.assertIs(task.state, TaskState.STARTED)
        self.assertIs(task._exc_caught, None)
        self.assertEqual(task_state, 'B')
        with self.assertRaises(InvalidStateError):
            task.result

        with self.assertRaises(StopIteration):
            task.root_coro.send(None)
        self.assertIs(task.state, TaskState.FINISHED)
        self.assertIs(task._exc_caught, None)
        self.assertTrue(task.finished)
        self.assertFalse(task.cancelled)
        self.assertEqual(task.result, 'result')

    def test_the_state_and_the_result__ver_cancel(self):
        task_state = 'A'
        
        async def async_fn():
            nonlocal task_state
            task_state = 'B'
            await sleep_forever()
            task_state = 'C'
            return 'result'

        task = Task(async_fn())
        self.assertIs(task.state, TaskState.CREATED)
        self.assertIs(task._exc_caught, None)
        self.assertEqual(task_state, 'A')
        with self.assertRaises(InvalidStateError):
            task.result

        task.start()
        self.assertIs(task.state, TaskState.STARTED)
        self.assertIs(task._exc_caught, None)
        self.assertEqual(task_state, 'B')
        with self.assertRaises(InvalidStateError):
            task.result

        task.cancel()
        self.assertIs(task.state, TaskState.CANCELLED)
        self.assertIs(task._exc_caught, None)
        self.assertFalse(task.finished)
        self.assertTrue(task.cancelled)
        with self.assertRaises(InvalidStateError):
            task.result

    def test_the_state_and_the_result__ver_uncaught_exception(self):
        task_state = 'A'
        
        async def async_fn():
            nonlocal task_state
            task_state = 'B'
            await sleep_forever()
            task_state = 'C'
            raise ZeroDivisionError
            return 'result'

        task = Task(async_fn())
        self.assertIs(task.state, TaskState.CREATED)
        self.assertIs(task._exc_caught, None)
        self.assertEqual(task_state, 'A')
        with self.assertRaises(InvalidStateError):
            task.result

        task.start()
        self.assertIs(task.state, TaskState.STARTED)
        self.assertIs(task._exc_caught, None)
        self.assertEqual(task_state, 'B')
        with self.assertRaises(InvalidStateError):
            task.result

        with self.assertRaises(ZeroDivisionError):
            task.root_coro.send(None)
        self.assertIs(task.state, TaskState.CANCELLED)
        self.assertIsInstance(task._exc_caught, ZeroDivisionError)
        self.assertEqual(task_state, 'C')
        self.assertFalse(task.finished)
        self.assertTrue(task.cancelled)
        with self.assertRaises(InvalidStateError):
            task.result

    def test_throw_exc_to_unstarted_task(self):
        task = Task(sleep_forever())
        self.assertIs(task.state, TaskState.CREATED)
        with self.assertRaises(InvalidStateError):
            task._throw_exc(ZeroDivisionError)
        self.assertIs(task.state, TaskState.CREATED)
        self.assertIs(task._exc_caught, None)
        task.cancel()  # to avoid RuntimeWarning: coroutine 'xxx' was never awaited
        self.assertIs(task.state, TaskState.CANCELLED)
        self.assertIs(task._exc_caught, None)

    def test_throw_exc_to_cancelled_task(self):
        task = Task(sleep_forever())
        task.start()
        self.assertIs(task.state, TaskState.STARTED)
        task.cancel()
        self.assertIs(task.state, TaskState.CANCELLED)
        self.assertIs(task._exc_caught, None)
        with self.assertRaises(InvalidStateError):
            task._throw_exc(ZeroDivisionError)
        self.assertIs(task.state, TaskState.CANCELLED)
        self.assertIs(task._exc_caught, None)

    def test_throw_exc_to_finished_task(self):
        async def async_func():
            pass

        task = Task(async_func())
        task.start()
        self.assertTrue(task.finished)
        with self.assertRaises(InvalidStateError):
            task._throw_exc(ZeroDivisionError)
        self.assertTrue(task.finished)
        self.assertIs(task._exc_caught, None)

    def test_throw_exc_to_started_task_and_get_caught(self):
        async def async_fn():
            try:
                await sleep_forever()
            except ZeroDivisionError:
                pass
            else:
                assert False
                
        task = Task(async_fn())
        task.start()
        self.assertIs(task.state, TaskState.STARTED)
        self.assertIs(task._exc_caught, None)
        task._throw_exc(ZeroDivisionError)
        self.assertIs(task.state, TaskState.FINISHED)
        self.assertIs(task._exc_caught, None)

    @pytest.mark.parametrize('do_suppress', (True, False))
    def test_suppress_exception(self, do_suppress):
        from contextlib import nullcontext

        async def async_fn():
            raise ZeroDivisionError

        task = Task(async_fn())
        task._suppresses_exc = do_suppress
        with nullcontext() if do_suppress else self.assertRaises(ZeroDivisionError):
            task.start()
        self.assertIsInstance(task._exc_caught, ZeroDivisionError)
        self.assertIs(task.state, TaskState.CANCELLED)

    def test_cancel_self(self):
        async def async_fn():
            self.assertFalse(task._is_cancellable)
            task.cancel()
            self.assertTrue(task._cancel_requested)
            await sleep_forever()
            self.fail("Failed to cancel")

        task = Task(async_fn())
        task.start()
        self.assertTrue(task.cancelled)
        self.assertIs(task._exc_caught, None)

    def test_cancel_without_starting_it(self):
        task = Task(sleep_forever())
        task.cancel()
        self.assertTrue(task._cancel_requested)
        self.assertTrue(task.cancelled)
        self.assertIs(task._exc_caught, None)

    def test_try_to_cancel_self_but_no_opportunity_for_that(self):
        async def async_fn():
            self.assertFalse(task._is_cancellable)
            task.cancel()

        task = Task(async_fn())
        task.start()
        self.assertTrue(task.finished)

    @unittest.skipIf(sys.implementation.name == "pypy", reason="Couldn't figure out how to prevent weakrefs from being created")
    def test_making_a_weakref_should_raise_an_exception(self):
        import weakref
        with self.assertRaises(Exception):
            weakref.ref(Task.dummy_task)

if __name__ == '__main__':
    unittest.main()