import json
import random

from   generic.gn_api       import   gn_api # 
from   generic.gn_request   import   Request # 
from   generic.Criptografia import Criptografia



class sellentt(gn_api):
    def __init__(self, argv:list):
        self.db = False
        
        self.setup, = self.setup(argv)
        self.sellentt_default_request()
        #varivel local apenas para sellent, guardar o user group recuperado
        self.user_group_sellent = {}
        self.grupos_economicos = {}
        super(sellentt, self, ).__init__()
        
    def sellentt_montar_request(self, **kwargs):

        base_url = self.environment_config.get('url')#'https://app.pedidosdigitais.com.br/api/v2/'
        headers = {
                #'Authorization': 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpYXQiOjE2NTcyMjAyODksImlzcyI6ImFwcC5wZWRpZG9zZGlnaXRhaXMuY29tLmJyIiwiaWQiOjM0LCJjbGllbnRfaWQiOjQyOX0.EfUKLHz9wVP0CCKE7OYtt6o3SC4l_DHYh6xeFExMhd0',
                **self.get_token('Authorization'),
                **kwargs.get('headers',{})
        }
        
        params = {
            "base_url" : base_url
        ,   "headers" : headers
        ,   **kwargs.get('params',{})
        }
        
        
        self.api_request = self.sellentt_request = Request(**params)
        
        
        
    def sellentt_default_request(self):
        self.sellentt_montar_request(headers={'Content-Type':'application/x-www-form-urlencoded',})
        
    def sellent_json_request(self):
        self.sellentt_montar_request(headers={"Content-Type":"application/json" })
        
    def sellentt_upload_request(self):
        # e esperado sempre que sejam arquivos png
        
        file_upload = self.current_data.get('file_upload','')
        self.sellentt_montar_request(
            params = {
                'files':{ 'file': open(file_upload,'rb') }
            }
        )
        
        
    #--------------------------------------------------------#
    #-----------------TRATAMENTO DOS CUSTOM------------------#
    #--------------------------------------------------------#
    
    def products_price_list(self, data):
        return """ 
            (
                SELECT
                    GROUP_CONCAT(
                        DISTINCT "{",
                        '"price":',
                        TBTABPRECOPRODUTO.VLPRODUTO,
                        ",",
                        '"erp_id":' '"',
                        TBTABPRECOPRODUTO.CDPRODUTO,
                        '"' "}"
                    ) AS tmp
                FROM
                    TBTABPRECOPRODUTO
                WHERE
                    TBTABPRECOPRODUTO.CDTABELA = TBTABPRECO.CDTABELA
            )
            
        
        """
    
    #--------------------------------------------------------#
    #--------------- TRATAMENTO BEFORE SEND     -------------#
    #--------------------------------------------------------#
    
    def beforeSend_categories(self, data):
        self.sellentt_default_request() 
        if  self.current_data['sub_grupo'] == 0:
            del data['parent_id']
        else:
            data['parent_id'] = self.translate(id = self.current_data.get('parent_id','0'), table = "TBGRUPO")
        return data
    
    def beforeSend_stores(self, data):
        self.sellent_json_request()
        
        grupo_economico_id = self.verificar_grupo_economico(data)
        
        if not grupo_economico_id:
            data['company_id'] = "4309405" # Para nao criar milhares de itens desnecessarios
        else:
            data['company_id'] = "{}".format(grupo_economico_id)
        
        
        return data
        
        
    # Talvez a mairo das gambs
    def beforeSend_companies(self, data):                      self.sellentt_default_request()          
    def beforeSend_users(self, data):                          self.sellentt_default_request()          
    def beforeSend_seller(self, data):                         self.sellentt_default_request()    
    def beforeSend_seller_id_users_user_id(self, data):        self.sellentt_default_request() 
    def beforeSend_products(self, data):                       self.sellent_json_request()
    def beforeSend_uploads(self, data):                        self.sellentt_upload_request()
    def beforeSend_products_id_images(self, data):             self.sellentt_default_request()
    def beforeSend_campos_extras(self, data):                  self.sellentt_default_request()             
    def beforeSend_orders_status(self, data):                  self.sellentt_default_request()
    def beforeSend_order_type(self, data):                     self.sellentt_default_request()          
    def beforeSend_payment_method(self, data):                 self.sellentt_default_request()
    def beforeSend_payment_term(self, data):                   self.sellentt_default_request()
    def beforeSend_price_table(self, data):                    self.sellent_json_request()
    def beforeSend_users_groups(self, data):                   self.sellent_json_request()
    def beforeSend_transport_company(self, data):              self.sellentt_default_request()                             
    def beforeSend_seller_id_stores_store_id(self, data):      self.sellentt_default_request()    
    def beforeSend_fiscal_ncm_ncm_id(self, data):              self.sellentt_default_request()    
        
        
    def afterSend_orders_code(self, data) :
        softdib_id = self.current_data.get('softdib_id')
        api_name   = self.apiName
        
        return softdib_id and self.getDb().delete("TBPEDIDOSSTATUS"
        ,   [f"IDTBPEDIDOSSTATUS='{softdib_id}'", f"NMAPI='{api_name}'"]
        )
        
    
    #--------------------------------------------------------#
    #--------------- TRATAMENTO FILTROS DE ROTA -------------#
    #--------------------------------------------------------#
    def rote_filter_orders(self):
        # 0 - False, 1 - True
        return  self.mountRouteParams(
            {
                #"pending_integration": '1',
                "after": "2023-12-10 08:00:00",
                # "code": 45
            }
            )
        
        
    def dateLastChanges(self):
        return self.current_order.get('modified')
    
    
    #--------------------------------------------------------#
    #------------------ TRATAMENTO RESPONSE  ----------------#
    #--------------------------------------------------------#
    
    def response_code_200(self, response) :
        return super().response_code_201(response)
    
    
    def afterGet_orders(self, data):    
        return data.get('data')
        
    
    #--------------------------------------------------------#
    #-----------------TRATAMENTO DOS CUSTOM REPLACEMENT -----#
    #--------------------------------------------------------#
    
    def descriptografar_senha(self, valor):
        return "sellentt_"+Criptografia.descriptografar(valor)
    
    def estado_regiao(self, estado_desejado):
        regioes_por_estado = '''
            {
                "005-Norte": ["AC", "AP", "AM", "PA", "RO", "RR", "TO"],
                "004-Nordeste": ["AL", "BA", "CE", "MA", "PB", "PE", "PI", "RN", "SE"],
                "003-Centro-Oeste": ["DF", "GO", "MT", "MS"],
                "002-Sudeste": ["ES", "MG", "RJ", "SP"],
                "001-Sul": ["PR", "RS", "SC"]
            }
        '''
        
        dict_regioes_por_estado = json.loads(regioes_por_estado)

        
        for regiao, estados in dict_regioes_por_estado.items():
            if estado_desejado in estados:
                return regiao.split('-')[0]
            
        return ""
    
    def status_color(self, valor):
        
        colors = {
            1 : "#03fc4e",
            2 : "#f5b916",
            3 : "#f56b16",
            4 : "#c9162b",
            5 : "#c9162b",
            6 : "#c9162b",
            7 : "#16f591"
        }
        
        
        return colors.get(valor, "#a1a1a1")
            
    def cep_format(self, valor):
        #82700-370
        return '{}{}{}{}{}-{}{}{}'.format(*(str(valor).zfill(8)))
        
        
    
    
    
    def validar_quantidade(self, valor):
        size_value = len(valor)
        return valor if size_value >= 10 and size_value <= 11 else ''
    
    
    def recuperar_group_id_para_companies(self, valor):
        
        if not self.user_group_sellent:
            response = self.throttling(rote='users/groups',method='GET')
            if response.ok:
                json = response.json()
                self.user_group_sellent = json.get('data', {})
        
        user_group = list(filter(lambda obj: obj.get('name') == valor , self.user_group_sellent))
        
        return (user_group and user_group[0].get('id',0)) or 0
    
    
    def buscar_grupos_economicos(self):
        print("INTEGRACAO: Buscando grupos economicos...")
        response = self.throttling(rote='companies',method='GET')
        
        if response.ok:
            resp_data = response.json()
            
            meta_dados = resp_data.get('meta', {})
            
            current_page = meta_dados['current_page']
            
            self.grupos_economicos = resp_data.get('data', {})
            
            while(meta_dados['last_page'] != current_page):
                current_page += 1
                
                response = self.throttling(rote=f'companies?page={current_page}',method='GET')
                
                if response.ok:
                    resp_data = response.json()
                    
                    self.grupos_economicos += resp_data.get('data', {})
                    
                    meta_dados = resp_data.get('meta', {})
                    current_page = meta_dados['current_page']
            
        
    def verificar_grupo_economico(self, valor):
        
        if not valor['company_id']:
            return
        
        if not self.grupos_economicos:
            self.buscar_grupos_economicos()
    
        user_group = list(filter(lambda obj: obj.get('name') == valor['company_id'], self.grupos_economicos))

        if not user_group: 
            
            # Reseta os grupos economicos para sincronizar novamente.
            self.grupos_economicos = False
            print("INTEGRACAO: Grupo economico não registrado, incluindo...")
           
            json_data = {
                "code": random.randint(1000, 100000),
                "name": valor['company_id'],
                "group_id": valor['segment_id']
            }
            
            params = {
                "rote"    : "companies"
                ,   "method"  : "POST"
                ,   "data"  : json.dumps(json_data)
            }
            
            response = self.api_request.doRequest(**params)
            
            if response.ok:
                created_data = response.json()
                novo_grupo = created_data.get('data', {})
                
                return novo_grupo.get('id', 0)
        else:
            return (user_group and user_group[0].get('id',0)) or 0
        # else:
        #     Exception()
        
    
    #--------------------------------------------------------#
    #--------------- TRATAMENTO PEDIDO/CUSTOM- ---------------#
    #--------------------------------------------------------#

    def shipping_type_id(self, value):
        
        # 1-CIF-Frete por conta do Remetente	
        # 2-FOB-Frete por conta do Destinatario	
        # 3-CIF + FOB	
        # 4-Terceiros	
        # 9-Sem Frete
        tipo_frete = {
            "CIF": "1",
            "FOB": "2",
            
        }
        
        return tipo_frete.get(value, '1') ##'9' if 'PARTICULAR' in value or not value else '1'
        
    
    def tipo_pessoa(self, data):
        return "J" if data == 'cnpj' else "F"
        
        
    
    #--------------------------------------------------------#
    #--------------- TRATAMENTO PEDIDO/ITEMS- ---------------#
    #--------------------------------------------------------#
    
    
    def get_order_items(self, order) :
        return [ self.extractValues(item, "itenscarrinho_fields") for item in order['products']]
        
    
    def get_order_data(self, order) :
        return [ self.extractValues(order, 'pedido_fields') ]
        
    
    #--------------------------------------------------------#
    #--------------- TRATAMENTO DELETE ----------------------#
    #--------------------------------------------------------#
    
    def deleteFromApi(self, **data):
        
        
        self.sellentt_montar_request()
        rote = self.atualWs.get('rote')
        
        sellent_id  = data.get('sellentt_id')
        softdib_id  = data.get('softdib_id')
        
        if not sellent_id: return 
        
        if  rote == 'seller/id/stores/store_id':
            softdib_vendedor_id, softdib_cliente_id = softdib_id.split("-")
            
            sellent_seller_id   = self.translate(id = softdib_vendedor_id, table = "TBVENDEDOR") 
            sellent_store_id    = self.translate(id = softdib_cliente_id , table = "TBCLIENTE") 
            rote = f"seller/{sellent_seller_id}/stores/{sellent_store_id}"
        
        elif rote == 'seller/id/users/user_id':
            
            softdib_usuario_id, softdib_vendedor_id = softdib_id.split("-")
            
            sellent_seller_id   = self.translate(id = softdib_vendedor_id, table = "TBVENDEDOR") 
            sellent_users_id    = self.translate(id = softdib_usuario_id , table = "TBUSUARIO") 
            rote = f"seller/{sellent_seller_id}/users/{sellent_users_id}"
            
        
        elif rote == 'products/id/images':
            softdib_produto_id, seq  = softdib_id.split("-")
            sellent_product_id   = self.translate(id = softdib_produto_id, table = "TBPRODUTO") 
            
            rote = f'products/{sellent_product_id}/images/{sellent_id}'
        else:
            rote = f"{rote}/{sellent_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 __del__(self):
        self.createLog("999","Final da exportacao")
        