
import re, json
from   generic.gn_api       import   gn_api # 
from   generic.gn_request   import   Request # 
from  datetime              import datetime
import base64

class ideris(gn_api):
    def __init__(self, argv:list):
        self.db = False
        
        setup   = self.setup(argv)

        token = self.get_token_auth()
        
        #self.ApplicationToken  = setup[0][  'NMTOKEN1API']#002e6fc5f068d6323874
        #self.CompanyToken      = setup[0]['NMTOKEN1DADOS']#b42241b9-0f49-4177-814d-ba3d30883bb3
        self.ideris_request = Request(
                base_url = "{}".format(self.environment_config.get('url'))
            ,   headers={
                'Authorization'     : f'Bearer {token}'
            }) 
        
        super(ideris, self, ).__init__()
        
        print('Fim')

    def get_token_auth(self):
        token_req = Request(
            base_url = "{}".format(self.environment_config.get('url'))
        )

        token_jwt = token_req.doRequest(
            rote="login",
            data='"{}"'.format(self.get_token_data('ClientSecret')),
            method="POST",
            headers={
                "Content-Type" : "application/json"
            }
        )

        return token_jwt.text
   
    #     #####      ##    ######## #######   #####    #####   ######    ######     ##     #####
    #    ##   ##    ####   #  ##  #  ##  ##  ##   ##  ##   ##   ##  ##     ##      ####   ##   ##
    #    ##        ##  ##     ##     ##      ##       ##   ##   ##  ##     ##     ##  ##  ##
    #    ##        ######     ##     ####    ##       ##   ##   #####      ##     ######   #####
    #    ##        ##  ##     ##     ##      ##  ###  ##   ##   ####       ##     ##  ##       ##
    #    ##   ##   ##  ##     ##     ##  ##  ##   ##  ##   ##   ## ##      ##     ##  ##  ##   ##
    #     #####    ##  ##    ####   #######   #####    #####   ###  ##   ######   ##  ##   #####



    def beforeSend_category(self, data):

        if self.current_data['request_method'] == 'PUT':
            data['id'] = self.current_data['ideris_id']
            self.current_rote = "category"

        if  self.current_data['subgrupo'] != 0:
            data['parentCategoryId'] = self.translate(id = "{}.0".format(self.current_data['grupo']), table = "TBGRUPO")
        
        return data
    
    def post_route_handler_category(self):
        return self.handle_send()

    #    ######   ######    #####   ######    ##  ##  ########  #####    #####
    #     ##  ##   ##  ##  ##   ##   ##  ##   ##  ##  #  ##  # ##   ##  ##   ##
    #     ##  ##   ##  ##  ##   ##   ##  ##   ##  ##     ##    ##   ##  ##
    #     ##  ##   #####   ##   ##   ##  ##   ##  ##     ##    ##   ##   #####
    #     #####    ####    ##   ##   ##  ##   ##  ##     ##    ##   ##       ##
    #     ##       ## ##   ##   ##   ##  ##   ##  ##     ##    ##   ##  ##   ##
    #    ###      ###  ##   #####   ######     ####     ####    #####    #####


    def beforeSend_sku(self, data):
        if self.current_data['request_method'] == 'PUT':
            self.current_rote = "sku"

        if self.current_data['request_method'] == "POST":
            check_request = self.ideris_request.doRequest(rote="/sku/search?sku={}".format(self.current_data['sku']))

            if check_request.status_code == 200:
                self.current_method = "PUT"
                
                # Remove por segurança o nome do SKU 
                # para não atualizar os nomes na plataforma do clietne
                del data['title']

        return data
    
    def afterSend_sku(self, data):
        return data
    
    
    def afterSend_order_invoice(self, data) :
        self.getDb().delete(
                    "TBPEDIDOSFATURADOS"
                ,   ["IDTBPEDIDOSFATURADOS={}".format(self.current_data['softdib_id'] )]
                )
        pass
        
    def afterSend_order(self, data) :
        self.getDb().delete(
                    "TBPEDIDOSSTATUS"
                ,   ["IDTBPEDIDOSSTATUS={}".format(self.current_data['softdib_id'] )]
                )
        pass
        
        
    
    def post_route_handler_sku(self):

        return self.handle_send()
    
    ##   ##   #####   ########    ##             #######   ######   #####    #####      ##     ####
    ###  ##  ##   ##  #  ##  #   ####             ##  ##     ##    ##   ##  ##   ##    ####     ##
    #### ##  ##   ##     ##     ##  ##            ##         ##    ##       ##        ##  ##    ##
    ## ####  ##   ##     ##     ######            ####       ##     #####   ##        ######    ##
    ##  ###  ##   ##     ##     ##  ##            ##         ##         ##  ##        ##  ##    ##
    ##   ##  ##   ##     ##     ##  ##            ##         ##    ##   ##  ##   ##   ##  ##    ## ##
    ##   ##   #####     ####    ##  ##           ####      ######   #####    #####    ##  ##   ######


    def beforeSend_order_invoice(self, data):
        # Caso de algum erro ele irá cancelar o envio.
        try:
            with open(data['xml'], "rb") as xml_file:
                arquivo_xml = xml_file.read()
                data['xml'] = arquivo_xml
        except Exception as e:
            self.ignore_request = True
        
        
        orderId = self.getDb().simple_select(fields=["CDPEDIDOEXTERNO"], table="TBPEDIDOSRETORNO", where=["CDPEDIDO='{}'".format(data['orderId'])], onlyFirst=True)

        data['orderId'] = orderId['CDPEDIDOEXTERNO']
        
        if self.current_data['request_method'] == "DELETE":
            data['statusId'] = "1065"
        else:
            data['statusId'] = "1021"

        self.current_rote = "order/{}/invoice".format(data['orderId'])
            
        return data

    #--- ----------------------------------------------------#
    #--------------- TRATAMENTO ITEMS/PEDIDO ----------------#
    #--------------------------------------------------------#

    def filtrar_pedido(self, order):
        print(order)

        return order

    def afterGet_order_search(self, data):    
        return data.get('obj')
    
    def get_order_items(self, order):

        for index, item in enumerate(order['obj']['items']):
            order['obj']['items'][index]['orderId'] = order['obj']['id']

        return [ self.extractValues(item, "itenscarrinho_fields") for item in order['obj']['items']]
    
    def get_order_data(self, order) :
        req = self.ideris_request.doRequest(
            rote="order/{id}".format(id=order['id'])
        )
        
        if req.status_code == 200 :
            self.current_order =  self.tryJson(req)

            if self.current_order['obj']['deliveryType'] == "FULL":
                pedido = [ self.extractValues(self.current_order['obj'], 'pedido_fields') ]
                pedido[0]['CDFRETE'] = 0

                return pedido
            
            return [ self.extractValues(self.current_order['obj'], 'pedido_fields') ]
            
        return False
    
    def customer_data(self, data) :
            
        order = self.current_order['obj']

        data[     'TIPO_PESSOA'] = "F" if order['documentType'] == "CPF" else "J"
        data[        'CNPJ_CPF'] = self.only_numbers(order['documentValue'])
        data[        'ENDERECO'] = order['addressStreet']
        data[    'ENDERECO_NRO'] = order['addressNumber']
        data[     'COMPLEMENTO'] = order['addressComment']
        data[             'CEP'] = order['addressZipCode']
        data[          'BAIRRO'] = order['districtName']
        data[          'CIDADE'] = order['cityName']
        data[          'ESTADO'] = order['stateAbbreviation']
        
        data[        'TELEFONE'] = order['phoneNumber'].split("/")[0].strip()
        data[             'DDD'] = order['phoneAreaCode']
            
        #print(response)
        return data
    
    #--------------------------------------------------------#
    #--------------- TRATAMENTO FILTROS DE ROTA -------------#
    #--------------------------------------------------------#
    def rote_filter_order_search(self):
        
        sql =  """
            SELECT 
                DTULTIMAALTERACAO 
            FROM 
                TBRELACIONAID
            WHERE 
                1=1 
            AND 
                NMTABELA = '{table}'
            ORDER BY 
                DTULTIMAALTERACAO DESC 
            LIMIT 1;
        """.format(table=self.atualWs['table'])
        
        date = self.getDb().select(sql)
        
        if date:
            alterado_apos = date[0]['DTULTIMAALTERACAO']
        else :
            alterado_apos = "1980-01-01" 

        # statusId=1009&startDate=2024-11-23

        # Expedicao = 1009
        # Separação = 1008
        # Expedido = 1010
        # Em transito = 1011
        # Entregue = 1012
        # Pendente = 1019 
        # Aprovado = 1038 
        # Devoluçao/Troca = 7
        # Aberto = 1007
        # Faturar = 1067
        # Pagamento cancelado = 1017
        # Cancelado = 1015
        
        return  self.mountRouteParams(
            {
                #"orderId": "4"
                 "statusId" : "1007",
                 "startDate": alterado_apos 
            }
        )
    
    #--------------------------------------------------------#
    #--------------- TRATAMENTO DELETE ----------------------#
    #--------------------------------------------------------#
    
    def deleteFromApi(self, **data):
        
        rote = self.atualWs.get('rote')
        
        ideris_id  = data.get('ideris_id')
        softdib_id  = data.get('softdib_id')
        
        if not ideris_id: return 
        
        if  rote == 'sku':
            rote = f"sku/{ideris_id}"
        
        delete_params = {
                "rote"   : rote
            ,   "method" : "DELETE"
            ,   "data"   : {}
        }
        
        delete_reponse = self.throttling(**delete_params)
        
        delete_is_ok = delete_reponse.ok
        
        if not delete_is_ok:
            self.response_log(delete_reponse)
            
            
        
        if delete_is_ok:
            rote = self.atualWs.get('rote')
            if  rote == 'products/id/images':
                upload_id = self.translate(id = f"{softdib_id}" , table = "TBPRODUTOIMAGEMUPLOAD") 
                self.getDb().delete("TBRELACIONAID"
                ,   [
                            f"IDAPI='{upload_id}'"
                        ,   f"NMTABELA='TBPRODUTOIMAGEMUPLOAD'"
                        ,   f"NMNOMEAPI='sellent'"
                    ]
                )
            
            
            
            
        return delete_is_ok
    
    def response_code_200(self, response) :
        data = json.loads(response.text)

        if data['httpStatusCode'] == 400:
            return super().response_code_400(response)
        elif data['httpStatusCode'] == 200:
            return super().response_code_201(response)
        
    def custom_control_id_sku(self, response):
        return self.current_data['sku']
    
    def custom_control_id_order_invoice(self, response):
        return self.current_data['softdib_id']
    
    def cd_transportador(self, value, item):
        return ""
        opts = {
            "Mercado Livre": "L201",
            "Shopee": "L202",            
            "Amazon": "L203",
            "Pedido Manual": "L201"
        }
        
        

        return opts[value]
    
    def cd_origem(self, value, item):
        try:
            opts = {
                "Mercado Livre": "201",
                "Shopee": "202",            
                "Amazon": "203",
                "Pedido Manual": "201"
            }

            return opts[value]
        except:
            return '201'
    
    def cd_vendedor(self, value, item):
        try:
            opts = {
                "Mercado Livre": "V02001",
                "Shopee": "V00004",            
                "Amazon": "V00005",
                "Pedido Manual": "V02001"
            }

            return opts[value]
        except:
            return 'V10000'
    
    def qtd_sku(self, value, item):

        sku_check = self.sku.split('-')
        retorno = ""

        try:
            if len(sku_check) == 2:
                retorno = int(sku_check[1]) * int(value)
            else:
                retorno = value
        except:
            retorno = value

        return retorno
    
    def valor_sku(self, value, item):
        sku_check = self.sku.split('-')
        retorno = value

        try:
            if len(sku_check) == 2:
                retorno = float(value) / int(sku_check[1])
            else:
                retorno = value
        except:
            retorno = value

        return retorno
    
    def type_pay(self, value, item):
        opts = { 
            "9"  : "302", # "Boleto",
            "10" : "301", # "Cartão de crédito (Transação online)",
            "6"  : "300", # "Deposito em conta",
            "1"  : "300", # "Dinheiro",
            "4"  : "301", # "Mercado Livre",
            "2"  : "301", # "Mercado Pago",
            "8"  : "301", # "Mercado pago point",
            "7"  : "301", # "Outras formas de pagamento",
            "3"  : "301", # "PayPal",
            "5"  : "300" # "Troca",
        }

        return opts[f"{value}"]

        
        

    
    def sku_code(self, value, item):
        sku = value.split("-")

        return sku[0]
    
    def define_sd_request(self,rota='/integracao/pedido/authentication'):
        """ 
            Monta a estrutura base de headers e paramentros para consumir ou enivar dados para api softdib
        """
        
        prot = "http://"
        base = "192.168.1.3" if self.debug else self.softdib_ip
        port = f':{self.softdib_port or 3000}'#.format()
        base_url = f"{prot}{base}{port}"
        #""" .format(
        #            prot=prot
        #        ,   base=base
        #        ,   port=port
        #) """
        
        auth = Request(
            base_url  =   base_url 
        )
        auth_res = auth.doRequest(
            rote  = rota,
            method  =   "post", 
            json    =
            {
                    "user"      : "SAC"
                ,   "lkgp"      : self.nmlkgrupo
                ,   "banco"     : self.nmbanco
                ,   "apiname"   : self.apiName
                ,   "empresa"   : self.cdempresa
                ,   "filial"    : self.cdfilial
            }
        )
        
        if auth_res.status_code != 200 :
            
            print(f"Falhou: {auth_res.status_code} - {auth_res.reason}")#.format(auth_res.status_code))
            exit()
            
        
        self.softdib_request = Request(
            base_url = base_url,
            headers = {
                "Content-Type": "application/json"
                ,"Accept": "application/json"
                ,"x-access-token": auth_res.text.replace('"','')
            }
        )
        print(self.softdib_request)
    
    def custom_control_id(self, response):
        data = json.loads(response.text)

        return data['obj']['id']
        
    def pagination_rules(self, req, data):
        return None
    
    
    def __del__(self):
        self.createLog("999","Final da exportacao")
    
    
    
    
    
    
    
    
    