from artiq.experiment import *


class UnwindingTest(EnvExperiment):
    def build(self):
        self.setattr_device("core")
        self.setattr_device("led0")
        self.setattr_device("led1")

    def run(self):
        avg = 0
        for i in range(10):
            self.test_nested_try_excepts(i)
            avg += self.get_dataset("time{}".format(i))
        avg /= 10
        self.set_dataset("time_avg", avg, broadcast=True, unit="s")
              
    def report_time(self, n, time):
        self.set_dataset("time{}".format(n), time, broadcast=True, unit="s")

    @portable
    def unwinding(self, n):
        try:
            try:
                try:
                    try:
                        try:
                            try:
                                try:
                                    try:
                                        try:
                                            try:
                                                assert n < 100
                                                self.unwinding(n + 1)
                                            except:
                                                raise
                                        except:
                                            raise
                                    except:
                                        raise
                                except:
                                    raise
                            except:
                                raise
                        except:
                            raise
                    except:
                        raise
                except:
                    raise
            except:
                raise
        except:
            raise

    @kernel
    def test_nested_try_excepts(self, n):
        self.core.wait_until_mu(now_mu())
        self.core.reset()
        p0 = self.core.get_rtio_counter_mu()
        try:
            self.unwinding(0)
        except:
            pass
        p1 = self.core.get_rtio_counter_mu()
        self.report_time(n, self.core.mu_to_seconds(p1 - p0))