# -*- coding: utf-8 -*-
import threading
import time
import copy

from media.monitor.handler import ReportHandler
from media.monitor.events import NewFile, DeleteFile
from media.monitor.log import Loggable
from media.monitor.exceptions import BadSongFile
import media.monitor.pure as mmp
from media.monitor.pure import LazyProperty

import api_clients.api_client as ac

class RequestSync(threading.Thread,Loggable):
    def __init__(self, watcher, requests):
        threading.Thread.__init__(self)
        self.watcher = watcher
        self.requests = requests

    @LazyProperty
    def apiclient(self):
        return ac.AirTimeApiClient()

    def run(self):
        # TODO : implement proper request sending
        self.logger.info("launching request with %d items." % len(self.requests))
        # self.apiclient.update_media_metadata(self
        self.watcher.flag_done()

class TimeoutWatcher(threading.Thread,Loggable):
    def __init__(self, watcher, timeout=5):
        self.logger.info("Created timeout thread...")
        threading.Thread.__init__(self)
        self.watcher = watcher
        self.timeout = timeout

    def run(self):
        # We try to launch a new thread every self.timeout seconds
        # so that the people do not have to wait for the queue to fill up
        while True:
            time.sleep(self.timeout)
            # If there is any requests left we launch em.
            # Note that this isn't strictly necessary since RequestSync threads
            # already chain themselves
            if self.watcher.requests_in_queue():
                self.logger.info("We got %d requests waiting to be launched" % self.watcher.requests_left_count())
                self.watcher.request_do()
            # Same for events, this behaviour is mandatory however.
            if self.watcher.events_in_queue():
                self.logger.info("We got %d events that are unflushed" % self.watcher.events_left_count())
                self.watcher.flush_events()

class WatchSyncer(ReportHandler,Loggable):
    def __init__(self, channel, chunking_number = 50, timeout=15):
        self.channel = channel
        self.timeout = timeout
        self.chunking_number = chunking_number
        self.__queue = []
        # Even though we are not blocking on the http requests, we are still
        # trying to send the http requests in order
        self.__requests = []
        self.request_running = False
        # we don't actually use this "private" instance variable anywhere
        self.__current_thread = None
        tc = TimeoutWatcher(self, timeout)
        tc.daemon = True
        tc.start()
        super(WatchSyncer, self).__init__(signal=channel.signal)

    @property
    def target_path(self): return self.channel.path
    def signal(self): return self.channel.signal

    def handle(self, sender, event):
        """We implement this abstract method from ReportHandler"""
        # Using isinstance like this is usually considered to be bad style
        # because you are supposed to use polymorphism instead however we would
        # separate event handling itself from the events so there seems to be
        # no better way to do this
        if isinstance(event, NewFile):
            try:
                self.logger.info("'%s' : New file added: '%s'" % (self.target_path, event.path))
                self.push_queue(event)
            except BadSongFile as e:
                self.report_problem_file(event=event, exception=e)
        elif isinstance(event, DeleteFile):
            self.logger.info("'%s' : Deleted file: '%s'" % (self.target_path, event.path))
            self.push_queue(event)
        else: raise Exception("Unknown event: %s" % str(event))

    def requests_left_count(self): return len(self.__requests)
    def events_left_count(self): return len(self.__queue)

    def push_queue(self, elem):
        self.logger.info("Added event into queue")
        if self.events_left_count() == self.chunking_number:
            self.push_request()
            self.request_do() # Launch the request if nothing is running
        self.__queue.append(elem)

    def flush_events(self):
        self.logger.info("Force flushing events...")
        self.push_request()
        self.request_do()


    def events_in_queue(self):
        """returns true if there are events in the queue that haven't been processed yet"""
        return len(self.__queue) > 0

    def requests_in_queue(self):
        return len(self.__requests) > 0

    def flag_done(self):
        """ called by request thread when it finishes operating """
        self.request_running = False
        self.__current_thread = None
        # This call might not be necessary but we would like
        # to get the ball running with the requests as soon as possible
        if self.requests_in_queue() > 0: self.request_do()

    def request_do(self):
        """ launches a request thread only if one is not running right now """
        if not self.request_running:
            self.request_running = True
            self.__requests.pop()()

    def push_request(self):
        self.logger.info("'%s' : Unleashing request" % self.target_path)
        # want to do request asyncly and empty the queue
        requests = copy.copy(self.__queue)
        def launch_request():
            # Need shallow copy here
            t = RequestSync(watcher=self, requests=requests)
            t.start()
            self.__current_thread = t
        self.__requests.append(launch_request)
        self.__queue = []

    def __del__(self):
        # Ideally we would like to do a little more to ensure safe shutdown
        if self.events_in_queue(): self.logger.warn("Terminating with events in the queue still pending...")
        if self.requests_in_queue(): self.logger.warn("Terminating with http requests still pending...")