# dev copy

import asyncio

import logging

import time

import traceback

from typing import Any, Awaitable, Callable, Union

from prometheus_client import Gauge, Summary

log = logging.getLogger()

# throw this away (when net_routes is rewritten)

def loop_forever_sync(func, sleep_period, up_metric):

    first_run = True

    while True:

        try:

            func(first_run)

            up_metric.set(1)

            first_run = False

        except Exception as ex:

            log.error(ex)

            traceback.print_exc()

            up_metric.set(0)

        time.sleep(sleep_period)

_created = []

# todo: some tricky typing

F_RET = Any

F_KWARGS = Any

UserAsyncFunc = Callable[...,  # always called with at least kwarg first_run=bool

                         Awaitable[F_RET]]

UserSyncFunc = Callable[...,  # see above

                        F_RET]

UserFunc = Union[UserAsyncFunc, UserSyncFunc]

class Loop:

    def __init__(

        self,

        func: UserFunc,

        sleep_period: float,

        metric_prefix: str,

    ):

        self.func = func

        self.sleep_period = sleep_period

        self.up_metric = Gauge(f'{metric_prefix}_up', 'not erroring')

        self.call_metric = Summary(f'{metric_prefix}_calls', 'calls')

        self.lastSuccessRun = 0

        self.everSucceeded = False

    async def call_func(self, first_run: bool, call_kwargs={}) -> F_RET:

        with self.call_metric.time():

            if asyncio.iscoroutinefunction(self.func):

                ret = await self.func(first_run=first_run, **call_kwargs)

            else:

                ret = self.func(first_run=first_run, **call_kwargs)

        return ret

    async def _run(self):

        self.first_run = True

        while True:

            await self._runOne()

            await asyncio.sleep(self.sleep_period)

    async def runNow(self, **kwargs: F_KWARGS) -> F_RET:

        """unlike background runs, you get to pass more args and get your func's

        return value.

        """

        return await self._runOne(call_kwargs=kwargs)

    async def _runOne(self, call_kwargs={}):

        try:

            result = await self.call_func(self.first_run, call_kwargs)

            self.lastSuccessRun = time.time()

            self.up_metric.set(1)

            self.everSucceeded = True

            self.first_run = False

        except Exception as ex:

            log.error(ex)

            traceback.print_exc()

            self.up_metric.set(0)

            result = None

            # todo: something that reveals error ratio

        return result

def loop_forever(

    func: UserFunc,

    sleep_period: float,

    metric_prefix='background_loop',

    up_metric=None,

    call_metric=None,

):

    """

    sleep_period is the sleep time after however long func takes to run

    """

    if up_metric is not None or call_metric is not None:

        raise NotImplementedError('remove old-style metrics')

    loop = Loop(func, sleep_period, metric_prefix)

    _created.append(asyncio.create_task(loop._run()))

    return loop