#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Copyright 2016 EDF R&D
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License Version 3 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, you may download a copy of license
# from https://www.gnu.org/licenses/gpl-3.0.

"""Main start-up point of AsterStudy application."""

from __future__ import unicode_literals

import os
import sys
import optparse
import traceback

LIBDIR = ''

# Add libdir to sys.path.
if LIBDIR != '@' 'LIBDIR' '@':
    # ... for install tree.
    if not os.path.isabs(LIBDIR):
        LIBDIR = os.path.join(os.path.dirname(os.path.realpath(__file__)),
                              LIBDIR)
        LIBDIR = os.path.abspath(LIBDIR)
    sys.path.insert(0, LIBDIR)
else:
    # ... for source tree.
    sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)))

try:
    # pragma pylint: disable=wrong-import-position,relative-import
    from asterstudy.common import CFG, debug_mode, enable_except_hook, version
    from asterstudy.datamodel import init_default_engine, Engine
    from asterstudy.gui.asterstdgui import AsterStdGui
except ImportError as err:
    sys.stderr.write("abort: couldn't find astergui libraries in [%s]\n" %
                     ' '.join(sys.path))
    sys.stderr.write("(check your install and PYTHONPATH)\n")
    if os.getenv("DEBUG", 0):
        sys.stderr.write("ERROR: %s\n" % err)
        traceback.print_exc()
    sys.exit(-1)

# pragma pylint: disable=too-many-branches
def main():
    """Main function."""

    # Parse command line.
    usage = "%prog [options] [STUDY_FILE]"
    description = "GUI framework for code_aster."
    parser = optparse.OptionParser(usage=usage, description=description)
    parser.add_option("-v", "--version", action="store_true", dest="version",
                      help="show program's version number and exit")
    parser.add_option("-g", "--debug", action="store_true", dest="debug",
                      help="run in debug mode")
    parser.add_option("-b", "--basicnaming", action="store_true",
                      dest="basicnaming",
                      help="use basic naming (instead of default/automatic)")
    parser.add_option("-n", "--noexhook", action="store_true",
                      dest="no_exc_hook",
                      help="switch off custom exception hook")
    parser.add_option("-c", "--nativenames", action="store_true",
                      dest="native_names",
                      help="switch off business-oriented translation "
                      "of code_aster dictionary")
    cmd_opts, cmd_args = parser.parse_args(sys.argv[1:])

    if cmd_opts.version:
        sys.stdout.write("AsterStudy %s\n" % version())
        sys.exit(0)

    if cmd_opts.debug:
        debug_mode.DEBUG = 1

    if not cmd_opts.no_exc_hook:
        enable_except_hook(True)
    else:
        try:
            import ptvsd
            ptvsd.enable_attach(secret="my_secret", address = ('0.0.0.0', 3000)) # may be secret=None
            # ptvsd.wait_for_attach() # uncomment this line if you want to wait a debug connection.
        except:
            pass

    if cmd_opts.basicnaming:
        os.environ["ASTERSTUDY_NAMING"] = "basic"

    if cmd_opts.native_names:
        os.environ["ASTERSTUDY_NATIVE_NAMES"] = "1"

    from PyQt5.Qt import QApplication, QLibraryInfo, QTranslator

    # Initialize application and settings
    app = QApplication(sys.argv)
    app.setOrganizationName("salome")
    app.setOrganizationDomain("edf.fr")
    app.setApplicationName("AsterStudy")

    # Set application language
    language = AsterStdGui.preferencesMgr().value("language")

    # Load Qt translations
    qt_translations_dir = QLibraryInfo.location(QLibraryInfo.TranslationsPath)
    for qt_tr in ["qt", "qtbase"]:
        translator = QTranslator(app)
        if translator.load(qt_tr + "_%s" % language, qt_translations_dir):
            app.installTranslator(translator)

    # Load AsterStudy translations
    for aster_tr in ["AsterStudy", "AsterStudyCommands"]:
        translator = QTranslator(app)
        if translator.load(aster_tr + "_msg_%s" % language, CFG.rcdir):
            app.installTranslator(translator)

    # Load additional translations
    try:
        import PyConsolePy # pragma pylint: disable=unused-variable
        gui_root = os.getenv("GUI_ROOT_DIR")
        pc_root = os.getenv("PYCONSOLE_ROOT_DIR")
        translator = QTranslator(app)
        if pc_root:
            pc_root = os.path.join(pc_root, "share", "resources")
            if translator.load("PyConsole_msg_%s" % language, pc_root):
                app.installTranslator(translator)
        elif gui_root:
            gui_root = os.path.join(gui_root, "share", "salome",
                                    "resources", "gui")
            if translator.load("PyConsole_msg_%s" % language, gui_root):
                app.installTranslator(translator)
    except ImportError:
        pass
    try:
        import PyEditorPy # pragma pylint: disable=unused-variable
        gui_root = os.getenv("GUI_ROOT_DIR")
        pe_root = os.getenv("PYEDITOR_ROOT_DIR")
        translator = QTranslator(app)
        if pe_root:
            pe_root = os.path.join(pe_root, "share", "resources")
            if translator.load("PyEditor_msg_%s" % language, pe_root):
                app.installTranslator(translator)
        elif gui_root:
            gui_root = os.path.join(gui_root, "share", "salome",
                                    "resources", "gui")
            if translator.load("PyEditor_msg_%s" % language, gui_root):
                app.installTranslator(translator)
    except ImportError:
        pass

    # initialize engine
    init_default_engine(Engine.AsRun)

    # Activate GUI and show main window
    asgui = AsterStdGui()
    asgui.initialize()
    if len(cmd_args) > 0:
        if not asgui.load(cmd_args[0]):
            sys.stderr.write("abort: couldn't load '%s'\n" % cmd_args[0])
            sys.exit(-1)
    asgui.mainWindow().show()

    # Start event loop
    return app.exec_()

if __name__ == "__main__":
    sys.exit(main())
