# coding: utf-8

from __future__ import absolute_import, division, print_function, unicode_literals

import functools
import logging
import threading
import time
from typing import Callable, Optional

import bytedenv
import schedule


metrics_enabled = None
logger = logging.getLogger(__name__)
logging.getLogger('schedule').setLevel(logging.ERROR)


class Backgrounds(object):
    def __init__(self):  # type: () -> None
        self.scheduler = schedule.Scheduler()
        self.lock = threading.Lock()
        self.init_closures = []
        self.stop_event = threading.Event()

    def register(self, schedule_seconds, closure, init_closure=None):
        # type: (int, Callable[[], None], Optional[Callable[[], None]]) -> None
        """ Register a background task.

        :param schedule_seconds: The schedule time in seconds for this task.
        :param closure: Closure for the task, will running periodically. If this closure raised any error, the error
                        will be handled by a logger.
        :param init_closure: Closure for task's initialize, will be called once after start(). If this closure raised
                             any error, the error will popuped to the start() method.
        """
        @functools.wraps(closure)
        def wrapper():
            start = time.time()
            try:
                closure()
            except Exception:
                logger.exception('run %s in background raised an error, the backtrace is:', closure)
            time_usage = time.time() - start
            logger.debug('run %s in background, time usage in seconds: %f', closure, time_usage)
            if time_usage > 3:
                logger.warning(
                    'time usage in seconds for run %s in background is %f, this may cause other task delay',
                    closure, time_usage
                )
                tags = {'task_name': getattr(closure, '__name__', 'unknown')}
                global metrics_enabled
                if metrics_enabled is None:
                    try:
                        from bytedance import metrics
                        metrics_enabled = True
                    except ImportError:
                        metrics_enabled = False
                if metrics_enabled:
                    from bytedance import metrics
                    metrics.emit_counter('python.backgrounds.%s.delay' % bytedenv.get_psm(), 1, tags=tags)

        with self.lock:
            self.scheduler.every(schedule_seconds).seconds.do(wrapper)
            if init_closure:
                self.init_closures.append(init_closure)

    def _target(self):  # type: () -> None
        while True:
            if self.stop_event.is_set():
                break
            self.scheduler.run_pending()
            time.sleep(1)

    def start(self):  # type: () -> None
        """Start the backgrounds. **NOTICE**: you should call the start AFTER FORK!
        """
        for closure in self.init_closures:
            closure()
        self.worker_thread = threading.Thread(target=self._target)
        self.worker_thread.setDaemon(True)
        self.worker_thread.setName('backgrounds')
        self.worker_thread.start()

    def stop(self):  # type: () -> None
        """Stop the backgrounds.
        """
        self.stop_event.set()

    def join(self):  # type: () -> None
        """Join the backgrounds' thread, will be blocked until stop() is called.
        """
        return self.worker_thread.join()