#! /usr/bin/env python

# v. 2.10
# Interactive subtitles for `mpv` for language learners.

import os, subprocess, sys
import random, re, time
import requests
import threading, queue
import calendar, math, base64
import numpy
import ast

from urllib.parse import quote
from json import loads
from json.decoder import JSONDecodeError

import warnings
from six.moves import urllib

from PyQt5.QtCore import Qt, QThread, QObject, pyqtSignal, pyqtSlot, QSize
from PyQt5.QtWidgets import QApplication, QFrame, QVBoxLayout, QHBoxLayout, QLabel, QSizePolicy, QWidget
from PyQt5.QtGui import QPalette, QPaintEvent, QPainter, QPainterPath, QFont, QFontMetrics, QColor, QPen, QBrush

# Import Japanese tokinizer
from sudachipy import tokenizer
from sudachipy import dictionary
tokenizer_obj = dictionary.Dictionary().create()

pth = os.path.expanduser('~/.config/mpv/scripts/')
os.chdir(pth)
import config as config

# returns ([[word: reading, translation]..], [morphology = '', gender = ''])
# jisho.org
def jisho(word):
    DOMAIN = 'jisho.org'
    VERSION = '1'

    base_url = f'https://{DOMAIN}/api/v{VERSION}'

    def get(url, params=None):
        if params is None:
            params = {}

        response = requests.get(
            url,
            params=params,
        )

        json = response.json()
        if response.status_code != 200:
            raise APIException(response.status_code,
                               response.content.decode())

        try:
            word = json['data'][0]['japanese'][0]['word'] + ': ' + json['data'][0]['japanese'][0]['reading']
            reading = json['data'][0]['japanese'][0]['reading']
            translations = json['data'][0]['senses'][0]['english_definitions']
            pairs = [[word, '']]
            for definition in translations:
              pairs.append(['', definition])

            return pairs, [reading, '']
        except:
            return  [['No translation Found', ''], ['', '']]

    def search(keyword):
        url = f'{base_url}/search/words'
        params = {'keyword': keyword} if keyword else {}
        return get(url, params=params)

    return search(word)


# offline dictionary with word \t translation
def tab_divided_dict(word):
  if word in offdict:
    tr = re.sub('<.*?>', '', offdict[word]) if config.tab_divided_dict_remove_tags_B else offdict[word]
    tr = tr.replace('\\n', '\n').replace('\\~', '~')
    return [[tr, '-']], ['', '']
  else:
    return [], ['', '']

# Google
# https://github.com/Saravananslb/py-googletranslation
class TokenAcquirer:
    """Google Translate API token generator

    translate.google.com uses a token to authorize the requests. If you are
    not Google, you do have this token and will have to pay for use.
    This class is the result of reverse engineering on the obfuscated and
    minified code used by Google to generate such token.

    The token is based on a seed which is updated once per hour and on the
    text that will be translated.
    Both are combined - by some strange math - in order to generate a final
    token (e.g. 464393.115905) which is used by the API to validate the
    request.

    This operation will cause an additional request to get an initial
    token from translate.google.com.

    Example usage:
        >>> from pygoogletranslation.gauthtoken import TokenAcquirer
        >>> acquirer = TokenAcquirer()
        >>> text = 'test'
        >>> tk = acquirer.do(text)
        >>> tk
        464393.115905
    """

    def __init__(self, tkk='0', tkk_url='https://translate.google.com/translate_a/element.js', proxies=None):

        if proxies is not None:
            self.proxies = proxies
        else:
            self.proxies = None

        r = requests.get(tkk_url, proxies=self.proxies)

        if r.status_code == 200:
            re_tkk = re.search("(?<=tkk=\\')[0-9.]{0,}", str(r.content.decode("utf-8")))            
            if re_tkk:
                self.tkk = re_tkk.group(0)
            else:
                self.tkk = '0'
        else:
            self.tkk = '0'


    def _xr(self, a, b):
            size_b = len(b)
            c = 0
            while c < size_b - 2:
                d = b[c + 2]
                d = ord(d[0]) - 87 if 'a' <= d else int(d)
                d = self.rshift(a, d) if '+' == b[c + 1] else a << d
                a = a + d & 4294967295 if '+' == b[c] else a ^ d

                c += 3
            return a

    def acquire(self, text):
        a = []
        # Convert text to ints
        for i in text:
            val = ord(i)
            if val < 0x10000:
                a += [val]
            else:
                # Python doesn't natively use Unicode surrogates, so account for those
                a += [
                    math.floor((val - 0x10000) / 0x400 + 0xD800),
                    math.floor((val - 0x10000) % 0x400 + 0xDC00)
                ]

        b = self.tkk
        d = b.split('.')
        b = int(d[0]) if len(d) > 1 else 0

        # assume e means char code array
        e = []
        g = 0
        size = len(a)
        while g < size:
            l = a[g]
            # just append if l is less than 128(ascii: DEL)
            if l < 128:
                e.append(l)
            # append calculated value if l is less than 2048
            else:
                if l < 2048:
                    e.append(l >> 6 | 192)
                else:
                    # append calculated value if l matches special condition
                    if (l & 64512) == 55296 and g + 1 < size and \
                            a[g + 1] & 64512 == 56320:
                        g += 1
                        l = 65536 + ((l & 1023) << 10) + (a[g] & 1023)  # This bracket is important
                        e.append(l >> 18 | 240)
                        e.append(l >> 12 & 63 | 128)
                    else:
                        e.append(l >> 12 | 224)
                    e.append(l >> 6 & 63 | 128)
                e.append(l & 63 | 128)
            g += 1
        a = b
        for i, value in enumerate(e):
            a += value
            a = self._xr(a, '+-a^+6')
        a = self._xr(a, '+-3^+b+-f')
        a ^= int(d[1]) if len(d) > 1 else 0
        if a < 0:  # pragma: nocover
            a = (a & 2147483647) + 2147483648
        a %= 1000000  # int(1E6)
        return '{}.{}'.format(a, a ^ b)

    def do(self, text):
        tk = self.acquire(text)
        return tk

    
    def rshift(self, val, n):
        """python port for '>>>'(right shift with padding)
        """
        return (val % 0x100000000) >> n

# translate.google.com
def google(word):
  word = word.replace('\n', ' ').strip()
  url = 'https://translate.google.com/translate_a/single?client=t&sl={lang_from}&tl={lang_to}&hl={lang_to}&dt=at&dt=bd&dt=ex&dt=ld&dt=md&dt=qca&dt=rw&dt=rm&dt=ss&dt=t&ie=UTF-8&oe=UTF-8&otf=1&pc=1&ssel=3&tsel=3&kc=2&q={word}'.format(lang_from = config.lang_from, lang_to = config.lang_to, word = quote(word))

  pairs = []
  fname = 'urls/' + url.replace('/', "-")
  try:
    if ' ' in word:
      raise Exception('skip saving')
    
    p = open(fname).read().split('=====/////-----')
    try:
      word_descr = p[1].strip()
    except:
      word_descr = ''

    for pi in p[0].strip().split('\n\n'):
      pi = pi.split('\n')
      pairs.append([pi[0], pi[1]])
  except:
    acquirer = TokenAcquirer()
    tk = acquirer.do(word)

    url = '{url}&tk={tk}'.format(url = url, tk = tk)
    p = requests.get(url, headers={'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.167 Safari/537.36'}).text
    p = loads(p)

    try:
      pairs.append([p[0][0][0], p[0][0][1]])
    except:
      pass

    if p[1] != None:
      for translations in p[1]:
        for translation in translations[2]:
          try:
            t1 = translation[5] + ' ' + translation[0]
          except:
            t1 = translation[0]

          t2 = ', '.join(translation[1])

          if not len(t1):
            t1 = '-'
          if not len(t2):
            t2 = '-'

          pairs.append([t1, t2])

    word_descr = ''

  return pairs, ['', '']

def mpv_pause():
  os.system('echo \'{ "command": ["set_property", "pause", true] }\' | socat - "' + mpv_socket + '" > /dev/null')

def mpv_resume():
  os.system('echo \'{ "command": ["set_property", "pause", false] }\' | socat - "' + mpv_socket + '" > /dev/null')

def mpv_pause_status():
  stdoutdata = subprocess.getoutput('echo \'{ "command": ["get_property", "pause"] }\' | socat - "' + mpv_socket + '"')

  try:
    return loads(stdoutdata)['data']
  except:
    return mpv_pause_status()

def mpv_fullscreen_status():
  stdoutdata = subprocess.getoutput('echo \'{ "command": ["get_property", "fullscreen"] }\' | socat - "' + mpv_socket + '"')

  try:
    return loads(stdoutdata)['data']
  except:
    return mpv_fullscreen_status()

def mpv_message(message, timeout = 3000):
  os.system('echo \'{ "command": ["show-text", "' + message + '", "' + str(timeout) + '"] }\' | socat - "' + mpv_socket + '" > /dev/null')

def stripsd2(phrase):
  return ''.join(e for e in phrase.strip().lower() if e == ' ' or (e.isalnum() and not e.isdigit())).strip()

def r2l(l):
  l2 = ''

  try:
    l2 = re.findall('(?!%)\W+$', l)[0][::-1]
  except:
    pass

  l2 += re.sub('^\W+|(?!%)\W+$', '', l)

  try:
    l2 += re.findall('^\W+', l)[0][::-1]
  except:
    pass
  
  return l2

def split_long_lines(line, chunks = 2, max_symbols_per_line = False):
  if max_symbols_per_line:
    chunks = 0
    while 1:
      chunks += 1
      new_lines = []
      for i in range(chunks):
        new_line = ' '.join(numpy.array_split(line.split(' '), chunks)[i])
        new_lines.append(new_line)

      if len(max(new_lines, key = len)) <= max_symbols_per_line:
        return '\n'.join(new_lines)
  else:
    new_lines = []
    for i in range(chunks):
      new_line = ' '.join(numpy.array_split(line.split(' '), chunks)[i])
      new_lines.append(new_line)

    return '\n'.join(new_lines)

def dir2(name):
  print('\n'.join(dir( name )))
  exit()

class thread_subtitles(QObject):
  update_subtitles = pyqtSignal(bool, bool)

  @pyqtSlot()
  def main(self):
    global subs

    was_hidden = 0
    inc = 0
    auto_pause_2_ind = 0
    last_updated = time.time()

    while 1:
      time.sleep(config.update_time)

      # hide subs when mpv isn't in focus or in fullscreen
      if inc * config.update_time > config.focus_checking_time - 0.0001:
        while 'mpv' not in subprocess.getoutput('xdotool getwindowfocus getwindowname') or (config.hide_when_not_fullscreen_B and not mpv_fullscreen_status()) or (os.path.exists(mpv_socket + '_hide')):
          if not was_hidden:
            self.update_subtitles.emit(True, False)
            was_hidden = 1
          else:
            time.sleep(config.focus_checking_time)
        inc = 0
      inc += 1

      if was_hidden:
        was_hidden = 0
        self.update_subtitles.emit(False, False)
        continue

      try:
        tmp_file_subs = open(sub_file).read()
      except:
        continue
      
      if config.extend_subs_duration2max_B and not len(tmp_file_subs):
        if not config.extend_subs_duration_limit_sec:
          continue
        if config.extend_subs_duration_limit_sec > time.time() - last_updated:
          continue

      last_updated = time.time()

      while tmp_file_subs != subs:
        if config.auto_pause == 2:
          if not auto_pause_2_ind and len(re.sub(' +', ' ', stripsd2(subs.replace('\n', ' '))).split(' ')) > config.auto_pause_min_words - 1 and not mpv_pause_status():
            mpv_pause()
            auto_pause_2_ind = 1

          if auto_pause_2_ind and mpv_pause_status():
            break

          auto_pause_2_ind = 0

        subs = tmp_file_subs

        if config.auto_pause == 1:
          if len(re.sub(' +', ' ', stripsd2(subs.replace('\n', ' '))).split(' ')) > config.auto_pause_min_words - 1:
            mpv_pause()

        self.update_subtitles.emit(False, False)

        break

class thread_translations(QObject):
  get_translations = pyqtSignal(str, int, bool)

  @pyqtSlot()
  def main(self):
    while 1:
      to_new_word = False

      try:
        word, globalX = config.queue_to_translate.get(False)
      except:
        time.sleep(config.update_time)
        continue

      # changing cursor to hourglass during translation
      QApplication.setOverrideCursor(Qt.WaitCursor)

      threads = []
      for translation_function_name in config.translation_function_names:
        threads.append(threading.Thread(target = globals()[translation_function_name], args = (word,)))
      for x in threads:
        x.start()
      while any(thread.is_alive() for thread in threads):
        if config.queue_to_translate.qsize():
          to_new_word = True
          break
        time.sleep(config.update_time)

      QApplication.restoreOverrideCursor()

      if to_new_word:
        continue

      if config.block_popup:
        continue

      self.get_translations.emit(word, globalX, False)

# drawing layer
# because can't calculate outline with precision
class drawing_layer(QLabel):
  def __init__(self, line, subs, parent=None):
    super().__init__(None)
    self.line = line
    self.setStyleSheet(config.style_subs)
    self.psuedo_line = 0

  def draw_text_n_outline(self, painter: QPainter, x, y, outline_width, outline_blur, text):
    outline_color = QColor(config.outline_color)

    font = self.font()
    text_path = QPainterPath()
    text_path.addText(x, y, font, text)

    # draw blur
    range_width = range(outline_width, outline_width + outline_blur)
    # ~range_width = range(outline_width + outline_blur, outline_width, -1)

    for width in range_width:
      if width == min(range_width):
        alpha = 200
      else:
        alpha = (max(range_width) - width) / max(range_width) * 200
        alpha = int(alpha)

      blur_color = QColor(outline_color.red(), outline_color.green(), outline_color.blue(), alpha)
      blur_brush = QBrush(blur_color, Qt.SolidPattern)
      blur_pen = QPen(blur_brush, width, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)

      painter.setPen(blur_pen)
      painter.drawPath(text_path)

    # draw outline
    outline_color = QColor(outline_color.red(), outline_color.green(), outline_color.blue(), 255)
    outline_brush = QBrush(outline_color, Qt.SolidPattern)
    outline_pen = QPen(outline_brush, outline_width, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)

    painter.setPen(outline_pen)
    painter.drawPath(text_path)

    # draw text
    color = self.palette().color(QPalette.Text)
    painter.setPen(color)
    painter.drawText(x, y, text)

  if config.outline_B:
    def paintEvent(self, evt: QPaintEvent):
      if not self.psuedo_line:
        self.psuedo_line = 1
        return

      x = y = 0
      y += self.fontMetrics().ascent()
      painter = QPainter(self)

      self.draw_text_n_outline(
        painter,
        x,
        y + config.outline_top_padding - config.outline_bottom_padding,
        config.outline_thickness,
        config.outline_blur,
        text = self.line
        )

    def resizeEvent(self, *args):
      self.setFixedSize(
        self.fontMetrics().width(self.line),
        self.fontMetrics().height() +
          config.outline_bottom_padding +
          config.outline_top_padding
        )

    def sizeHint(self):
      return QSize(
        self.fontMetrics().width(self.line),
        self.fontMetrics().height()
        )

class events_class(QLabel):
  mouseHover = pyqtSignal(str, int, bool)
  redraw = pyqtSignal(bool, bool)

  def __init__(self, word, subs, skip = False, parent=None):
    super().__init__(word)
    self.setMouseTracking(True)
    self.word = word
    self.subs = subs
    self.skip = skip
    self.highlight = False

    self.setStyleSheet('background: transparent; color: transparent;')

  def highligting(self, color, underline_width):
    color = QColor(color)
    color = QColor(color.red(), color.green(), color.blue(), 200)
    painter = QPainter(self)

    if config.hover_underline:
      font_metrics = QFontMetrics(self.font())
      text_width = font_metrics.width(self.word)
      text_height = font_metrics.height()

      brush = QBrush(color)
      pen = QPen(brush, underline_width, Qt.SolidLine, Qt.RoundCap)
      painter.setPen(pen)
      if not self.skip:
        painter.drawLine(0, text_height - underline_width, text_width, text_height - underline_width)

    if config.hover_hightlight:
      x = y = 0
      y += self.fontMetrics().ascent()

      painter.setPen(color)
      painter.drawText(x, y + config.outline_top_padding - config.outline_bottom_padding, self.word)

  if config.outline_B:
    def paintEvent(self, evt: QPaintEvent):
      if self.highlight:
        self.highligting(config.hover_color, config.hover_underline_thickness)

  #####################################################

  def resizeEvent(self, event):
    text_height = self.fontMetrics().height()
    text_width = self.fontMetrics().width(self.word)

    self.setFixedSize(text_width, text_height + config.outline_bottom_padding + config.outline_top_padding)

  def enterEvent(self, event):
    if not self.skip:
      self.highlight = True
      self.repaint()
      config.queue_to_translate.put((self.word, event.globalX()))

  @pyqtSlot()
  def leaveEvent(self, event):
    if not self.skip:
      self.highlight = False
      self.repaint()

      config.scroll = {}
      self.mouseHover.emit('', 0, False)
      QApplication.restoreOverrideCursor()

  def wheel_scrolling(self, event):
    if event.y() > 0:
      return 'ScrollUp'
    if event.y():
      return 'ScrollDown'
    if event.x() > 0:
      return 'ScrollLeft'
    if event.x():
      return 'ScrollRight'

  def wheelEvent(self, event):
    for mouse_action in config.mouse_buttons:
      if self.wheel_scrolling(event.angleDelta()) == mouse_action[0]:
        if event.modifiers() == eval('Qt.%s' % mouse_action[1]):
          exec('self.%s(event)' % mouse_action[2])

  def mousePressEvent(self, event):
    for mouse_action in config.mouse_buttons:
      if 'Scroll' not in mouse_action[0]:
        if event.button() == eval('Qt.%s' % mouse_action[0]):
          if event.modifiers() == eval('Qt.%s' % mouse_action[1]):
            exec('self.%s(event)' % mouse_action[2])

  #####################################################

  def f_show_in_browser(self, event):
    config.avoid_resuming = True
    os.system(config.show_in_browser.replace('${word}', self.word))

  def f_auto_pause_options(self, event):
    if config.auto_pause == 2:
      config.auto_pause = 0
    else:
      config.auto_pause += 1
    mpv_message('auto_pause: %d' % config.auto_pause)

  @pyqtSlot()
  def f_subs_screen_edge_padding_decrease(self, event):
    config.subs_screen_edge_padding -= 5
    mpv_message('subs_screen_edge_padding: %d' % config.subs_screen_edge_padding)
    self.redraw.emit(False, True)

  @pyqtSlot()
  def f_subs_screen_edge_padding_increase(self, event):
    config.subs_screen_edge_padding += 5
    mpv_message('subs_screen_edge_padding: %d' % config.subs_screen_edge_padding)
    self.redraw.emit(False, True)

  @pyqtSlot()
  def f_font_size_decrease(self, event):
    config.style_subs = re.sub('font-size: (\d+)px;', lambda size: [ 'font-size: %dpx;' % ( int(size.group(1)) - 1 ), mpv_message('font: %s' % size.group(1)) ][0], config.style_subs, flags = re.I)
    self.redraw.emit(False, True)

  @pyqtSlot()
  def f_font_size_increase(self, event):
    config.style_subs = re.sub('font-size: (\d+)px;', lambda size: [ 'font-size: %dpx;' % ( int(size.group(1)) + 1 ), mpv_message('font: %s' % size.group(1)) ][0], config.style_subs, flags = re.I)
    self.redraw.emit(False, True)

  @pyqtSlot()
  def f_translation_full_sentence(self, event):
    self.mouseHover.emit(self.subs , event.globalX(), True)

  def f_auto_pause_min_words_decrease(self, event):
    config.auto_pause_min_words -= 1
    mpv_message('auto_pause_min_words: %d' % config.auto_pause_min_words)

  def f_auto_pause_min_words_increase(self, event):
    config.auto_pause_min_words += 1
    mpv_message('auto_pause_min_words: %d' % config.auto_pause_min_words)

class main_class(QWidget):
  def __init__(self):
    super().__init__()

    self.thread_subs = QThread()
    self.obj = thread_subtitles()
    self.obj.update_subtitles.connect(self.render_subtitles)
    self.obj.moveToThread(self.thread_subs)
    self.thread_subs.started.connect(self.obj.main)
    self.thread_subs.start()

    self.thread_translations = QThread()
    self.obj2 = thread_translations()
    self.obj2.get_translations.connect(self.render_popup)
    self.obj2.moveToThread(self.thread_translations)
    self.thread_translations.started.connect(self.obj2.main)
    self.thread_translations.start()

    # start the forms
    self.subtitles_base()
    self.subtitles_base2()
    self.popup_base()

  def clearLayout(self, layout):
    if layout == 'subs':
      layout = self.subtitles_vbox
      self.subtitles.hide()
    elif layout == 'subs2':
      layout = self.subtitles_vbox2
      self.subtitles2.hide()
    elif layout == 'popup':
      layout = self.popup_vbox
      self.popup.hide()

    if layout is not None:
      while layout.count():
        item = layout.takeAt(0)
        widget = item.widget()

        if widget is not None:
          widget.deleteLater()
        else:
          self.clearLayout(item.layout())

  def subtitles_base(self):
    self.subtitles = QFrame()
    self.subtitles.setAttribute(Qt.WA_TranslucentBackground)
    self.subtitles.setWindowFlags(Qt.X11BypassWindowManagerHint)
    self.subtitles.setStyleSheet(config.style_subs)

    self.subtitles_vbox = QVBoxLayout(self.subtitles)
    self.subtitles_vbox.setSpacing(config.subs_padding_between_lines)
    self.subtitles_vbox.setContentsMargins(0, 0, 0, 0)

  def subtitles_base2(self):
    self.subtitles2 = QFrame()
    self.subtitles2.setAttribute(Qt.WA_TranslucentBackground)
    self.subtitles2.setWindowFlags(Qt.X11BypassWindowManagerHint)
    self.subtitles2.setStyleSheet(config.style_subs)

    self.subtitles_vbox2 = QVBoxLayout(self.subtitles2)
    self.subtitles_vbox2.setSpacing(config.subs_padding_between_lines)
    self.subtitles_vbox2.setContentsMargins(0, 0, 0, 0)

    if config.pause_during_translation_B:
      self.subtitles2.enterEvent = lambda event : [mpv_pause(), setattr(config, 'block_popup', False)][0]
      self.subtitles2.leaveEvent = lambda event : [mpv_resume(), setattr(config, 'block_popup', True)][0] if not config.avoid_resuming else [setattr(config, 'avoid_resuming', False), setattr(config, 'block_popup', True)][0]

  def popup_base(self):
    self.popup = QFrame()
    self.popup.setAttribute(Qt.WA_TranslucentBackground)
    self.popup.setWindowFlags(Qt.X11BypassWindowManagerHint)
    self.popup.setStyleSheet(config.style_popup)

    self.popup_inner = QFrame()
    outer_box = QVBoxLayout(self.popup)
    outer_box.addWidget(self.popup_inner)

    self.popup_vbox = QVBoxLayout(self.popup_inner)
    self.popup_vbox.setSpacing(0)

  def render_subtitles(self, hide = False, redraw = False):
    if hide or not len(subs):
      try:
        self.subtitles.hide()
        self.subtitles2.hide()
      finally:
        return

    if redraw:
      self.subtitles.setStyleSheet(config.style_subs)
      self.subtitles2.setStyleSheet(config.style_subs)
    else:
      self.clearLayout('subs')
      self.clearLayout('subs2')

      if hasattr(self, 'popup'):
        self.popup.hide()

      # if subtitle consists of one overly long line - split into two
      if config.split_long_lines_B and len(subs.split('\n')) == 1 and len(subs.split(' ')) > config.split_long_lines_words_min - 1:
        subs2 = split_long_lines(subs)
      else:
        subs2 = subs

      subs2 = re.sub(' +', ' ', subs2).strip()

      ##############################

      for line in subs2.split('\n'):
        line2 = ' %s ' % line.strip()
        ll = drawing_layer(line2, subs2)

        hbox = QHBoxLayout()
        hbox.setContentsMargins(0, 0, 0, 0)
        hbox.setSpacing(0)
        hbox.addStretch()
        hbox.addWidget(ll)
        hbox.addStretch()
        self.subtitles_vbox.addLayout(hbox)

        ####################################

        hbox = QHBoxLayout()
        hbox.setContentsMargins(0, 0, 0, 0)
        hbox.setSpacing(0)
        hbox.addStretch()

        line2 += '\00'

        # Japanese Fix
        mode = tokenizer.Tokenizer.SplitMode.A
        line2 = [m.surface() for m in tokenizer_obj.tokenize(line2, mode)]

        for smbl in line2:
          word = smbl
          if smbl.isalpha():
            ll = events_class(word, subs2)
            ll.mouseHover.connect(self.render_popup)
            ll.redraw.connect(self.render_subtitles)

            hbox.addWidget(ll)
          else:
            ll = events_class(smbl, subs2, skip = True)
            hbox.addWidget(ll)

        hbox.addStretch()
        self.subtitles_vbox2.addLayout(hbox)

    self.subtitles.adjustSize()
    self.subtitles2.adjustSize()

    w = self.subtitles.geometry().width()
    h = self.subtitles.height = self.subtitles.geometry().height()

    x = (config.screen_width/2) - (w/2)

    if config.subs_top_placement_B:
      y = config.subs_screen_edge_padding
    else:
      y = config.screen_height - config.subs_screen_edge_padding - h

    self.subtitles.setGeometry(int(x), int(y), 0, 0)
    self.subtitles.show()

    self.subtitles2.setGeometry(int(x), int(y), 0, 0)
    self.subtitles2.show()

  def render_popup(self, text, x_cursor_pos, is_line):
    if text == '':
      if hasattr(self, 'popup'):
        self.popup.hide()
      return

    self.clearLayout('popup')

    if is_line:
      QApplication.setOverrideCursor(Qt.WaitCursor)
      
      line = globals()[config.translation_function_name_full_sentence](text)
      if config.translation_function_name_full_sentence == 'google':
        try:
          line = line[0][0][0].strip()
        except:
          line = 'Google translation failed.'
      
      if config.split_long_lines_B and len(line.split('\n')) == 1 and len(line.split(' ')) > config.split_long_lines_words_min - 1:
        line = split_long_lines(line)

      ll = QLabel(line)
      ll.setObjectName("first_line")
      self.popup_vbox.addWidget(ll)
    else:
      word = text

      for translation_function_name_i, translation_function_name in enumerate(config.translation_function_names):
        pairs, word_descr = globals()[translation_function_name](word)

        if not len(pairs):
          pairs = [['', '[Not found]']]
          #return

        # ~pairs = [ [ str(i) + ' ' + pair[0], pair[1] ] for i, pair in enumerate(pairs) ]

        if word in config.scroll:
          if len(pairs[config.scroll[word]:]) > config.number_of_translations:
            pairs = pairs[config.scroll[word]:]
          else:
            pairs = pairs[-config.number_of_translations:]
            if len(config.translation_function_names) == 1:
              config.scroll[word] -= 1

        for i1, pair in enumerate(pairs):
          if i1 == config.number_of_translations:
            break

          if config.split_long_lines_in_popup_B:
            pair[0] = split_long_lines(pair[0], max_symbols_per_line = config.split_long_lines_in_popup_symbols_min)
            pair[1] = split_long_lines(pair[1], max_symbols_per_line = config.split_long_lines_in_popup_symbols_min)

          if pair[0] == '-':
            pair[0] = ''
          if pair[1] == '-':
            pair[1] = ''

          if pair[0] != '':
            # to emphasize the exact form of the word
            # to ignore case on input and match it on output
            chnks = re.split(word, pair[0], flags = re.I)
            exct_words = re.findall(word, pair[0], flags = re.I)

            hbox = QHBoxLayout()
            hbox.setContentsMargins(0, 0, 0, 0)

            for i2, chnk in enumerate(chnks):
              if len(chnk):
                ll = QLabel(chnk)
                ll.setObjectName("first_line")
                hbox.addWidget(ll)
              if i2 + 1 < len(chnks):
                ll = QLabel(exct_words[i2])
                ll.setObjectName("first_line_emphasize_word")
                hbox.addWidget(ll)

            # filling the rest of the line with empty bg
            ll = QLabel()
            ll.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
            hbox.addWidget(ll)

            self.popup_vbox.addLayout(hbox)

          if pair[1] != '':
            ll = QLabel(pair[1])
            ll.setObjectName("second_line")
            self.popup_vbox.addWidget(ll)

            # padding
            ll = QLabel()
            ll.setStyleSheet("font-size: 6px;")
            self.popup_vbox.addWidget(ll)

        if len(word_descr[0]):
          ll = QLabel(word_descr[0])
          ll.setProperty("morphology", word_descr[1])
          ll.setAlignment(Qt.AlignRight)
          self.popup_vbox.addWidget(ll)

        # delimiter between dictionaries
        if translation_function_name_i + 1 < len(config.translation_function_names):
          ll = QLabel()
          ll.setObjectName("delimiter")
          self.popup_vbox.addWidget(ll)

    self.popup_inner.adjustSize()
    self.popup.adjustSize()

    w = self.popup.geometry().width()
    h = self.popup.geometry().height()

    if w > config.screen_width:
      w = config.screen_width - 20

    if not is_line:
      if w < config.screen_width / 3:
        w = config.screen_width / 3

    if x_cursor_pos == -1:
      x = (config.screen_width/2) - (w/2)
    else:
      x = x_cursor_pos - w/5
      if x+w > config.screen_width:
        x = config.screen_width - w

    if config.subs_top_placement_B:
      y = self.subtitles.height + config.subs_screen_edge_padding
    else:
      y = config.screen_height - config.subs_screen_edge_padding - self.subtitles.height - h

    self.popup.setGeometry(int(x), int(y), int(w), 0)
    self.popup.show()

    QApplication.restoreOverrideCursor()

if __name__ == "__main__":
  print('[py part] Starting jaSubs ...')

  try:
    os.mkdir('urls')
  except:
    pass

  if 'tab_divided_dict' in config.translation_function_names:
    offdict = { x.split('\t')[0].strip().lower() : x.split('\t')[1].strip() for x in open(os.path.expanduser(config.tab_divided_dict_fname)).readlines() if '\t' in x }

  mpv_socket = sys.argv[1]
  sub_file = sys.argv[2]
  # sub_file = '/tmp/mpv_sub_'
  # mpv_socket = '/tmp/mpv_socket_'

  subs = ''

  app = QApplication(sys.argv)

  config.avoid_resuming = False
  config.block_popup = False
  config.scroll = {}
  config.queue_to_translate = queue.Queue()
  config.screen_width = app.primaryScreen().size().width()
  config.screen_height = app.primaryScreen().size().height()

  form = main_class()
  app.exec_()