#! /usr/bin/python2.7

def get_save_subtitles(fpath) :
   import subliminal
   from babelfish import Language
   from datetime import timedelta
   from os import system
   print("Finding and saving subtitles for "+str(fpath))
   vids = subliminal.scan_video(fpath)
   subs = subliminal.download_best_subtitles([vids], {Language("eng")})
   for v in [vids] :
      subliminal.save_subtitles(v, subs[v])
      system("chmod -R 777 {}".format(v.name[:v.name.rindex("/")]))

import threading
class Downloader(threading.Thread) :
   def __init__(self, in_q, rate) :
      threading.Thread.__init__(self)
      self.q = in_q
      self.rate = rate
   def run(self) :
      @RateLimited(self.rate)
      def doit(arg) :
         try :
            get_save_subtitles(arg)
         except Exception as e :
            print("Could not save subtitles for "+arg+", "+str(e))
      while True :
         job = self.q.get()
         if job is None :
            return
         doit(job)

class FileWatcher(threading.Thread) :
   def __init__(self, root, out_q) :
      threading.Thread.__init__(self)
      self.q = out_q
      self.root = root
   def run(self) :
      import os
      for dirpath, _, fnames in os.walk(self.root) :
         fnames = sorted(fnames)
         if len(fnames) > 150 :
            continue
         for fname in fnames :
            fname = os.path.join(dirpath, fname)
            if not self.isVideoExt(fname.split(".")[-1]) :
               continue
            if not self.noSubYet(".".join(fname.split(".")[:-1])) :
               continue
            if self.isLink(fname) :
               continue
            self.q.put(fname)

      self.q.put(None)
   def isVideoExt(self, ext) :
      return ext in ["mp4", "avi", "mkv"]

   def noSubYet(self, basename) :
      from os import path
      return not (
         path.isfile(basename+".srt") or
         path.isfile(basename+".en.srt") or
         path.isfile(basename+".en.ttml") or
         path.isfile(basename+".ttml")
      )

   def isLink(self, fpath) :
      from os import path
      return path.islink(fpath)

job_queue = None
def get_job_queue() :
   global job_queue
   if job_queue is None :
      import Queue as queue
      job_queue = queue.Queue()
   return job_queue

last = 0.0
def RateLimited(opsPerSec) :
   import time
   minInterval = 1.0 / float(opsPerSec)
   def dec(func) :
      def limitedFunc(*args, **kwargs) :
         global last
         elapsed = time.clock() - last
         left = minInterval - elapsed
         if left > 0 :
            time.sleep(left)
         ret = func(*args, **kwargs)
         last = time.clock()
         return ret
      return limitedFunc
   return dec

def get_args() :
   import argparse
   parser = argparse.ArgumentParser()
   parser.add_argument("--root", type=str, default="/volume1/video/TV") #required=True)
   parser.add_argument("--rate", type=float, default=1)
   return parser.parse_args()

def main() :
   args = get_args()

   FileWatcher(args.root, get_job_queue()).run()
   Downloader(get_job_queue(), args.rate).run()

   return

   threads = []
   threads.append(FileWatcher(args.root, get_job_queue()))
   threads.append(Downloader(get_job_queue(), args.rate))

   for t in threads :
      t.start()

   for t in threads :
      t.join()

if __name__ == "__main__" :
   main()