import  os
from    QT.Main_Window      import Main_Window, QtWidgets
from    Order_Display       import Order_Display
from    Login               import Login_Dialog
from    App_State           import App_State
import  designbox_orders_rc
import  schema              
import  pathlib
from lxml                   import etree

class Order_Processing (Main_Window) :

    APP_NAME                = "Designbox Orders"
    VERSION                 = "0.5"
    APP_ORGANISATION        = ("designbox-orders", "glaser-co.at")
    APP_DIR                 = os.path.dirname (__file__)

    @classmethod
    def _load_app_settings (cls, settings) :
        settings.beginGroup ("TempSettings")
        result = {"database" : settings.value ("database")}
        result = {"username" : settings.value ("username")}
        settings.endGroup ()
        return result
    # end def _load_app_settings

    def _setupActions (self, app) :
        super ()._setupActions (app)
        self._add_action ("test",  "Scan Dir", self.scan_orders_directory)
    # end def _setupActions
       
    def _setupGui (self) :
        self.main_menu = QtWidgets.QMenuBar  (self)
        self.setMenuBar                      (self.main_menu)
        file = QtWidgets.QMenu               ("& File")
        self.main_menu.addMenu               (file)
        self.tool_bar_file = self.addToolBar ("File")
        self.tool_bar_file.setObjectName     ("tb_file")
        for a, l in ( ( self.actions.exit
                      , (file, self.tool_bar_file)
                      )
                    , ( (self.actions.test), (self.tool_bar_file, ))
                    ) : 
            for x in l :
                x.addAction (a)
        self.setCentralWidget (Order_Display (self))
        settings = self.settings
        settings.beginGroup         ("TempSettings")
        user_id = settings.value    ("user_id")
        settings.endGroup           ()
        with schema.orm.db_session :
            App_State.user_id = schema.User [user_id].id
        self.scan_orders_directory  ()
    # end def _setupGui
    
    def _find_orders (self, root_path : pathlib.Path) :
        result = set ()
        for path, dirs, files in root_path.walk () :
            for f in files :
                if f.endswith (".txt") :
                    xml_name = (path / f).with_suffix (".xml")
                    if xml_name.exists () :
                        result.add (xml_name)
            for d in dirs :
                result.intersection_update (self._find_orders (root_path / d))
        return result        
    # end def _find_orders
    
    def scan_orders_directory (self) :
        with schema.orm.db_session :
            state = schema.State.get ()
        orders = self._find_orders (pathlib.Path (state.imos_export_dir))
        with schema.orm.db_session :
            for o in orders :
                self._update_order_in_database (o)
        self.centralWidget ().update_orders ()
    # end def scan_orders_directory
    
    def _update_order_in_database (self, xml_file) :
        basket_no = xml_file.stem
        if True :
            order = schema.Order.get (basket_no = basket_no)
            if not order :
                xml       = etree.parse (xml_file).getroot ()
                com       = xml.xpath ("//TEXT_SHORT") [0].text
                user,line = xml.xpath ("//RETAILER") [0].text.split ("/")
                order = schema.Order \
                    ( basket_no         = basket_no
                    , state             = 0
                    , commission        = com
                    , imos_user         = user
                    , production_line   = schema.Production_Line.get (short = line)
                    , active            = True
                    )
                schema.Action \
                    ( user              = schema.User [App_State.user_id]
                    , date              = schema.datetime.now ()
                    , action_kind       = 1
                    , action            = "Auftrag importiert"
                    , order             = order
                    )
    # end def _update_order_in_database
    
    def _restore_settings (self) :
        super ()._restore_settings ()
        self.centralWidget ().restore_settings (self.settings)
    # end def _restore_settings

    def save_settings (self) :
        settings = self.settings
        super ().save_settings ()
        self.centralWidget ().save_settings (settings)
        settings.beginGroup         ("TempSettings")
        settings.setValue           ("user_id", App_State.user_id)
        settings.endGroup           ()
    # end def save_settings
        
    @classmethod
    def pre_main_window_action (cls, settings) :
        settings.beginGroup         ("TempSettings")
        db_file = settings.value    ("database")
        user_id = settings.value    ("user_id")
        settings.endGroup           ()
        schema.db.bind              (provider = "sqlite", filename = db_file)
        schema.db.generate_mapping  (create_tables = False)
        username = ""
        if user_id :
            with schema.orm.db_session :
                username = schema.User [user_id].username
        if False :
            login = Login_Dialog (username)
            if login.exec () == 1 :
                settings.beginGroup         ("TempSettings")
                settings.setValue           ("user_id", login.user_id)
                settings.endGroup           ()
                return True
        else :
            print ("### Login skipped")
            return True
    # end def pre_main_window_action
    
# end class Order_Processing
    
if __name__ == "__main__" :
    import argparse
    parser = argparse.ArgumentParser ()
    parser.add_argument ("-s","--settings-file",    type = str)
    parser.add_argument ("-d", "--database",        type = str)
    cmd    = parser.parse_args ()
    Order_Processing.run (Order_Processing.load_settings (cmd))