#!/usr/bin/env python3

import sys, os, time
from http.server import SimpleHTTPRequestHandler,BaseHTTPRequestHandler
try:
    from http.server import ThreadingHTTPServer as HTTPServer
    print('Using threaded http-server')
except:
    from http.server import HTTPServer
    print('Using simple http-server')
from threading import Thread
import json
import locale
import gettext
import signal

signal.signal(signal.SIGINT, signal.SIG_DFL)
LANGS=['es', 'ca', 'en']

def lang_fullname(lang):
    xgettext_langs = [ _('spanish'), _('valencian'), _('english') ]
    if lang == 'es':
        return 'spanish'
    elif lang == 'ca':
        return 'valencian'
    elif lang == 'en':
        return 'english'
    else:
        return 'unknown'

def _(*args):
    return args

def set_translator(lang=None):
    global _
    if isinstance(lang,str) or lang is None:
        lang = [lang]
    elif isinstance(lang,list):
        pass
    else:
        pass
    lang = [l for l in lang if l in LANGS + [None]]
    if not lang:
        raise Exception('Invalid language parameter')
    if lang[0] is None:
        lang = None
    try:
        translation = gettext.translation('simplayer',localedir='/usr/share/locale', languages=lang)
        if translation:
            translation.install()
            _ = translation.gettext
    except FileNotFoundError:
        print('No translation found!')

set_translator()

# from PySide2.QtCore import (QUrl, Signal, Slot, QObject, QSize, Qt)
# from PySide2.QtGui import (QIcon,QPixmap)
# from PySide2.QtWidgets import (QApplication, QAction, QLineEdit, QMainWindow, QPushButton, QToolBar)
# from PySide2.QtWebEngineWidgets import (QWebEngineSettings, QWebEngineView, QWebEnginePage)

from PySide2.QtCore import *
from PySide2.QtGui import *
from PySide2.QtWidgets import *
from PySide2.QtWebEngineWidgets import *
from PySide2.QtWebEngineCore import *

# from qtpy.QtCore import *
# from qtpy.QtGui import *
# from qtpy.QtWidgets import *
# from qtpy.QtWebEngineWidgets import *

# from superqt import QRangeSlider

from jinja2 import Environment, FileSystemLoader

try:
    from bs4 import BeautifulSoup
except:
    pass

#LANG, ENCODING = locale.getdefaultlocale()
LANG, ENCODING = locale.getlocale()
LANG2 = os.getenv('LANG')
LANG3 = os.getenv('LANGUAGE')

if not LANG:
    LANG=""
if not LANG2:
    LANG2=""
if not LANG3:
    LANG3=""

lang_count={'en':0,'es':0,'ca':0}

if 'ca_ES' in LANG:
    lang_count['ca']+=1
elif 'es' in LANG:
    lang_count['es']+=1
elif 'en' in LANG:
    lang_count['en']+=1

if 'ca_ES' in LANG2:
    lang_count['ca']+=2
elif 'es' in LANG2:
    lang_count['es']+=2
elif 'en' in LANG2:
    lang_count['en']+=2

if 'ca_ES' in LANG3:
    lang_count['ca']+=2
elif 'es' in LANG3:
    lang_count['es']+=2
elif 'en' in LANG3:
    lang_count['en']+=2

if lang_count['es'] and lang_count['es'] > lang_count['ca']:
    LANG='es'
elif lang_count['ca'] and lang_count['ca'] > lang_count['es']:
    LANG='ca'
else:
    LANG='en'

set_translator(LANG)

DEBUG=False
DEBUG_REQUESTS=False
FIXED_PORT=None
if DEBUG:
    FIXED_PORT=16666


USE_CACHE=True
LIBRARY_DIR='/usr/lib/simplayer'
IMAGE_DIR=f'{LIBRARY_DIR}/images'
TEMPLATE_DIR=f'{LIBRARY_DIR}/templates'
RESOURCE_DIR=f'{LIBRARY_DIR}/resources'

def debug_print(msg):
    if DEBUG:
        sys.stderr.write(f'{msg}\n')
        sys.stderr.flush()

#FLASH_PPAPI_DIR=f'{LIBRARY_DIR}/untracked'
#FLASH_PPAPI_FILES=['libpepflashplayer.so','manifest.json']
#FLASH_PPAPI=f'{FLASH_PPAPI_DIR}/libpepflashplayer.so'

# import shutil
# import urllib3
# import tarfile, tempfile

# def download_libs():
#     if os.path.isfile(FLASH_PPAPI):
#         return
#     url='http://ftp.eq.uc.pt/software/Linux/deb-multimedia/pool/non-free/p/pepper-flash-player/flashplayer-chromium_32.0.0.465-dmo1_amd64.deb'
#     try:
#         with tempfile.TemporaryDirectory() as tmpdir:
#             with urllib3.PoolManager().request('GET',url, preload_content=False) as fp1:
#                 with open(f'{tmpdir}/file.deb','wb') as fp2:
#                     shutil.copyfileobj(fp1,fp2)
#                     os.system(f'/usr/bin/ar x {tmpdir}/file.deb --output {tmpdir}')
#                     tar = tarfile.open(name=f'{tmpdir}/data.tar.xz',mode='r:xz')
#                     for member in (m for m in tar.getmembers() if m.isfile() and os.path.basename(m.name) in ['libpepflashplayer.so','manifest.json']):
#                         with open(f'{FLASH_PPAPI_DIR}/{os.path.basename(member.name)}','wb') as fp3:
#                             shutil.copyfileobj(tar.extractfile(member),fp3)
#             pass
#     except Exception as e:
#         print(f'{str(e)}')
#         pass

EASY = True
NORMAL = True
HARD = True

class Handler(SimpleHTTPRequestHandler):
    def __init__(self,*args,**kwargs):
        try:
            super().__init__(*args,directory=LIBRARY_DIR,**kwargs)
        except Exception as e:
            os.chdir(LIBRARY_DIR)
            super().__init__(*args,**kwargs)

    # def translate_path(self, path, *args):
    #     return super().translate_path(path, *args)

    def do_GET(self,*args):
        content = None
        basename = os.path.basename(self.path)
        response_code = 200
        if basename:
            if 'home' == basename[:4]:
                key = basename.split('?')[1]
                if key:
                    params = key.split('&')
                    for param in params:
                        try:
                            k,v = param.split('=')
                        except:
                            k = param
                            v = ''
                        if k == 'gltest':
                            if v == 'no':
                                self.server.http_server.webgl_detection.emit('NO')
                                self.server.http_server.tm.set_webgl_enabled(False)
                            elif v == 'yes':
                                self.server.http_server.webgl_detection.emit('YES')
                        elif k == 'category':
                            content = self.server.http_server.tm.get_html(type_html=v).encode('utf8')
                if not content:
                    if self.server.http_server.tm.main_page:
                        content = self.server.http_server.tm.redirect(redirection=self.server.http_server.tm.main_page).encode('utf8')
                    else:
                        content = self.server.http_server.tm.get_html(type_html='').encode('utf8')
            elif 'swf' == basename[:3]:
                key = basename.split('?')[1]
                content = self.server.http_server.tm.get_html(type_html='swf',name=key).encode('utf8')
            elif 'webgl' == basename[:5]:
                content = self.server.http_server.tm.check_webgl().encode('utf8')
        elif self.path == '/':
            content = self.server.http_server.tm.get_html(type_html='home').encode('utf8')

        if content:
            currentActivity = None
            self.send_response(response_code)
            self.end_headers()
            if isinstance(content,(str,bytes)):
                self.wfile.write(content)
        else:
            try:
                super().do_GET(*args)
            except Exception as e:
                try:
                    self.send_error(429)
                except Exception as e2:
                    pass
                # print(f'Fail request {self.path}')
        # print('{} {}'.format(_('Current activity: '),currentActivity))

    # def list_directory(self, path):
    #     return super().list_directory(path)

    def log_message(self, format, *args):
        if DEBUG_REQUESTS:
            msg = f'HTTP_HANDLE_REQUEST {self.address_string()} - - [{self.log_date_time_string()}] "{args[0]}" {args[1]} {args[2]}'
            debug_print(msg)
            # return super().log_message(format, *args)

class CustomTCPServer(HTTPServer,QObject):
    def __init__(self,*args,**kwargs):
        self.http_server = kwargs.get('http_server')
        kwargs.pop('http_server')
        super().__init__(*args,**kwargs)

class HttpServer(QObject):
    server_started = Signal(str)
    webgl_detection = Signal(str)

    def __init__(self,*args,**kwargs):
        super().__init__()
        self.activity = kwargs.get('activity')
        kwargs.pop('activity')
        self.tm = TemplateManager(activity=self.activity)
        self.thread_server = Thread(target=self.start_server,name='http_server',daemon=True,kwargs=kwargs)
        self.thread_server.start()

    def start_server(self,*args,**kwargs):
        while True:
            try:
                port = 0
                if FIXED_PORT:
                    port = FIXED_PORT
                with CustomTCPServer(("",port),Handler,http_server=self,**kwargs) as httpd:
                    p = httpd.server_address[1]
                    self.server_started.emit(str(p))
                    httpd.serve_forever()
            except Exception as e:
                pass

class TemplateManager():
    def __init__(self,*args,**kwargs):
        self.main_activity=kwargs.get('activity')
        self.main_page=''
        self.webgl_enabled = True
        self.basedir = LIBRARY_DIR
        self.init_cache()
        self.loader = FileSystemLoader(searchpath=TEMPLATE_DIR)
        self.environment = Environment(loader=self.loader)
        self.projects = {}
        self.categories = {}
        self.search_projects()
        self.search_categories()
        self.check_main_page()
        print('{} {}'.format(len(self.projects),_('projects loaded')))

    def init_cache(self):
        self.cache = {}
        for l in LANGS:
            for i in ['{0:03b}'.format(i) for i in range(8) ]:
                k=[]
                for c in i:
                    if c == '1':
                        k.append('True')
                    else:
                        k.append('False')
                self.cache[l+'_'+'_'.join(k)] = {}

    def check_main_page(self):
        if self.main_activity:
            found = False
            for project in self.projects:
                if self.main_activity == project.split('/')[-1]:
                    prjdata=self.projects[project]
                    self.main_page=f'{project}/{prjdata.get(f"html_{LANG}")}'
                    self.main_page=self.main_page.split(LIBRARY_DIR)[-1]
                    found = True
                    break
            if not found:
                # exit showing message
                QMessageBox.critical(None,_('Error'),_("Activity '{}' not found").format(self.main_activity))
                print(_("Activity '{}' not found").format(self.main_activity))
                sys.exit(1)


    def set_webgl_enabled(self,status):
        self.webgl_enabled=status
        self.init_cache()

    def search_projects(self):
        needed = { 'banner': '', 'html': '' , 'name': ''}
        for x in (d for d in os.listdir(RESOURCE_DIR) if os.path.isdir(f'{RESOURCE_DIR}/{d}')):
            prj = f'{RESOURCE_DIR}/{x}'
            try:
                f = json.load(open(os.path.join(prj,'meta.json'),'r'))
                # ensure full tree with all languages
                for language in LANGS:
                    for key in needed.keys():
                        if f.get(f'{key}_{language}'):
                            needed[key] = f.get(f'{key}_{language}')
                    if needed['banner'] and needed['html'] and needed['name']:
                        break
                for language in LANGS:
                    if language not in f.get('languages'):
                        f['languages'].append(language)
                    for key in needed.keys():
                        if not f.get(f'{key}_{language}'):
                            f[f'{key}_{language}'] = needed[key]
                # ensure level on all activities
                level = f.get('level')
                if not level or level not in ['easy','normal','hard']:
                    f['level'] = 'normal'
                self.projects.setdefault(prj,f)
            except Exception as e:
                pass

    def search_categories(self):
        imagedir = f'{self.basedir}/images/categories'
        default_category_image = f'{imagedir}/default_category.svg'
        cats = set()
        for prj in self.projects.values():
            cat = prj.get('category')
            for c in cat.split(','):
                if c:
                    cats.add(c)
        cats = sorted(list(cats))
        for cat in cats:
            if os.path.isfile(f'{imagedir}/{cat}.svg'):
                self.categories.setdefault(cat,f'{imagedir}/{cat}.svg')
            else:
                self.categories.setdefault(cat,default_category_image)

        # for x in (f for f in os.listdir(imagedir) if os.path.basename(f).split('.')[-1] == 'svg' and os.path.isfile(os.path.join(imagedir,f))):
        #     self.categories.setdefault(os.path.basename(x).split('.')[0],os.path.relpath(os.path.join(self.basedir,x),self.basedir))

    def get_html(self,*args,**kwargs):
        type_html = kwargs.get('type_html')
        show = 'home'
        if type_html and type_html in self.categories:
            show = type_html
        elif type_html == 'swf':
            name = kwargs.get('name')
            show = f'swf_{name}'

        out = None
        if USE_CACHE:
            out = self.cache[f'{LANG}_{EASY}_{NORMAL}_{HARD}'].get(show)
            if out:
                debug_print(_('Cache hit'))
            else:
                debug_print(_('Cache miss'))

        if out:
            return out
        if show == 'home':
            content = self.index_html()
        elif type_html == 'swf':
            content = self.swf_html(name=name)
        else:
            content = self.category_html(show=show)
        self.cache[f'{LANG}_{EASY}_{NORMAL}_{HARD}'].setdefault(show,content)
        return content

    def redirect(self,*args,**kwargs):
        tpl = self.environment.get_template('redirect.tpl')
        content = tpl.render(**kwargs)
        return content

    def check_webgl(self):
        tpl = self.environment.get_template('checkwebgl.tpl')
        content = tpl.render()
        return content

    def color_category(self,category):
        color = '#f5f5dc'
        if category == 'math':
            color = '#ff0000'
        elif category == 'earth-science':
            color = '#82553c'
        elif category == 'biology':
            color = '#00ff00'
        elif category == 'physics':
            color = '#0000ff'
        elif category == 'chemistry':
            color = '#820082'
        return color

    def index_html(self):
        tpl = self.environment.get_template('index.tpl')
        items = [ (f'home?category={k}',f'images/categories/{k}.svg' if os.path.isfile(f'{LIBRARY_DIR}/images/categories/{k}.svg') else f'images/categories/default_category.svg',_(k),k,self.color_category(k)) for k in sorted(self.categories.keys()) ]
        i=len(items)
        columns=1
        if i == 1:
            columns=1
        elif i  % 3 == 0:
            columns=3
        else:
            columns=2
        content = tpl.render(categories=items,color='#e59e6d',columns=str(columns))
        return content

    def category_html(self,*args,**kwargs):
        category = kwargs.get('show')
        xgettext_categories=[_('math'),_('earth-science'),_('biology'),_('physics'),_('chemistry'),_('accessibility'),_('basics'),_('other')]
        color = self.color_category(category)
        tpl = self.environment.get_template('categories.tpl')
        items = [ (f'{os.path.relpath(k,self.basedir)}/{v.get(f"html_{LANG}")}',f'{os.path.relpath(k,self.basedir)}/{v.get(f"banner_{LANG}")}',v.get(f'name_{LANG}'),v.get('level')) for k,v in self.projects.items() if category in v.get('category').split(',') and ( (self.webgl_enabled == False and 'webgl' not in v.get('require')) or self.webgl_enabled )]
        items.sort(key=lambda x: x[2])
        content = tpl.render(items=items,color=color,filter_text=_('Filter'),easy=EASY,normal=NORMAL,hard=HARD,msg=_('No items to display with current settings'))
        return content

    def swf_html(self,*args,**kwargs):
        name = kwargs.get('name')
        if not name:
            return ''
        tpl = self.environment.get_template('swf.tpl')
        content = tpl.render(html={'rufflepath':'/ruffle/ruffle.js','swf':name})
        pass
        return content

class Interceptor(QWebEngineUrlRequestInterceptor):
    def __init__(self):
        super().__init__()

    def interceptRequest(self, info):
        # if info.requestUrl().scheme() == 'simplayer':
        #    info.setUrl(QUrl(f'{self.app.basedir}/{info.requestUrl().path()}'))
        # else:
        #    info.block(True)
        pass

class WebEngine(QWebEngineView):
    def __init__(self,*args,**kwargs):
        super(WebEngine,self).__init__(*args,**kwargs)
        self.initSettings()
        self.set_interceptor()

    def initSettings(self):
        pagesettings = QWebEngineSettings.globalSettings()
        settings = [QWebEngineSettings.WebGLEnabled, QWebEngineSettings.Accelerated2dCanvasEnabled, QWebEngineSettings.PluginsEnabled]
        for s in settings:
            b = pagesettings.testAttribute(s)
            pagesettings.setAttribute(s,True)
            a = pagesettings.testAttribute(s)
            if b != a:
                debug_print('{} {}!'.format(s,_('activated')))

    def set_interceptor(self):
        self.interceptor = Interceptor()
        self.page().setUrlRequestInterceptor(self.interceptor)

class CustomPage(QWebEnginePage):
    def __init__(self,*args,**kwargs):
        self.callback = None
        super(CustomPage,self).__init__(*args,**kwargs)

    def set_callback(self,callback):
        self.callback = callback

    def acceptNavigationRequest(self, url, _type, isMainFrame, *args, **kwargs):
        if self.callback:
            url2 = self.callback(url)
            if not url2:
                url2 = url
            if url2 != url:
                self.setUrl(url2)
                return False
            return super(CustomPage,self).acceptNavigationRequest(url2, _type, isMainFrame, *args, **kwargs)
        else:
            return super(CustomPage,self).acceptNavigationRequest(url, _type, isMainFrame, *args, **kwargs)

class MainWindow(QMainWindow):
    server_started = Signal(str)

    def debug_history(self):
        n=0
        h = self.webEngineView.history()
        cur = h.currentItemIndex()
        debug_print(_('--Start History--'))
        for x in h.items():
            s=""
            if n == cur:
                s="*"
            debug_print(f'{s}{n}:{x.url().toString()}')
            n+=1
        debug_print(_('-- End History --'))

    def __init__(self,*args,**kwargs):
        super().__init__()
        self.setWindowIcon(QIcon(f'{LIBRARY_DIR}/resources/favicon.ico'))
        # always lowercase keys
        self.mapping = {
            # 'debug_gpu-flags' : "chrome://gpu",
            # 'debug_webgl-report' : 'http://webglreport.com/',
            # 'debug_flash-test1' : 'https://condor.depaul.edu/sjost/hci430/flash-examples/Examples1/Examples1.htm',
            # 'debug_flash-version' : 'http://embed-swf.org/flash-player-version.php',
            # 'debug_webgl-detect' : lambda: self.load_url(f'{self.get_docroot()}/webgl?'),
            # # 'debug_download' : lambda : download_libs(),
            # 'debug_swf': lambda: self.load_url(f'{self.get_docroot()}/resources/diza/swf?diza.swf'),
            # 'debug_code' : lambda : self.webEngineView.page().toHtml(lambda x: print(BeautifulSoup(x,features="lxml").prettify()) or self.debug_history()),
            # 'debug_ruffle': 'https://ruffle.rs/demo/',
            'back' : lambda : self.load_back(),
            'forward': lambda : self.load_forward(),
            'reload': lambda : self.load_reload(),
        }

        self.local_server_port = None
        self.server = HttpServer(**kwargs)
        self.server.server_started.connect(self.set_local_port)
        self.server.webgl_detection.connect(self.set_webgl_detection)
        self.webgl_enabled = True

        self.setWindowTitle(_('Simplayer'))
        self.objects = {}

        self.toolbar = QToolBar(self)
        self.objects.setdefault('toolbar',self.toolbar)
        self.addToolBar(self.toolbar)
        self.toolbar.setFloatable(False)
        self.toolbar.setMovable(False)

        xgettext_keys=[_('home'),_('back'),_('forward'),_('reload')]
        for key in ['home','back','forward','reload']:
            self.add_button(key=key)
        if DEBUG:
            spacer = QWidget()
            spacer.setSizePolicy(QSizePolicy.Expanding,QSizePolicy.Preferred)
            self.toolbar.addWidget(spacer)
            for d in sorted((x for x in self.mapping if 'debug_' in x)):
                self.add_button(d)

        spacer = QWidget()
        spacer.setSizePolicy(QSizePolicy.Expanding,QSizePolicy.Preferred)
        self.toolbar.addWidget(spacer)

        self.label = QLabel()
        self.label.setText(_('Show activities').capitalize()+':')
        self.label.setStyleSheet("QLabel { margin-right: 1ex; }")
        self.check_easy = QCheckBox(_('easy').capitalize(),self)
        self.check_easy.setFocusPolicy(Qt.NoFocus)
        self.check_normal = QCheckBox(_('normal').capitalize(),self)
        self.check_normal.setFocusPolicy(Qt.NoFocus)
        self.check_hard = QCheckBox(_('hard').capitalize(),self)
        self.check_hard.setFocusPolicy(Qt.NoFocus)
        self.check_easy.setChecked(EASY)
        self.check_normal.setChecked(NORMAL)
        self.check_hard.setChecked(HARD)
        self.check_easy.stateChanged.connect(lambda: self.check_changed(self.check_easy.isChecked(),self.check_normal.isChecked(),self.check_hard.isChecked()))
        self.check_normal.stateChanged.connect(lambda: self.check_changed(self.check_easy.isChecked(),self.check_normal.isChecked(),self.check_hard.isChecked()))
        self.check_hard.stateChanged.connect(lambda: self.check_changed(self.check_easy.isChecked(),self.check_normal.isChecked(),self.check_hard.isChecked()))
        self.toolbar.addWidget(self.label)
        self.toolbar.addWidget(self.check_easy)
        self.toolbar.addWidget(self.check_normal)
        self.toolbar.addWidget(self.check_hard)

        spacer2 = QWidget()
        spacer2.setSizePolicy(QSizePolicy.Expanding,QSizePolicy.Preferred)
        self.toolbar.addWidget(spacer2)

        self.label_language = QLabel()
        self.label_language.setText(_('Language').capitalize()+':')
        self.label_language.setStyleSheet("QLabel { margin-right: 1ex; }")
        self.toolbar.addWidget(self.label_language)

        self.language_selector = QComboBox()
        self.language_selector.addItems( map(lambda x: x.capitalize(),[ _(lang_fullname(l)) for l in LANGS ]) )
        text = _(lang_fullname(LANG)).capitalize()
        self.language_selector.setCurrentIndex(self.language_selector.findText(text))
        self.language_selector.currentIndexChanged.connect(self.set_language)
        self.language_selector.setEditable(False)
        self.language_selector.setFocusPolicy(Qt.NoFocus)
        self.language_selector.setStyleSheet('QComboBox { border: 0px; background-color: transparent; width: 12ex; }')
        self.toolbar.addWidget(self.language_selector)


        self.webEngineView = WebEngine(self)

        self.webPage = CustomPage(self)
        self.webEngineView.setPage(self.webPage)
        self.webPage.set_callback(self.load_url)

        self.webEngineView.page().urlChanged.connect(self.urlChanged)
        self.webEngineView.page().loadFinished.connect(self.loadFinished)

        self.setCentralWidget(self.webEngineView)

        if self.server.tm.main_page:
            self.toolbar.hide()

        self.toolbar.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
        self.level_changed = False
        self.browsing_history= False
        self.language_changed = False

    def get_levels(self):
        return (self.check_easy.isChecked(),self.check_normal.isChecked(),self.check_hard.isChecked())

    def check_changed(self,easy,normal,hard):
        global EASY,NORMAL,HARD
        EASY = easy
        NORMAL = normal
        HARD = hard
        if self.in_category:
            self.level_changed = True
            self.load_reload()

    def set_language(self,index,go=True):
        global LANG
        if isinstance(index,str):
            LANG=index.lower()
            index = self.language_selector.findText(_(lang_fullname(LANG)).capitalize())
            self.language_selector.setCurrentIndex(index)
        else:
            LANG = LANGS[index]
        set_translator(LANG)
        self.retranslate_buttons()
        if go:
            self.language_changed = True
            self.webPage.setUrl(self.webEngineView.url())

    def retranslate_buttons(self):
        for key,button in self.objects.items():
            if key.startswith('button_'):
                button.setText(_(key[len('button_'):]).capitalize())
        for l in LANGS:
            self.language_selector.setItemText(LANGS.index(l),_(lang_fullname(l)).capitalize())
        self.label.setText(_('Show activities').capitalize()+':')
        self.check_easy.setText(_('easy').capitalize())
        self.check_normal.setText(_('normal').capitalize())
        self.check_hard.setText(_('hard').capitalize())
        self.label_language.setText(_('Language').capitalize()+':')

    def add_button(self,key=None):
        if key:
            nameobject = f'button_{key}'
            toolbar = self.objects.get('toolbar')

            if nameobject in self.objects:
                debug_print('{}: {} {}'.format(_('Warning'),key,_('object already defined, can\'t add')))
                return
            image = f'{IMAGE_DIR}/buttons/{key}.svg'
            icon = None
            if os.path.isfile(image):
                icon = QIcon(QPixmap(image))
            else:
                debug_print('{}: {} {}'.format(_('Warning'),_('Missing image'),image))
                icon = self.style().standardIcon(QStyle.SP_DesktopIcon)

            if 'debug_' in key:
                key = key.split('debug_')[1]
                action = QAction(icon,_(key).capitalize(),toolbar)
                action.setData(f'debug_{key}')
            else:
                action = QAction(icon,_(key).capitalize(),toolbar)
                action.setData(key)

            action.triggered.connect(self.buttonPushed)
            self.objects.setdefault(nameobject,action)
            toolbar.addAction(action)

    def buttonPushed(self,*args,**kwargs):
        try:
            who = kwargs.get('who')
            if not who:
                who=self.sender().data()
            who = who.lower()
            destination = self.mapping.get(who)
            if isinstance(destination,type(lambda x:x)):
                destination()
            else:
                if destination:
                    self.webPage.setUrl(QUrl(destination))
                else:
                    self.webPage.setUrl(f'{self.get_docroot()}/home?button={who}')
        except Exception as e:
            pass

    @Slot(str)
    def set_local_port(self,port=None):
        if port is not None:
            self.local_server_port = port
        debug_print('Server Started, initializing...')
        self.webPage.setUrl(f'{self.get_docroot()}/webgl')

    @Slot(str)
    def set_webgl_detection(self,status=None):
        if status == 'NO':
            self.webgl_enabled = False

    def get_docroot(self):
        if self.local_server_port:
            return f'http://localhost:{self.local_server_port}'
        return None

    def load_back(self):
        self.browsing_history = True
        self.webEngineView.back()

    def load_forward(self):
        self.browsing_history = True
        self.webEngineView.forward()

    def load_reload(self):
        self.webEngineView.reload()

    def normpath(self,path):
        if path[:2] == '//':
            path = path[1:]
        return os.path.normpath(path)

    def load_url(self,url):
        global currentActivity, LANG
        currentActivity = None
        debug_print('load_url: {}'.format(url))

        if not isinstance(url,QUrl):
            url = QUrl(url)

        parts = url.path().split('/')
        if parts and len(parts) > 2:
            if parts[1] == 'resources':
                currentActivity = parts[2] if parts[2] else None

        target_html = None
        target_url = None
        if currentActivity:
            activity_properties = self.server.tm.projects.get(f'{RESOURCE_DIR}/{currentActivity}')
            if self.browsing_history:
                self.browsing_history = False
                if len(parts) > 3:
                    for key,value in activity_properties.items():
                        if not key.startswith('html_'):
                            continue
                        if value == parts[3]:
                            if key.startswith('html_'):
                                language = key[len('html_'):]
                                a= QSignalBlocker(self.language_selector)
                                self.set_language(language,go=False)
                                a.unblock()
                                return
                            break
            if activity_properties and LANG in activity_properties.get('languages') and activity_properties.get(f'name_{LANG}'):
                self.setWindowTitle(activity_properties.get(f'name_{LANG}').capitalize())
                if self.language_changed:
                    self.language_changed = False
                    target_html = activity_properties.get(f'html_{LANG}')
                    target_url = f'{self.get_docroot()}/resources/{currentActivity}/{target_html}'
                    url = target_url
            print(_('Current activity: {}').format(currentActivity))

        if not isinstance(url,QUrl):
            url = QUrl(url)
        scheme=url.scheme()
        params=''
        query = url.query()
        path = url.path()
        host = url.host()
        port = url.port()
        self.in_category = False
        if query:
            parts = query.split('&')
            query = []
            category = None
            for part in parts:
                try:
                    k,v = part.split('=')
                except:
                    k = part
                    v = ''
                if k not in ['easy','normal','hard']:
                    query.append(part)
                    if k == 'category':
                        category = str(v)
            if path == "/home":
                if category:
                    self.setWindowTitle(_(category).capitalize())
                    self.in_category = category
                else:
                    self.setWindowTitle(_('Simplayer').capitalize())

            # easy,normal,hard = self.get_levels()
            # query.append(f'easy={easy}')
            # query.append(f'normal={normal}')
            # query.append(f'hard={hard}')
            params = '&'.join(query)
        if params:
            params = f'?{params}'

        #url = QUrl(scheme+':'+os.path.normpath(url.toString(QUrl.FormattingOptions(QUrl.RemoveScheme))))
        url = QUrl(f'{scheme}://{host}:{port}{self.normpath(path)}{params}')

        # if DEBUG:
        #     print('{} {} {}'.format(_("Loading url"),url.toString(),_("Valid!") if url.isValid() else _("Not valid!")))

        self.browsing_history = False
        self.level_changed = False

        return url

    def loadFinished(self, status):
        pass

    def urlChanged(self, url):
        url_txt = url.toString()

        self.objects.get('button_{}'.format('back')).setEnabled(self.webEngineView.history().canGoBack())
        self.objects.get('button_{}'.format('forward')).setEnabled(self.webEngineView.history().canGoForward())
        self.debug_history()

        debug_print(f'{_("URL changed")} {url_txt}')


if __name__ == '__main__':
    # QApplication.setAttribute(Qt.AA_UseOpenGLES,True)
    # QApplication.setAttribute(Qt.AA_UseSoftwareOpenGL,True)
    # QApplication.setAttribute(Qt.AA_ShareOpenGLContexts,True)
    # download_libs()
    # if os.path.isfile(FLASH_PPAPI):
    #     sys.argv.append('--no-sandbox')
    #     sys.argv.append(f'--ppapi-flash-path={FLASH_PPAPI}')
    #     sys.argv.append('--ppapi-flash-version=32.0.0.151')
    #     print('Running without sandbox, flash available')
    if DEBUG:
        print('{} {}'.format(_('Detected language'),LANG))
    QApplication.setAttribute(Qt.AA_EnableHighDpiScaling,True)
    param=""
    for i in range(len(sys.argv)):
        if sys.argv[i] == '-a' and i+1 < len(sys.argv):
            param=sys.argv[i+1]
            break
    app = QApplication(sys.argv)
    mainWin = MainWindow(activity=param)
    try:
        availableGeometry = mainWin.screen().availableGeometry()
    except:
        availableGeometry = mainWin.geometry()
    #mainWin.resize(availableGeometry.width() * 2 / 3, availableGeometry.height() * 2 / 3)
    mainWin.resize(1280,1024)
    qr=mainWin.frameGeometry()
    cp=availableGeometry.center()
    qr.moveCenter(cp)
    mainWin.move(qr.topLeft())
    mainWin.show()
    sys.exit(app.exec_())
