import os
import re
import json
import shutil
import zipfile
import calendar
import threading
# import pandas as pd
import subprocess
from datetime import date
from time import sleep,perf_counter
import pyautogui as pt
from selenium import webdriver
from datetime import date as dt
from io import BytesIO, StringIO
from datetime import date, timedelta
from markupsafe import escape, Markup
from werkzeug.utils import secure_filename
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver.common.by import By
from werkzeug.datastructures import FileStorage
from selenium.webdriver.chrome.options import Options
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.support.ui import WebDriverWait, Select
from selenium.webdriver.support import expected_conditions as EC
from flask import Flask, jsonify, request, request, abort, url_for, render_template, send_from_directory, redirect
try:
    import modulos as md
except:
    try:
        from . import modulos as md
    except:
        pass
try:
    import conn_fileserver as MVF
    import extract_data as Extrair
except:
    try:
        from . import conn_fileserver as MVF
        from . import extract_data as Extrair
    except:
        pass
try:
    import models_ as db
except:
    try:
        import models as db
    except:
        pass


pasta_bots=os.path.join(os.path.expanduser("~"), "api/estrutura_api/api/utils/bots")
upload_folder=os.path.join(os.path.expanduser("~"), ".arquivos_api")

data_vigente={'mes':int(dt.today().month-1),'ano':dt.today().year, "mes_int":int(dt.today().month-1)}
match int(data_vigente['mes']):
    case 1:
        data_vigente['mes']=f'0{data_vigente['mes']}-jan'
    case 2:
        data_vigente['mes']=f'0{data_vigente['mes']}-fev'
    case 3:
        data_vigente['mes']=f'0{data_vigente['mes']}-mar'
    case 4:
        data_vigente['mes']=f'0{data_vigente['mes']}-abr'
    case 5:
        data_vigente['mes']=f'0{data_vigente['mes']}-mai'
    case 6:
        data_vigente['mes']=f'0{data_vigente['mes']}-jun'
    case 7:
        data_vigente['mes']=f'0{data_vigente['mes']}-jul'
    case 8:
        data_vigente['mes']=f'0{data_vigente['mes']}-ago'
    case 9:
        data_vigente['mes']=f'0{data_vigente['mes']}-set'
    case 10:
        data_vigente['mes']=f'{data_vigente['mes']}-out'
    case 11:
        data_vigente['mes']=f'{data_vigente['mes']}-nov'
    case 12:
        data_vigente['mes']=f'-{data_vigente['mes']}-dez'

def worker_0(driver):
    sleep(15)
    try:
        driver.find_element(By.CSS_SELECTOR, ".col-sm-12 > h3 > b").text
        driver.quit()
        sleep(5)
        return
    except:
        pass

def formatar_data(data=None,mode='str_format'):
	if mode=='str_format' and data!=None:
		mes_formatado=None
		match data:
			case '01'| 1:
				mes_formatado=f'{data}-jan'
			case '02'|2:
				mes_formatado=f'{data}-fev'
			case '03'|3:
				mes_formatado=f'{data}-mar'
			case '04'|4:
				mes_formatado=f'{data}-abr'
			case '05'|5:
				mes_formatado=f'{data}-mai'
			case '06'|6:
				mes_formatado=f'{data}-jun'
			case '07'|7:
				mes_formatado=f'{data}-jul'
			case '08'|8:
				mes_formatado=f'{data}-ago'
			case '09'|9:
				mes_formatado=f'{data}-set'
			case '10'|10:
				mes_formatado=f'{data}-out'
			case '11'|11:
				mes_formatado=f'{data}-nov'
			case '12'|12:
				mes_formatado=f'-{data}-dez'
	if mode=='int':
		mes_formatado=int(re.sub(r'\D','',str(data)))
	
	return mes_formatado

pasta_download=os.path.join(os.path.expanduser('~'),'downloads')

class ScriptJS:
    def exec_script(driver,script):
        driver.execute_script(script)
        sleep(1.5)
        return 

class MoverArquivos:
    def __init__(self, origem ,destino, nome_arquivo):
        try:
            pasta_destino=os.path.join(os.path.expanduser('~'), f'.arquivos_api/{destino}')
            os.makedirs(pasta_destino, exist_ok=True)
            if nome_arquivo not in os.listdir(pasta_destino):
                shutil.move(os.path.join(pasta_download, origem), os.path.join(pasta_destino, nome_arquivo))
                print('Arquivo movido')
            else:
                print("arquivo já consta")
                os.remove(os.path.join(pasta_download, origem))
        except Exception as e:
            print(f'Erro ao mover arquivo -> {pasta_destino}')
        return None

def verificar_arquivo(local_arquivo):
    arquivo=False
    
    rota=os.path.join(os.path.expanduser('~'), f'{local_arquivo}')
    arquivo=True if os.path.isfile(rota) else False
    print(f'RETORNO VERIFICAÇÃO ARQUIVO: {arquivo}')
    return arquivo

def verificar_notas(cnpj, controle:list, mes, empresa:dict):
    """
       Efetua o callback dos modulos de calculo da quantidade de notas e margem de erro, 
       e gera o relatorio base em pdf
    """
    pass
    for i in range(2):
        md.VerificarNT(cnpj, mes)
        sleep(5)
    with open(f"{pasta_bots}/controle/chave_nt.json", 'r', encoding='utf-8') as f:
        chaves_nt=json.load(f)
    emp=[list(i.keys())[0] for i in chaves_nt]
    print(f"cnpj -> {cnpj} margem de erro -> {chaves_nt[emp.index(cnpj)]["margem_err"]}")
    if chaves_nt[emp.index(cnpj)]["margem_err"]=="0.00%":
        if isinstance(controle, list):
            controle.append({f"{empresa['razao']}":date.today().isoformat()})
        with open(f"{pasta_bots}/controle/controle.json", 'w') as f:json.dump(controle,f,indent=4,ensure_ascii=False )
        os.makedirs(os.path.join(upload_folder,f"{cnpj}/{mes}/{str(data_vigente['ano'])}/relatorios"), exist_ok=True)
        md.GerarRelatorio(os.path.join(upload_folder,f"{cnpj}/{mes}/{str(data_vigente['ano'])}/relatorios")).gerar_arquivo()
    
    return

def request_IM(driver, argKey):
    #argKey=re.sub(r'\D','',argKey)
    driver.switch_to.default_content()
    im_company=driver.find_element(By.ID, 'lblCae').text
    try:
        id_request_company=0
        modalidade=''
        for i in db.SQLConn().parametro_read():
            if i['cnpj']==argKey:
                id_request_company=i['id']
                modalidade=i['modalidade']
    except Exception as e:
        print(f'Error to find company! {e}')
    finally:
        if id_request_company!=None and modalidade!='':
            im_company=im_company[17:]
            print(id_request_company)
            db.SQLConn().parametro_update(id=id_request_company, coluna='im', valor=str(im_company))
            print('Inscrição Municipal Alterada!')
            

    return driver.switch_to.frame(driver.find_element(By.ID, 'iframe'))

def requestUrlLIVRO(driver, argKey):
    if int(data_vigente['mes_int'])<10:
        data_vigente['mes_int']=int(f"0{data_vigente['mes_int']}")
        
    argKey=re.sub(r'\D','',argKey)
    driver.switch_to.default_content()
    firstDayMonth=date.today().replace(day=1)
    countPreviousMonth=(firstDayMonth-timedelta(days=1)).day
    print(countPreviousMonth)

    if verificar_arquivo(f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/livros/Livro Fiscal Serviços Prestados ISSQN-{data_vigente['mes']}-{data_vigente['ano']}.pdf') :
        return
    else:
        driver.execute_script("function requestLivro(valueIndex){if(document.querySelectorAll('a.rtIn')[valueIndex].innerHTML=='Emitir Livro Fiscal' ){document.querySelectorAll('a.rtIn')[valueIndex].click() } }; for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){requestLivro(a)}")
        try:
            iframe=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'iframe')))
            driver.switch_to.frame(iframe)
        except:
            try:
                driver.switch_to.frame(driver.find_element(EC.presence_of_element_located((By.ID, 'iframe'))))
            except Exception as e:
                print(f'Error to request livro fiscal {e}')
                return
        finally:
            sleep(1)
            Select(driver.find_element(By.ID, 'ddlTipoDocumento')).select_by_visible_text('Livro Fiscal')
            sleep(1.5)
            driver.find_element(By.ID, 'txtLivroFiscalNumLivro').send_keys('1')
            driver.find_element(By.ID, 'txtLivroFiscalPagInicial').send_keys('1')
            driver.find_element(By.ID, 'txtLivroFiscalDtInicial').send_keys(f'01/{data_vigente['mes_int']}/2025')
            driver.find_element(By.ID,'txtLivroFiscalDtFinal').send_keys(f'{countPreviousMonth}/{data_vigente['mes_int']}/2025')
            driver.find_element(By.ID, 'btnGerar').click()
            sleep(10)
            pt.hotkey('ctrl', 's')
            sleep(1)
            pt.press('enter')
            sleep(5)
            pt.hotkey('alt', 'f4')
            sleep(5)
            os.makedirs(os.path.join(os.path.expanduser('~'),f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/livros'), exist_ok=True)
            sleep(1)
            try:
                download_file=sorted(os.listdir(pasta_download), key=lambda _:os.path.getmtime(os.path.join(pasta_download,_)),reverse=True)
                if str(download_file[0]).endswith('.pdf'):
                    MoverArquivos(origem=download_file[0], destino=f'{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/livros', nome_arquivo=f'Livro Fiscal Serviços Prestados ISSQN-{data_vigente['mes']}-{data_vigente['ano']}.pdf')
                    
                    # shutil.move(os.path.join(pasta_download, download_file[0]), os.path.join(os.path.abspath(f'arquivosApi/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/livros'), f'Livro Fiscal Serviços Prestados ISSQN-{int(date.today().month)-1}-{date.today().year}.pdf'))
                else:
                    print('Arquivo não encontrado!')
            except ValueError as e:
                print(f'Erro ao mover arquivo: {e}')
            #lastFileDownload=sorted(os.listdir(pasta_download), key=lambda e: os.path.getmtime(os.path.join(pasta_download, e)), reverse=True)
            #shutil.move(os.path.join(pasta_download, lastFileDownload[0]), os.path.join(f'arquivosApi/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/livros', f'Livro Fiscal Serviços Prestados ISSQN-{int(date.today().month)-1}-{date.today().year}.pdf'))
            sleep(10)
    return driver.switch_to.default_content()

def requestUrlNT(driver, argKey):
    argKey=re.sub(r'\D','',argKey)
    month=data_vigente['mes_int']
    # month=f'0{month}' if month<=9 else False
    first_day=date.today().replace(day=1)
    last_day=(first_day-timedelta(days=1)).day

    os.makedirs(os.path.join(os.path.expanduser('~'), f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/notasT'), exist_ok=True)
    if verificar_arquivo(f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/notasT/Relatório Serviços Tomados ISSQN-{data_vigente['mes']}-{data_vigente['ano']}.pdf'):
        print('Arquivo Baixado')
        return
    else:
        print('REQUESTE NT')
        driver.execute_script("function requestNT(value){if(document.querySelectorAll('a.rtIn')[value].innerHTML=='Consulta de Notas Tomadas' ){document.querySelectorAll('a.rtIn')[value].click()}};  for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){requestNT(a)}")
        sleep(4)
        iframe=driver.find_element(By.ID, 'iframe')
        driver.switch_to.frame(iframe)
        sleep(1)
        Select(driver.find_element(By.ID, 'ddlSerie')).select_by_visible_text('Nota Fiscal de Serviço Eletrônica - NFS-e')
        sleep(1)
        driver.execute_script(f"document.querySelector('input#txtDtEmissaoIni').value='01/{month}/2025'")
        driver.execute_script(f"document.querySelector('input#txtDtEmissaoFim').value='{last_day}/{month}/2025'")
        sleep(1)
        driver.find_element(By.ID, 'btnBuscarNotas').click()
        sleep(1)
        driver.find_element(By.ID, 'btnImprimir').click()
        try:
            sleep(5)
            pt.hotkey('ctrl','s')
            sleep(1)
            pt.press('enter')
            sleep(1)
            pt.hotkey('alt','f4')
            sleep(10)
            try:
                download_file=sorted(os.listdir(pasta_download), key=lambda _:os.path.getmtime(os.path.join(pasta_download,_)),reverse=True)
                if str(download_file[0]).endswith('.pdf'):
                    MoverArquivos(origem=download_file[0], destino=f'{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/notasT', nome_arquivo=f'Relatório Serviços Tomados ISSQN-{data_vigente['mes']}-{data_vigente['ano']}.pdf')

                    # shutil.move(os.path.join(pasta_download, download_file[0]), os.path.join(os.path.abspath(f'arquivosApi/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/notasT'), f'Relatório Serviços Tomados ISSQN-{int(date.today().month)-1}-{date.today().year}.pdf'))
                else:
                    print('Arquivo não encontrado!')
            except ValueError as e:
                print(f'Erro ao mover arquivo: {e}') 
            # lastFileDownload=sorted(os.listdir(pasta_download), key=lambda e: os.path.getmtime(os.path.join(pasta_download, e)), reverse=True)
            # shutil.move(os.path.join(pasta_download, lastFileDownload[0]), os.path.join(f'arquivosApi/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/notasT', ))
            sleep(5)
            return 
        except:
            try:
                WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, 'modal-dialog')))
                with open(os.path.join(os.path.expanduser('~'),f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/notasT/Relatório Serviços Tomados ISSQN-{data_vigente['mes']}-{data_vigente['ano']}.txt'), 'w', encoding='utf-8') as f:
                    f.write('File not found')
                return
            except TimeoutException as e:
                print(f'Error to request notas tomadas {e}')
    return driver.switch_to.default_content()

def requestUrlNFS(driver, argKey):
    print(f"DATAS -> {data_vigente['mes']} - {data_vigente['mes_int']}")
    if int(data_vigente['mes_int'])<10:
        data_vigente['mes_int']=int(f"0{data_vigente['mes_int']}")
        
    argKey=re.sub(r'\D','',argKey)
    driver.switch_to.default_content()

    print('REQUESTE')
    os.makedirs(os.path.join(os.path.expanduser('~'),f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/nfse'), exist_ok=True)
    
    pasta_empresa_sis=os.path.join(os.path.expanduser('~'), f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/nfse') if os.path.isdir(os.path.join(os.path.expanduser('~'),f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/nfse')) else False
    if verificar_arquivo(f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/nfse/NFS5-{data_vigente['mes']}_a_10-{data_vigente['mes']}.zip') or verificar_arquivo(f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/nfse/NFS10-{data_vigente['mes']}_a_15-{data_vigente['mes']}.zip') or verificar_arquivo(f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/nfse/NFS15-{data_vigente['mes']}_a_20-{data_vigente['mes']}.zip') or verificar_arquivo(f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/nfse/NFS25-{data_vigente['mes']}_a_26-{data_vigente['mes']}.zip') or verificar_arquivo(f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/nfse/NFS{data_vigente['mes']}.txt') or verificar_arquivo(f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/nfse/NFS-{data_vigente['mes']}.zip'):
        print('1ª CONDIÇÃO')
        #verifica se já consta a NFS do mes vigente anterior
        return driver.switch_to.default_content()
    else:
        print('2ª CONDIÇÃO')

        try:
            firstDayMonth=date.today().replace(day=1)
            countPreviousMonth=(firstDayMonth-timedelta(days=1)).day
            sleep(1)
            driver.switch_to.default_content()

            
            driver.execute_script("""
                    function requestNota(value){
                        if(document.querySelectorAll('a.rtIn')[value].innerHTML=='Consultar Nota Eletrônica'){
                            document.querySelectorAll('a.rtIn')[value].click();
                        } 
                    };    
                    for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){requestNota(a)}
                """)
            driver.switch_to.frame(driver.find_element(By.ID, 'iframe'))
            sleep(1)
            driver.find_element(By.ID, 'imbArrow').click()
            sleep(1)
            driver.find_element(By.ID, 'txtDtEmissaoIni').send_keys(f'01/{data_vigente['mes_int']}/2025')
            driver.find_element(By.ID, 'txtDtEmissaoFim').send_keys(f'{countPreviousMonth}/{data_vigente['mes_int']}/2025')
            sleep(1)
            driver.find_element(By.ID, 'btnLocalizar2').click()
            sleep(1)
            export_all=driver.execute_script("return document.querySelector('a#dgDocumentos__ctl2_btnExportarTodosXml').dataset.originalTitle")
            print(f'Resposta NFS-e: {export_all}')
            if str(export_all)=='Exportar todas as notas em XML.':
                #caso haja <=10 notas ativas exportando todas de uma vez
                try:
                    clickNota=WebDriverWait(driver, 5).until(EC.element_to_be_clickable((By.ID, 'dgDocumentos__ctl2_btnExportarTodosXml')))
                    print(clickNota)
                except:
                    try:
                        driver.execute_script("document.querySelector('a#dgDocumentos__ctl2_btnExportarTodosXml').click()")
                    except:
                        pass
                sleep(0.5)
                clickNota.click()
                sleep(10)
                ultimo_arquivo=sorted(os.listdir(pasta_download), key=lambda _:os.path.getmtime(os.path.join(pasta_download,_)),reverse=True)
                try:
                    if ultimo_arquivo[0].endswith('.zip') and pasta_empresa_sis!=None:     
                        with zipfile.ZipFile(os.path.join(pasta_download,ultimo_arquivo[0]), 'r') as zipado: zipfile.ZipFile.extractall(zipado,os.path.join(os.path.expanduser('~'),f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/nfse'))
                        MoverArquivos(origem=ultimo_arquivo[0], destino=f'{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/nfse', nome_arquivo=f'NFS-{data_vigente['mes']}.zip')

                        # shutil.copy2(os.path.join(pasta_download, ultimo_arquivo[0]), os.path.join(os.path.abspath(f'arquivosApi/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/nfse'), f'NFS-{int(date.today().month)-1}.zip'))
                        # os.remove(os.path.join(pasta_download,ultimo_arquivo[0]))
                    sleep(0.5)
                except NoSuchElementException as e:
                    print(f'ERRO AO RETORNAR UNZIP: {e}')
                    return
                return
            else:
               
                #caso possua notas acima de 10, percorrera todas as tags
                try:#requisita a quantidade de dias do mes anterior
                    paginas=len(driver.find_elements(By.CSS_SELECTOR, ".pagerstyle > td > a"))+1
                    listagem=[]
                    #lista=[i for i in range(1,len(paginas)+2)]
                    a=0
                    def retornar_paginas():
                        global lista, paginas
                        try:
                            paginas=len(driver.find_elements(By.CSS_SELECTOR, ".pagerstyle > td > a"))
                            lista=[i for i in range(1,len(driver.find_elements(By.CSS_SELECTOR, ".pagerstyle > td > a"))+2)]
                        except:
                            try:
                                lista=[i for i in range(1,int(driver.execute_script("return document.querySelectorAll('.pagerstyle a').length"))+2)]
                                paginas=driver.execute_script("return document.querySelector('iframe#iframe').contentDocument.querySelectorAll('.pagerstyle a').length")
                            except Exception as e:
                                with open("nfse_erro/nfse_lote.txt",'w') as f:f.write(f"0 Erro ao retornar paginas -> {e}\n")
                                pass
                        print(f"PAGINA FUNCTION RETORNO -> {paginas}")
                        return paginas
                    
                    while paginas!=0:
                        sleep(2.5)
                        print(f"Contagem -> {a}")
                        # pagina_atual=driver.execute_script('return document.querySelectorAll("iframe")[0].contentDocument.querySelector(".pagerstyle span").innerHTML')
                        
                        #Verificação da quantia das notas na pagina atual
                        try:
                            notas=int(driver.execute_script("return document.querySelectorAll('.table.table-bordered.table-hover tbody tr').length"))
                        except:
                            try:
                                notas=len(driver.find_elements(By.CSS_SELECTOR, ".table.table-bordered table-hover > tbody > tr"))
                            except Exception as e:
                                with open(f"{pasta_bots}/nfse_erro/nfse_lote.txt", 'w') as f:f.write(f"1 Erro ao retornar quantidade de notas pagina -> {e}\n")
                                notas=12

                       
                        #Laço de execução de download da nota
                        for nota in range(1,int(notas)-1):
                            print(f"EFETUANDO DOWNLOAD NOTA -> {nota}")
                            
                            try:
                                #Efetua o click para download do xml
                                driver.execute_script(f"document.querySelector('table.table-bordered.table-hover').children[0].children[{nota}].children[13].children[0].click()")
                            except:
                                try:
                                    #Efetua o click para download do xml caso o try antecessor não execute
                                    driver.find_elements(By.CSS_SELECTOR, ".table.table-bordered.table-hover > tbody > tr")[nota].find_elements(By.CSS_SELECTOR, "td")[4].find_element(By.TAG_NAME, 'a').click()
                                except Exception as e:
                                    with open(f"{pasta_bots}/nfse_erro/nfse_lote.txt", 'w') as f:f.write(f"2 Erro ao efetuar download da nota -> {e}\n")
                                    
                                    continue
                            finally:
                                sleep(2.5)
                                ultimo_arquivo=sorted(os.listdir(pasta_download), key=lambda _:os.path.getmtime(os.path.join(pasta_download,_)),reverse=True)
                                print(f'SLICE NOMENCLATURA -> {str(ultimo_arquivo[0])[-10:]}')
                                if ultimo_arquivo[0].endswith('.xml'):
                                    MoverArquivos(origem=ultimo_arquivo[0], destino=f'{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/nfse', nome_arquivo=f'{ultimo_arquivo[0]}')
                                    sleep(1.5)
                                if int(nota)==10:
                                    break
                                continue
                        
                        #######ERRO DE LOOP
                        
                        #Efetua o click para proxima pagina
                        try:
                            # post_next=print(driver.execute_script(f"document.querySelector('table.table-bordered.table-hover').children[0].querySelector('.pagerstyle').children[0].children[{a}]").get_attribute("href"))
                            page=driver.execute_script(f"return document.querySelector('table.table-bordered.table-hover').children[0].querySelector('.pagerstyle').children[0].children[{a}].innerHTML")
                            if a==0 and str(page)=="...":
                                a+=1
                            else:
                                if str(page)!="...":
                                    driver.execute_script(f"document.querySelector('table.table-bordered.table-hover').children[0].querySelector('.pagerstyle').children[0].children[{a}].click()")
                                    sleep(1)
                                    a+=1
                                    #lista.pop(0)
                                    paginas-=1
                            print("NEXT 1º")
                        except:
                            try:
                                #Efetua o click para proxima pagina caso o try antecessor não execute
                                page=driver.find_elements(By.CSS_SELECTOR, ".pagerstyle > td > a")[a].text
                                if a==0 and str(page)=='...':
                                    a+=1
                                else:
                                    if str(page)!="..." :
                                        driver.find_elements(By.CSS_SELECTOR, ".pagerstyle > td > a")[a].click()      
                                        # lista.pop(0)
                                        sleep(1)
                                        paginas-=1
                                        a+=1
                                print("NEXT 2º")
                            except:
                                try:
                                    page=driver.execute_script(f"return document.querySelector('iframe#iframe').contentDocument.querySelectorAll('.pagerstyle a')[{a}].innerHTML")
                                    if a==0 and page=="...":
                                        a+=1
                                    else:
                                        if str(page)!="...":
                                            driver.execute_script(f"document.querySelector('iframe#iframe').contentDocument.querySelectorAll('.pagerstyle a')[{a}].click()")
                                            paginas-=1
                                            a+=1
                                except Exception as e:
                                    print("ERROR ")
                                    with open(f"{pasta_bots}/nfse_erros/nfse_lote.txt", 'w') as f: f.write(f"3 Erro ao efetuar requisicao de proxima pagina -> {e}\n") 
                                    driver.quit()
                        print(f"Proxima pagina -> {page} paginas -> {paginas}")
                        #Efetua reinicio para next page
                        try:
                            # pagina_atual=driver.execute_script('return document.querySelectorAll("iframe")[0].contentDocument.querySelector(".pagerstyle span").innerHTML')
                            
                            if paginas==1 and str(page)=="...":
                                if str(driver.execute_script(f"return document.querySelector('iframe#iframe').contentDocument.querySelectorAll('.pagerstyle a')[{a-1}].innerHTML"))=="...":
                                    driver.execute_script(f"return document.querySelector('iframe#iframe').contentDocument.querySelectorAll('.pagerstyle a')[{a-1}].click()")
                                elif str(driver.execute_script(f"return document.querySelector('iframe#iframe').contentDocument.querySelectorAll('.pagerstyle a')[{a}].innerHTML"))=="...":
                                    driver.execute_script(f"return document.querySelector('iframe#iframe').contentDocument.querySelectorAll('.pagerstyle a')[{a}].click()")

                                print("Requeste Refresh 1")
                                paginas=retornar_paginas()
                                print(f"PAGINAS ALOCADAS -> {(driver.find_elements(By.CSS_SELECTOR, ".pagerstyle > td > a"))}")
                                a=0
                        except:
                            try:
                                # pagina_atual=driver.execute_script('return document.querySelectorAll("iframe")[0].contentDocument.querySelector(".pagerstyle span").innerHTML')
                                if paginas==1 and str(page)=="...":
                                    if driver.find_elements(By.CSS_SELECTOR, ".pagerstyle > td > a")[a-1].text=="...":
                                        driver.find_elements(By.CSS_SELECTOR, ".pagerstyle > td > a")[a-1].click()
                                    elif driver.find_elements(By.CSS_SELECTOR, ".pagerstyle > td > a")[a].text=="...":
                                        driver.find_elements(By.CSS_SELECTOR, ".pagerstyle > td > a")[a].click()

                                    print("Requeste Refresh 2")
                                    paginas=retornar_paginas()
                                    print(f"PAGINAS ALOCADAS -> {driver.execute_script("return document.querySelectorAll('.pagerstyle a').length")}")
                                    a=0
                            except Exception as e:
                                with open(f"{pasta_bots}/nfse_erro/nfse_lote.txt", 'w') as f:f.write(f"4 Erro ao efetuar refresh da pagina -> {e}\n")
                                pass
                        finally:
                            sleep(1)

                    return 
                    
                except NoSuchElementException as e:
                    print(f'Erro ao requisitar NFS {e}')
                    
                finally:
                    return 
        except ValueError as e:
            print(f'Erro ao retornar a nfs {e}')
            return

def requestGUIAS(driver, argKey):
    argKey=re.sub(r'\D','',argKey)
    iframe=driver.find_element(By.ID, 'iframe')
    #script guia contratados
    def requeste_pdf():
        pt.hotkey('ctrl','p')
        print('REQUESTE')
        sleep(5)
        for i in range(5):pt.press('tab')
        # pt.press('tab', presses=5)
        sleep(1)
        pt.press('enter')
        sleep(1)
        # for i in range(5):pt.press('down')
        pt.press('down', presses=5)
        sleep(1)
        pt.press('enter')
        sleep(1)
        pt.press('tab')
        sleep(1)
        pt.press('enter')
        sleep(1)
        pt.press('esc')
        sleep(1)
        # pt.press(['tab','tab','tab','tab'])
        pt.press('tab',presses=4)
        sleep(1)
        pt.press('enter')

        sleep(10)
        pt.press('enter')
        sleep(10)
        pt.hotkey('alt', 'f4')
        return 
    
    worker=threading.Thread(target=requeste_pdf)
    #script referente a requisição da guia contratados
    if verificar_arquivo(os.path.join(f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', f'Contratados ISSQN-{data_vigente['mes']}.pdf')) or verificar_arquivo(os.path.join(f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', f'Declaração Não Movto - Serviços-{data_vigente['mes']}.pdf')) or verificar_arquivo(os.path.join(f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', f'Contratados Protocolo ISSQN-{data_vigente['mes']}.pdf')):
        print('RETORNANDO ARQUIVO BAIXADO')
        return 
    else:
        try:
            sleep(1)
            #Efetua a verificação de primeira emissão Serviços contratados
            ScriptJS.exec_script(driver, """function verifyNote(counter){
                    if(document.querySelectorAll('a.rtIn')[counter].innerHTML=='Emissão de Guia'){
                        document.querySelectorAll('a.rtIn')[counter].click();
                    } 
                };  
                
                for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){verifyNote(a); document.querySelectorAll('a.rtIn')[a].innerHTML}""")
            
            sleep(1)
            driver.switch_to.frame(driver.find_element(By.ID, 'iframe'))
            sleep(1)
            WebDriverWait(driver,5).until(Select(driver.find_element(By.CLASS_NAME, 'form-control')).select_by_visible_text('Serviços Contratados'))
                
            #se o arquivo já foi gerado ele executa a reemissão
            clickButton=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.CLASS_NAME, 'btn.btn-success.nc-ok')))
            clickButton.click()
            sleep(1)
            guia_name=f'Guia Contratados{data_vigente['mes']}.pdf'
            try:
                ReemissaoGuia=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'dgReemissao__ctl3_ibNaoMovimento')))
                ReemissaoGuia.click()
                guia_name=f'Declaração Não Movto - Serviços-{int(date.today().month)-1}.pdf'
            except:
                try:
                    ReemissaoGuia=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'dgReemissao_ctl3_ibGuia')))
                    ReemissaoGuia.click()
                    guia_name=f'Contratados ISSQN-{data_vigente['mes']}.pdf'
                except Exception as e:
                    print(f'Error to request first guia {e}')
                    return
            finally:
                if ReemissaoGuia:
                    print("RETORNANDO 1ª EMISSÃO DE GUIA")
                    sleep(5)
                    
                    worker.start()
                    worker.join()
                    print('Requeste 1ª Contratados')

                    try:
                        download_file=sorted(os.listdir(pasta_download), key=lambda _:os.path.getmtime(os.path.join(pasta_download,_)),reverse=True)
                        if str(download_file[0]).endswith('.pdf'):
                            MoverArquivos(origem=download_file[0], destino=f'{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', nome_arquivo=guia_name)
                            
                            # shutil.move(os.path.join(pasta_download, download_file[0]), os.path.join(f'arquivosApi/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', guia_name))
                        else:
                            print(f'Arquivo invalido: {download_file[0]}')
                    except ValueError as e:
                        print('Erro ao mover arquivo')
                        return
                    #CreateAndMoveFile(argKey, 'guias', os.path.join(os.path.expanduser('~'), 'downloads'), 0, guia_name)
        except:
            try:
                #caso a guia tenha sido emitida
                clickButton=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.CLASS_NAME, 'btn.btn-info.nc-ok')))
                clickButton.click()
                driver.switch_to.default_content()
                ScriptJS.exec_script(driver,"""
                    function verifyNote(counter){
                        if(document.querySelectorAll('a.rtIn')[counter].innerHTML=='Reemissão de Guia'){
                            document.querySelectorAll('a.rtIn')[counter].click();
                        } 
                    };  
                    
                    for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){verifyNote(a); document.querySelectorAll('a.rtIn')[a].innerHTML}
                            """)
                # driver.execute_script("""
                #     function verifyNote(counter){
                #         if(document.querySelectorAll('a.rtIn')[counter].innerHTML=='Reemissão de Guia'){
                #             document.querySelectorAll('a.rtIn')[counter].click();
                #         } 
                #     };  
                    
                #     for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){verifyNote(a); document.querySelectorAll('a.rtIn')[a].innerHTML}
                #             """)
                sleep(5)
                driver.switch_to.frame(iframe)
                #verifica guia de não movimento, guia do DAM, protocolo e referencial de doc. exatamente nesta sequencia
                guia_name=f'Contratados ISSQN-{data_vigente['mes']}.pdf'
                try:
                    emissao_guia=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'dgReemissao__ctl3_ibNaoMovimento')))
                    emissao_guia.click()
                    guia_name=f'Declaração Não Movto - Serviços-{data_vigente['mes']}.pdf'
                except:
                    try:
                        emissao_guia=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'dgReemissao__ctl3_ibGuia')))
                        emissao_guia.click()
                        guia_name=f'Contratados ISSQN-{data_vigente['mes']}.pdf'
                    except:
                        try:
                            emissao_guia=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'dgReemissao__ctl3_ibProtocolo')))
                            emissao_guia.click()
                            guia_name=f'Contratados Protocolo ISSQN-{data_vigente['mes']}.pdf'
                        except:
                            try:
                                emissao_guia=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'dgReemissao__ctl3_ibRelDocs')))
                                emissao_guia.click()
                                guia_name=f'Contratados Doc ISSQN-{data_vigente['mes']}.pdf'
                            except Exception as e:
                                print(f'Error to request file contratados {e}')
                finally:
                    if emissao_guia:
                        print("RETORNANDO 2ª EMISSÃO DE GUIA")

                        sleep(5)
                        # requeste_pdf()
                        worker.start()
                        worker.join()
                        sleep(5.5)
                        sleep(0.55)
                        print('Requeste 2ª Contratados')
                        try:
                            download_file=sorted(os.listdir(pasta_download), key=lambda _:os.path.getmtime(os.path.join(pasta_download,_)),reverse=True)
                            if str(download_file[0]).endswith('.pdf'):
                                MoverArquivos(origem=download_file[0],destino=f'{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', nome_arquivo=guia_name)
                                
                                # shutil.move(os.path.join(pasta_download, download_file[0]), os.path.join(f'arquivosApi/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', guia_name))
                            else:
                                print(f'Arquivo invalido: {download_file[0]}')
                        except ValueError as e:
                            print('Erro ao mover arquivo')
                            return

                        
                        #CreateAndMoveFile(f"{argKey}", 'guias', os.path.join(os.path.expanduser('~'), 'downloads'), 0, guia_name)

            #emissão com DAM
            except:
                    try:
                        ibFechamento=WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, 'ibFechamento')))
                        ibFechamento.click()
                        try:
                            checkBox=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'cbConcordo')))
                            if not checkBox.is_selected():
                                print("RETORNANDO 3ª EMISSÃO DE GUIA DAM")

                                checkBox.click()
                                sleep(1.5)
                                driver.find_element(By.ID, 'btnDocumentos').click()
                                sleep(5)
                                # requeste_pdf()
                                worker.start()
                                worker.join()
                                sleep(5.5)
                                sleep(0.55)
                                try:
                                    download_file=sorted(os.listdir(pasta_download), key=lambda _:os.path.getmtime(os.path.join(pasta_download,_)),reverse=True)
                                    if str(download_file[0]).endswith('.pdf'):
                                        MoverArquivos(origem=download_file[0], destino=f'{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', nome_arquivo=f'Guia DAM ISSQN-{data_vigente['mes']}.pdf')
                                        
                                        # shutil.move(os.path.join(pasta_download, download_file[0]), os.path.join(f'arquivosApi/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', f'Guia DAM ISSQN-{int(date.today().month)-1}.pdf'))
                                    else:
                                        print(f'Arquivo invalido: {download_file[0]}')
                                except ValueError as e:
                                    print('Erro ao mover arquivo')
                                    return
                                
                                #CreateAndMoveFile(argKey,'guias', os.path.join(os.path.expanduser('~'), 'downloads'), 0, f'Guia DAM ISSQN-{int(date.today().month)-1}.pdf')
                        except:
                            try:
                                clickButton=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.CLASS_NAME, 'btn.btn-success.nc-ok')))
                                clickButton.click()
                                try:
                                    ibNaoMovimento=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'dgReemissao__ctl3_ibNaoMovimento')))
                                    ibNaoMovimento.click()
                                    print("RETORNANDO 4ª EMISSÃO DE GUIA DAM")

                                    sleep(5)
                                    # requeste_pdf()
                                    worker.start()
                                    worker.join()
                                    sleep(0.55)
                                    try:
                                        download_file=sorted(os.listdir(pasta_download), key=lambda _:os.path.getmtime(os.path.join(pasta_download,_)),reverse=True)
                                        if str(download_file[0]).endswith('.pdf'):
                                            MoverArquivos(origem=download_file[0],destino=f'{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', nome_arquivo=f'Guia DAM ISSQN-{data_vigente['mes']}.pdf')
                                            
                                            # shutil.move(os.path.join(pasta_download, download_file[0]), os.path.join(f'arquivosApi/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', f'Guia DAM ISSQN-{int(date.today().month)-1}.pdf'))
                                        else:
                                            print(f'Arquivo invalido: {download_file[0]}')
                                    except ValueError as e:
                                        print('Erro ao mover arquivo')
                                        return
                                    
                                    #CreateAndMoveFile(argKey,'guias' ,os.path.join(os.path.expanduser('~'), 'downloads'), 0, f'Declaração Não Movto - Serviços -{int(date.today().month)-1}.pdf')
                                except:
                                    try:
                                        ibNaoMovimento=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'dgReemissao__ctl3_ibProtocolo')))
                                        ibNaoMovimento.click()
                                        print("RETORNANDO 5ª EMISSÃO DE GUIA DAM")

                                        sleep(5)
                                        # requeste_pdf()
                                        worker.start()
                                        worker.join()
                                        sleep(0.55)
                                        print('Requeste 4ª Contratados')
                                        try:
                                            download_file=sorted(os.listdir(pasta_download), key=lambda _:os.path.getmtime(os.path.join(pasta_download,_)),reverse=True)
                                            if str(download_file[0]).endswith('.pdf'):
                                                MoverArquivos(origem=download_file[0], destino=f'{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', nome_arquivo=f'Contratados Protocolo ISSQN-{data_vigente['mes']}.pdf')
                                                
                                                # shutil.move(os.path.join(pasta_download, download_file[0]), os.path.join(f'arquivosApi/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', f'Contratados Protocolo ISSQN-{int(date.today().month)-1}.pdf'))
                                            else:
                                                print(f'Arquivo invalido: {download_file[0]}')
                                        except ValueError as e:
                                            print('Erro ao mover arquivo')
                                            return
                                        
                                        #CreateAndMoveFile(argKey,'guias', os.path.join(os.path.expanduser('~'), 'downloads'), 0, f'Contratados Protocolo ISSQN-{int(date.today().month)-1}.pdf')
                                    except Exception as e:
                                        print(f'Error to request protocolo e não movimento: {e}')
                                        pass
                            except:
                                try:
                                    clickButton=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.CLASS_NAME, 'btn.btn-info.nc-ok')))
                                    clickButton.click()
                                    driver.switch_to.default_content()

                                    ScriptJS.exec_script(driver,"""
                                        function verifyNote(counter){
                                            if(document.querySelectorAll('a.rtIn')[counter].innerHTML=='Reemissão de Guia'){
                                                document.querySelectorAll('a.rtIn')[counter].click();
                                            } 
                                        };  
                                        
                                        for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){verifyNote(a); document.querySelectorAll('a.rtIn')[a].innerHTML}
                                        """)
                                    # driver.execute_script("""
                                    #     function verifyNote(counter){
                                    #         if(document.querySelectorAll('a.rtIn')[counter].innerHTML=='Reemissão de Guia'){
                                    #             document.querySelectorAll('a.rtIn')[counter].click();
                                    #         } 
                                    #     };  
                                        
                                    #     for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){verifyNote(a); document.querySelectorAll('a.rtIn')[a].innerHTML}
                                    #     """)

                                    driver.switch_to.frame(iframe)
                                    #verifica guia de não movimento, guia do DAM, protocolo e referencial de doc. exatamente nesta sequencia
                                    guia_name=f'Contratados ISSQN-{data_vigente['mes']}.pdf'
                                    try:
                                        emissao_guia=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'dgReemissao__ctl3_ibNaoMovimento')))
                                        emissao_guia.click()
                                        guia_name=f'Declaração Não Movto - Serviços-{data_vigente['mes']}.pdf'
                                    except:
                                        try:
                                            emissao_guia=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'dgReemissao__ctl3_ibGuia')))
                                            emissao_guia.click()
                                            guia_name=f'Contratados ISSQN-{data_vigente['mes']}.pdf'
                                        except:
                                            try:
                                                emissao_guia=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'dgReemissao__ctl3_ibProtocolo')))
                                                emissao_guia.click()
                                                guia_name=f'Contratados Protocolo ISSQN-{data_vigente['mes']}.pdf'
                                            except:
                                                try:
                                                    emissao_guia=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'dgReemissao__ctl3_ibRelDocs')))
                                                    emissao_guia.click()
                                                    guia_name=f'Contratados Doc ISSQN-{data_vigente['mes']}.pdf'
                                                except Exception as e:
                                                    print(f'Error to request file contratados {e}')
                                    finally:
                                        if emissao_guia:
                                            print("RETORNANDO 6ª EMISSÃO DE GUIA DAM")
                                            sleep(5)
                                            # requeste_pdf()
                                            worker.start()
                                            worker.join()
                                            
                                            sleep(0.55)
                                            print('Requeste 5ª Contratados')
                                            try:
                                                download_file=sorted(os.listdir(pasta_download), key=lambda _:os.path.getmtime(os.path.join(pasta_download,_)),reverse=True)
                                                if str(download_file[0]).endswith('.pdf'):
                                                    print(download_file[0])
                                                    MoverArquivos(origem=download_file[0], destino=f'{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', nome_arquivo=guia_name)
                                                
                                                    # shutil.move(os.path.join(pasta_download, download_file[0]), os.path.join(f'arquivosApi/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', guia_name))
                                                else:
                                                    print(f'Arquivo invalido: {download_file[0]}')
                                            except ValueError as e:
                                                print('Erro ao mover arquivo')
                                                return
                                            
                                            #CreateAndMoveFile(f"{argKey}", 'guias', os.path.join(os.path.expanduser('~'), 'downloads'), 0, guia_name)
                                except Exception as e:
                                    print(f'Error to request first button: {e}')
                                    pass
                    except Exception as e:
                        print(f'Guia não gerada: {e}')
     
    #script guia prestados
    try:
        driver.switch_to.default_content()

        ScriptJS.exec_script(driver,"""
            function verifyNote(counter){
                if(document.querySelectorAll('a.rtIn')[counter].innerHTML=='Emissão de Guia'){
                    document.querySelectorAll('a.rtIn')[counter].click();
                } 
            };  
            
            for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){verifyNote(a); document.querySelectorAll('a.rtIn')[a].innerHTML}
                    """)
        
        # driver.execute_script("""
        #     function verifyNote(counter){
        #         if(document.querySelectorAll('a.rtIn')[counter].innerHTML=='Emissão de Guia'){
        #             document.querySelectorAll('a.rtIn')[counter].click();
        #         } 
        #     };  
            
        #     for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){verifyNote(a); document.querySelectorAll('a.rtIn')[a].innerHTML}
        #             """)
        
        sleep(1)
        driver.switch_to.frame(iframe)
        WebDriverWait(driver, 5).until(Select(driver.find_element(By.ID, 'ddlTipoFechamento')).select_by_visible_text('Serviços Prestados'))
        #requisição referente ao serviços prestados
        if verificar_arquivo(os.path.join(f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', f'Prestados ISSQN-{data_vigente['mes']}.pdf')) or verificar_arquivo(os.path.join(f'.arquivos_api/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', f'Declaração Não Movto Pres - Serviços-{data_vigente['mes']}.pdf')):
            return
        else:
            try:
                #verifica se a guia prestados já foi emitida
                clickButton=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.CLASS_NAME, 'btn.btn-info.nc-ok')))
                clickButton.click()
                sleep(1)
                driver.switch_to.default_content()
                
                ScriptJS.exec_script(driver,"""
                    function verifyNote(counter){
                        if(document.querySelectorAll('a.rtIn')[counter].innerHTML=='Reemissão de Guia'){
                            document.querySelectorAll('a.rtIn')[counter].click();
                        } 
                    };  
                    for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){verifyNote(a); document.querySelectorAll('a.rtIn')[a].innerHTML}
                    """)
                # driver.execute_script("""
                #     function verifyNote(counter){
                #         if(document.querySelectorAll('a.rtIn')[counter].innerHTML=='Reemissão de Guia'){
                #             document.querySelectorAll('a.rtIn')[counter].click();
                #         } 
                #     };  
                #     for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){verifyNote(a); document.querySelectorAll('a.rtIn')[a].innerHTML}
                #     """)
                sleep(1)
                driver.switch_to.frame(iframe)
                guia_name=f'Guia Prestados{data_vigente['mes']}.pdf'
                try:
                    ReemissaoGuia=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'dgReemissao__ctl4_ibNaoMovimento')))
                    ReemissaoGuia.click()
                    guia_name=f'Declaração Não Movto Pres - Serviços-{data_vigente['mes']}.pdf'
                except:
                    try:
                        ReemissaoGuia=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'dgReemissao__ctl4_ibGuia')))
                        ReemissaoGuia.click()
                        guia_name=f'Prestados ISSQN-{data_vigente['mes']}.pdf'
                    except Exception as e:
                        print(f'Error to request first guia {e}')
                        pass
                finally:
                    if ReemissaoGuia:
                        print("RETORNANDO 1ª EMISSÃO DE GUIA PRESTADOS")

                        sleep(5)
                        driver.execute_script("imprimirRelatorio()")
                        sleep(10)
                        # requeste_pdf()
                        worker.start()
                        worker.join()
                        sleep(0.55)
                        print('Requeste 1ª Prestados')
                        try:
                            download_file=sorted(os.listdir(pasta_download), key=lambda _:os.path.getmtime(os.path.join(pasta_download,_)),reverse=True)
                            if str(download_file[0]).endswith('.pdf'):
                                MoverArquivos(origem=download_file[0], destino=f'{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', nome_arquivo=guia_name)
                                
                                # shutil.move(os.path.join(pasta_download, download_file[0]), os.path.join(f'arquivosApi/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', guia_name))
                            else:
                                print(f'Arquivo invalido: {download_file[0]}')
                        except ValueError as e:
                            print('Erro ao mover arquivo')
                            return
                        
                        #CreateAndMoveFile(argKey, 'guias', os.path.join(os.path.expanduser('~'), 'downloads'), 0, guia_name)
            except:
                try:
                    ibFechamento=WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, 'ibFechamento')))
                    ibFechamento.click()
                    # interação com o checkbox 
                    checkBox=WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, 'cbConcordo')))
                    if not checkBox.is_selected():
                        checkBox.click()
                        sleep(1.5)
                        clickDan=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'ibGerarGuia')))
                        clickDan.click()
                        sleep(5)
                        driver.switch_to.default_content()

                        ScriptJS.exec_script(driver,"""
                            function verifyNote(counter){
                                if(document.querySelectorAll('a.rtIn')[counter].innerHTML=='Reemissão de Guia'){
                                    document.querySelectorAll('a.rtIn')[counter].click();
                                } 
                            };  
                            for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){verifyNote(a); document.querySelectorAll('a.rtIn')[a].innerHTML}
                        """)

                        # driver.execute_script("""
                        #     function verifyNote(counter){
                        #         if(document.querySelectorAll('a.rtIn')[counter].innerHTML=='Reemissão de Guia'){
                        #             document.querySelectorAll('a.rtIn')[counter].click();
                        #         } 
                        #     };  
                        #     for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){verifyNote(a); document.querySelectorAll('a.rtIn')[a].innerHTML}
                        # """)
                        sleep(1)
                        driver.switch_to.frame(iframe)

                        #verificar o return do valor se executa o redirecionamento
                        emitirDAM=WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, 'dgReemissao_ctl4_ibGuia')))
                        emitirDAM.click()
                        sleep(5)
                        print("RETORNANDO 2ª EMISSÃO DE GUIA PRESTADOS")

                        driver.execute_script("imprimirRelatorio()")
                        sleep(5)
                        # requeste_pdf()
                        worker.start()
                        worker.join()
                        sleep(0.55)
                        print('Requeste 2ª Prestados')
                        try:
                            download_file=sorted(os.listdir(pasta_download), key=lambda _:os.path.getmtime(os.path.join(pasta_download,_)),reverse=True)
                            if str(download_file[0]).endswith('.pdf'):
                                MoverArquivos(origem=download_file[0], destino=f'{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', nome_arquivo=f'Prestados ISSQN-{data_vigente['mes']}.pdf')
                                
                                # shutil.move(os.path.join(pasta_download, download_file[0]), os.path.join(f'arquivosApi/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', f'Prestados ISSQN-{int(date.today().month)-1}.pdf'))
                            else:
                                print(f'Arquivo invalido: {download_file[0]}')
                        except ValueError as e:
                            print('Erro ao mover arquivo')
                            return

                        #CreateAndMoveFile(argKey,'guias', os.path.join(os.path.expanduser('~'), 'downloads'), 0, f'Prestados ISSQN-{int(date.today().month)-1}.pdf')
                        return  
                except:
                    #verifica se a guia já foi emitida e executa a emissão se não se sim reemite TRATAMENTO CASO NÂO EMITA A GUIA NAS PRIMEIRA REQUISIÇÕES
                    sleep(5)
                    try:
                        clickButton=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.CLASS_NAME, 'btn.btn-success.nc-ok')))
                        clickButton.click()
                    except:
                        try:
                            clickButton=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.CLASS_NAME, 'btn.btn-info.nc-ok')))
                            clickButton.click()
                            driver.switch_to.default_content()
                            ScriptJS.exec_script(driver, """
                                function verifyNote(counter){
                                    if(document.querySelectorAll('a.rtIn')[counter].innerHTML=='Reemissão de Guia'){
                                        document.querySelectorAll('a.rtIn')[counter].click();
                                    } 
                                };  
                                
                                for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){verifyNote(a); document.querySelectorAll('a.rtIn')[a].innerHTML}
                
                            """)
                            # driver.execute_script("""
                            #     function verifyNote(counter){
                            #         if(document.querySelectorAll('a.rtIn')[counter].innerHTML=='Reemissão de Guia'){
                            #             document.querySelectorAll('a.rtIn')[counter].click();
                            #         } 
                            #     };  
                                
                            #     for(a=0;a<document.querySelectorAll('a.rtIn').length;a++){verifyNote(a); document.querySelectorAll('a.rtIn')[a].innerHTML}
                
                            # """)
                        except Exception as e:
                            print(f'Error to request guia prestados {e}')
                            return
                    finally:
                        if clickButton:
                            sleep(1)
                            driver.switch_to.frame(iframe)
                            ibNaoMovimento=WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.ID, 'dgReemissao__ctl4_ibNaoMovimento')))
                            ibNaoMovimento.click()
                            sleep(5)
                            print("RETORNANDO 3ª EMISSÃO DE GUIA PRESTADOS")

                            driver.execute_script("imprimirRelatorio()")
                            sleep(5)
                            # requeste_pdf()
                            worker.start()
                            worker.join()
                            sleep(0.55)
                            print('Requeste 3ª Prestados')
                            try:
                                download_file=sorted(os.listdir(pasta_download), key=lambda _:os.path.getmtime(os.path.join(pasta_download,_)),reverse=True)
                                if str(download_file[0]).endswith('.pdf'):
                                    MoverArquivos(origem=download_file[0], destino=f'{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', nome_arquivo=f'Declaração Não Movto Pres - Serviços-{data_vigente['mes']}.pdf')
                                    
                                    # shutil.move(os.path.join(pasta_download, download_file[0]), os.path.join(f'arquivosApi/{argKey}/{data_vigente['mes']}/{data_vigente['ano']}/guias', f'Declaração Não Movto Pres - Serviços-{int(date.today().month)-1}.pdf'))
                                else:
                                    print(f'Arquivo invalido: {download_file[0]}')
                            except ValueError as e:
                                print('Erro ao mover arquivo')
                                return
                            
                            #CreateAndMoveFile(argKey,'guias', os.path.join(os.path.expanduser('~'), 'downloads'), 0, f'Declaração Não Movto Pres - Serviços-{int(date.today().month)-1}.pdf')
                            return
    except Exception as e:
        print(f'Passando direto {e}')
        return
    sleep(5)
    driver.switch_to.default_content()          
    return

class RequestGuias:
    def __init__(self,cliente, empresa=None, extrair:list=[1,1,1,1], mes:list=None):
        """
        extrair -> [0] - GUIAS se 0 não extrair
        """
        if mes!=None:
            data_vigente['mes']=mes[0]
            data_vigente['mes_int']=mes[1]

        self.lista=list()
        lista_nome=self.lista=list()
        print('REQUESTE CLASS')
        #Verifica se foi inserido dados para leitura se executado sem dados retorna info do banco
        if empresa!=None:
            if isinstance(empresa, list):
                self.lista=[re.sub(r'\D','',str(i)) for i in empresa]
                for i in empresa:
                    lista_nome.append(db.SQLConn().parametro_readline(param=['cnpj', str(i)])['razao'])
            else:
                self.lista=[re.sub(r'\D','',str(empresa))]
                lista_nome=db.SQLConn().parametro_readline(param=['cnpj', str(empresa)])
                lista_nome=[lista_nome['razao']]
        else:
            self.lista=[i['cnpj'] for i in db.SQLConn().parametro_read()]
            lista_nome=[i['razao'] for i in db.SQLConn().parametro_read()]
        listagem=[{'Ativas':[],'Desativas':[]}]
        options=Options()
        #options.add_argument("--headless=new") # MODO HEADLESS MAIS RECENTE
        options.add_argument("--no-sandbox")
        # options.add_argument("--kiosk-printing") fecha o popup de impressão
        options.add_argument("--disable-extensions")
        options.add_argument("--no-default-browser-check")
        options.add_argument("--disable-popup-blocking")
        options.add_argument("--disable-software-rasterizer")

        options.add_experimental_option("excludeSwitches",["enable-automation"])
        options.add_experimental_option("useAutomationExtension", False)
        options.add_experimental_option("excludeSwitches", ["enable-logging"])
        
        options.add_experimental_option("prefs",{
            "download.default_directory":pasta_download,
            "download.prompt_for_download":False,
            "download.directory_upgrade":True,
            "safebrownsing.enabled":False,
            # Tenta desabilitar proteção específica de downloads
            "safebrowsing.disable_download_protection": True,
            "profile.default_content_setting_values.automatic_downloads":1, # Permitir múltiplos downloads
            "profile.default_content_setting_values.notifications":2, # Bloquear notificações
        })
        #options.add_argument("--kiosk-printing") # HABILITA IMPRESSÃO SILENCIOSA

        options.page_load_strategy='normal'
        driver=webdriver.Chrome(options=options)
        driver.execute_cdp_cmd("Page.setDownloadBehavior", {
                "behavior": "allow",
                "downloadPath": str(pasta_download),
                # "eventsEnabled": True  # opcional: se quiser eventos
            })
        
        driver.get('https://onlinecba.issnetonline.com.br/cuiaba/Login/Login.aspx')
        
        driver.maximize_window()
        
        try:
            dicionario={}
            clickLogin=WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, 'btnAcionaCertificado')))
            clickLogin.click()
            sleep(1)
            pt.press(['down','down'])
            sleep(1.5)
            pt.press('enter')
            sleep(1.5)
            urlHome=driver.current_url
            timer_inicial=perf_counter()
            for ind,a in enumerate(self.lista):
                try:
                    inicio=perf_counter()
                    guias_v=livros_v=notas_tomadas_v=nfse_v=False
                    inputInfo=WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, 'TxtCPF')))
                    print(f'REQUESTE ISSQN EMPRESA: {a}')
                    inputInfo.send_keys(a)
                    sleep(1.5)
                    driver.execute_script("document.querySelector('a#imbLocalizar').click()")
                    
                    #REQUISIÇÃO DAS GUIAS extrair[0]
                    try:
                        if extrair[0]==1:
                            listagem[0]['Ativas'].append(a)
                            print('Request guias')
                            requestGUIAS(driver, a)
                            guias_v=True
                    except:
                        try:
                            WebDriverWait(driver, 1.5).until(EC.presence_of_element_located((By.CLASS_NAME, 'modal-dialog')))
                            modal_texto=str(WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.CLASS_NAME,'bootbox-body'))).text)
                            with open(f'{pasta_bots}/modal_erros/modal_log.txt','r',encoding='utf-8') as f:modal_lista=[v.strip() for v in f]
                            
                            if modal_texto not in modal_lista:
                                with open(f'{pasta_bots}/modal_erros/modal_log.txt','a',encoding='utf-8') as f:f.write(f'{modal_texto}\n')

                            match modal_texto:
                                case 'Contribuinte não encontrado.':
                                    listagem[0]['Desativas'].append(a)
                                    print('Empresa não encontrada')
                                    sleep(0.5)
                                    driver.get(urlHome)
                                    pass
                                case 'Nenhum registro encontrado.':
                                    pass
                        except TimeoutException as e:
                            with open('modal_erros/log_erro_issqn.txt', 'a', encoding='utf-8') as f:f.write(f'ERRO AO RETORNAR GUIAS EMPRESA -> {lista_nome[ind]} - {a}, {e} Tempo exec -> {perf_counter()-inicio} Data/Hora: {date.today().isoformat()}\n')
                            pass
                        
                    sleep(1)
                    
                    #REQUISIÇÃO DO LIVRO FISCAL extrair[1]
                    try:
                        if extrair[1]==1:
                            sleep(0.5)
                            print('Request livros fiscais')
                            requestUrlLIVRO(driver, a)
                            livros_v=True
                    except:
                        try:
                            WebDriverWait(driver, 1.5).until(EC.presence_of_element_located((By.CLASS_NAME, 'modal-dialog')))
                            modal_texto=str(WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.CLASS_NAME,'bootbox-body'))).text)
                            with open(f'{pasta_bots}/modal_erros/modal_log.txt','r',encoding='utf-8') as f:modal_lista=[v.strip() for v in f]
                            
                            if modal_texto not in modal_lista:
                                with open(f'{pasta_bots}/modal_erros/modal_log.txt','a',encoding='utf-8') as f:f.write(f'{modal_texto}\n')

                            match modal_texto:
                                case 'Contribuinte não encontrado.':
                                    listagem[0]['Desativas'].append(a)
                                    print('Empresa não encontrada')
                                    sleep(0.5)
                                    driver.get(urlHome)
                                    pass
                                case 'Nenhum registro encontrado.':
                                    pass
                        except TimeoutException as e:
                            with open('modal_erros/log_erro_issqn.txt', 'a', encoding='utf-8') as f:f.write(f'ERRO AO RETORNAR LIVRO EMPRESA -> {lista_nome[ind]} - {a}, {e} Tempo exec -> {perf_counter()-inicio} Data/Hora: {date.today().isoformat()}\n')
                            pass

                    sleep(1)

                    #REQUISIÇÃO DAS NOTAS TOMADAS extrair[2]
                    try:
                        if extrair[2]==1:
                            sleep(1)
                            print('Request notas tomadas')
                            requestUrlNT(driver, a)
                            notas_tomadas_v=True
                    except:
                        try:
                            WebDriverWait(driver, 1.5).until(EC.presence_of_element_located((By.CLASS_NAME, 'modal-dialog')))
                            modal_texto=str(WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.CLASS_NAME,'bootbox-body'))).text)
                            with open(f'{pasta_bots}/modal_erros/modal_log.txt','r',encoding='utf-8') as f:modal_lista=[v.strip() for v in f]
                            
                            if modal_texto not in modal_lista:
                                with open(f'{pasta_bots}/modal_erros/modal_log.txt','a',encoding='utf-8') as f:f.write(f'{modal_texto}\n')
                            
                            match modal_texto:
                                case 'Contribuinte não encontrado.':
                                    listagem[0]['Desativas'].append(a)
                                    print('Empresa não encontrada')
                                    sleep(0.5)
                                    driver.get(urlHome)
                                    pass
                                case 'Nenhum registro encontrado.':
                                    pass
                        except TimeoutException as e:
                            with open('modal_erros/log_erro_issqn.txt', 'a', encoding='utf-8') as f:f.write(f'ERRO AO RETORNAR NT EMPRESA -> {lista_nome[ind]} - {a}, {e} Tempo exec -> {perf_counter()-inicio} Data/Hora: {date.today().isoformat()}\n')
                            pass

                    sleep(1)

                    #REQUISIÇÃO DAS NFS-e extrair[3]
                    try:
                        if extrair[3]==1:
                            sleep(1)
                            print('Request NFS')
                            requestUrlNFS(driver, a)
                            nfse_v=True
                    except:
                        try:
                            WebDriverWait(driver, 1.5).until(EC.presence_of_element_located((By.CLASS_NAME, 'modal-dialog')))
                            modal_texto=str(WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.CLASS_NAME,'bootbox-body'))).text)
                            with open(f'{pasta_bots}/modal_erros/modal_log.txt','r',encoding='utf-8') as f:modal_lista=[v.strip() for v in f]
                            
                            if modal_texto not in modal_lista:
                                with open(f'{pasta_bots}/modal_erros/modal_log.txt','a',encoding='utf-8') as f:f.write(f'{modal_texto}\n')
                            
                            match modal_texto:
                                case 'Contribuinte não encontrado.':
                                    listagem[0]['Desativas'].append(a)
                                    print('Empresa não encontrada')
                                    sleep(0.5)
                                    driver.get(urlHome)
                                    pass
                                case 'Nenhum registro encontrado.':
                                    pass
                        except TimeoutException as e:
                            with open('modal_erros/log_erro_issqn.txt', 'a', encoding='utf-8') as f:f.write(f'ERRO AO RETORNAR NFS-e EMPRESA -> {lista_nome[ind]} - {a}, {e} Tempo exec -> {perf_counter()-inicio} Data/Hora: {date.today().isoformat()}\n')
                            pass
                    
                    MVF.ConnFileServer.mover_pasta_para_fileserver(origem=os.path.join(os.path.expanduser('~'), f'.arquivos_api/{a}'), nova_pasta=f'{a}')
                    
                    sleep(1)
                    with open(f'{pasta_bots}/modal_erros/log_issqn.json', 'r', encoding='utf-8') as f:log_issqn=json.load(f)
                    dicionario={"Empresa":lista_nome[ind],"CNPJ":a,"Guias":guias_v,"Livros":livros_v,"Notas Tomadas":notas_tomadas_v,"NFS-e":nfse_v, "Tempo de Execução":perf_counter()-inicio, "Data/Hora":date.today().isoformat()}
                    log_issqn.append(dicionario)
                    with open(f'{pasta_bots}/modal_erros/log_issqn.json','w',encoding='utf-8') as f:json.dump(log_issqn,f,indent=4,ensure_ascii=False)
                    
                    driver.get(urlHome)
                except Exception as e:
                    try:
                        v=str(e)[12:142]
                        log_cond=True if v == 'A empresa possui uma correspondência não lida. Visualize acessando o menu DTE - Domicílio Tributário Eletrônico > Caixa de Entrada' else False
                        if log_cond!=True:
                            print(f'Error request: {e}')
                            
                            #Erro de timeout com o banco do sistema
                            if str(e)=="HTTPConnectionPool(host='localhost', port=52951): Max retries exceeded with url: /session/748e00b4c7656fb642e925db46f44d83/url (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x00000232901B9F10>: Failed to establish a new connection: [WinError 10061] Nenhuma conexão pôde ser feita porque a máquina de destino as recusou ativamente'))":
                                driver.quit()
                                return 
                            driver.get(urlHome)
                        else:
                            print(f'LOG VARIAVEL: {v}')
                            #Erro de timeout com o banco do sistema
                            if v=="onPool(host='localhost', port=52951): Max retries exceeded with url: /session/748e00b4c7656fb642e925db46f44d83/url (Caused by NewC":
                                driver.quit()
                                return
                            print(f'Error loop requeste {e}')
                    #apos a proxima requisição passara direto
                    except TimeoutError as e:
                        with open('modal_erros/timeout_log.txt','a',encoding='utf-8') as f:f.write(f'Erro de requisição -> {e}\n')
                        continue
            print(f"EXECUÇÃO FINALIZADA - TEMPO -> {perf_counter()-timer_inicial}")
            driver.quit()
        except Exception as e:
            try:
                v=str(e)[12:142]
                print(f'LOG VARIAVEL: {v}')
                log_cond=True if v == 'A empresa possui uma correspondência não lida. Visualize acessando o menu DTE - Domicílio Tributário Eletrônico > Caixa de Entrada' else False
                sleep(1)
                if log_cond==True:
                    print('Error request')
                    pt.press('enter')
            except Exception as a:
                print(f'Error not found {a}')
        return None

# RequestGuias(cliente='192.168.1.186', extrair=[0,0,1,1], empresa=['38075745000192'])

from webdriver_manager.chrome import ChromeDriverManager
from selenium.webdriver.chrome.service import Service
# import sefaz_cte as cte
try:
    from api.utils.bots import sefaz_nfe as sf
except:
    try:
        import sefaz_nfe as sf
    except:
        try:
            from . import sefaz_nfe as sf
        except:
            pass

# import sefaz_nfc as nfc

class RequestNFe:
    def __init__(self,cliente, only_emp=[]):
        contagem=list() 
        try:
            with open(f"{pasta_bots}/controle/controle.json", 'r') as f:controle=json.load(f)
            controle=[]
            with open(f"{pasta_bots}/controle/controle.json", "w") as f:json.dump(controle,f,indent=4,ensure_ascii=False)
            sleep(1.5)

            #execução sefaz requisição danfe
            download_dir=os.path.abspath(os.path.join(os.path.expanduser('~'), 'downloads'))
            options=Options()
            options.add_argument("--ignore-certificate-errors")
            options.add_argument("--start-maximized")

            options.add_argument("--log-level=0")  # 0=ALL, 1=INFO, 2=WARNING, 3=ERROR
            options.add_argument("--disable-popup-blocking")
            prefs={
                "download.prompt_for_download": False,       # Não mostrar popup
                "download.directory_upgrade": True,          # Permitir alterar diretório
                "download.default_directory": download_dir,  # Caminho para download
                "safebrowsing.enabled": True,
                "profile.default_content_setting_values.automatic_downloads":1, # Permitir múltiplos downloads
                "profile.default_content_setting_values.notifications":2, # Bloquear notificações
                
            }

            options.add_experimental_option("excludeSwitches",["enable-automation"])
            options.add_experimental_option("useAutomationExtension", False)
            options.add_experimental_option("excludeSwitches", ["enable-logging"])
            options.add_experimental_option("prefs",prefs)
            driver=webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)
            threading.Thread(target=worker_0, args=(driver,)).start()

            # Esse comando é o que frequentemente "contorna" o bloqueio de downloads verificados.
            driver.execute_cdp_cmd("Page.setDownloadBehavior", {
                "behavior": "allow",
                "downloadPath": str(download_dir),
                # "eventsEnabled": True  # opcional: se quiser eventos
            })
            
            driver.get('https://www.sefaz.mt.gov.br/acesso/pages/login/login.xhtml') 
            
            def click_popup():
                sleep(5)
                pt.press(['down','down','down'])
                sleep(1)
                pt.press('enter')
            
            processo_click=threading.Thread(target=click_popup)

            processo_click.start()
            driver.execute_script("document.querySelectorAll('div.form-group')[7].children[1].click()")
            processo_click.join()
            sleep(1)

            driver.execute_script("document.querySelectorAll('div.ui-helper-hidden-accessible')[1].children[0].value='CONTABILISTA'")
            driver.find_element(By.CLASS_NAME, 'btnPadrao').click()
            sleep(5)

            print('REQUESTE SEFAZ INFO')
            if len(only_emp)==0:
                for i in db.SQLConn().parametro_read():
                    cte_v=nfe_v=nfc_v=False
                    inicio=perf_counter()    
                    #print(f'REQUESTE CT-e EMPRESA: {i['razao']}--> {re.sub(r'\D','',i['cnpj'])}')
                    try:
                        try:
                            #cte.requestCTE(re.sub(r'\D','',i['cnpj']),driver)
                            cte_v=None
                        except:
                            pass
                        if i['ie']!=None and i['ie']!='None':
                            contagem.append({'Nome':i['razao'],'CNPJ':i['cnpj'],'IE':i['ie']})
                            try:
                                sf.Request_sefaz_info(i['ie'], driver,re.sub(r'\D','',i['cnpj']))
                                nfe_v=True
                            except:
                                pass
                            sleep(0.55)
                            try:
                                #nfc.requestNFC(i['ie'],driver,re.sub(r'\D','',i['cnpj']))
                                nfc_v=None
                            except:
                                pass
                            sleep(1)
                        data={'Empresa':i['razao'], 'CT-e':cte_v, 'NF-e':nfe_v, 'NFC':nfc_v, 'Tempo':perf_counter()-inicio, 'Data Download':dt.today().isoformat()}
                        with open(f'{pasta_bots}/modal_erros/sefaz_log.json','a',encoding='utf-8') as f:json.dump(data,f,indent=4,ensure_ascii=False)
                    except:
                        continue
                driver.quit()
                
            #Efetua a verificação se foi inserido a leitura de uma empresa no modo singular
            if len(only_emp)==3:
                try:
                    from . import sefaz_nfe as sf

                    with open(f"{pasta_bots}/controle/controle.json", 'r') as f:controle=json.load(f)
                    cont=[list(i.keys())[0] for i in controle]
                    print(f"REQUESTE -> {cont}")

                    data=re.sub(r'\D','',str(only_emp[1]))
                    empresa_inf=db.SQLConn().parametro_readline(param=[only_emp[0], data])
                    
                    if empresa_inf['razao'] not in [list(i.keys())[0] for i in controle]:
                        data_={"mes":f'{only_emp[2]}',"ano":'2025'}
                        mes=formatar_data(data_['mes'], mode='str_format')
                        pasta_=os.path.join(os.path.expanduser("~"),f'.arquivos_api/{data}/{mes}/{data_['ano']}/nfe/xml')
                        sf.Request_sefaz_info(ie=empresa_inf['ie'], driver=driver, cnpj=empresa_inf['cnpj'], data_vigente=data_)
                        print(f"IE empresa -> {empresa_inf['ie']}")
                        sleep(1.5)

                        data_formatada={"mes":mes,"ano":"2025"}
                        pasta_arquivos=os.listdir(os.path.join(os.path.expanduser("~"), f'.arquivos_api/{data}/{mes}/{data_['ano']}/nfe/html'))
                        pasta_arquivos_xls=os.listdir(os.path.join(os.path.expanduser("~"), f'.arquivos_api/{data}/{mes}/{data_['ano']}/nfe/xls'))
                        print("Requeste extração")
                        sleep(5)
                        if len(pasta_arquivos)>0 and len(pasta_arquivos_xls)>0:
                            for arquivo in pasta_arquivos:
                                try:
                                    print(arquivo)
                                    Extrair.extrai_info(file_nfe_html=arquivo, codigo_dominio=empresa_inf['codigo'], razao=empresa_inf['razao'], cnpj=only_emp[1] ,path=pasta_,regime=empresa_inf['modalidade'], data_=data_formatada)
                                except Exception as e:
                                    print(f"Error -> {e}")
                                    continue
                            tarefa=threading.Thread(target=verificar_notas, args=(only_emp[1], controle, mes, empresa_inf))
                            tarefa.start()
                            tarefa.join()
                            sleep(1)
                        elif len(pasta_arquivos_xls)>0 and len(pasta_arquivos)==0:
                            tarefa=threading.Thread(target=verificar_notas, args=(only_emp[1], controle, mes, empresa_inf))
                            tarefa.start()
                            tarefa.join()
                        
                        else:
                            print("Não consta arquivos validos na pasta")
                            return
                except Exception as e:
                    print(f"Error modulo sefaz -> {e}")        
                driver.quit()
            else:
                print('Error empresa não especificada')

          
        except ValueError as e:
            print(f'ERRO: {e}')
        return None      

# RequestNFe(cliente='192.168.1.186', only_emp=["cnpj", f"50893362000127", "10"]) 

import requests
# IMPORTAÇÃO EM LOTE VIA DB
class RequesteInit:
    def __init__():
        print("Iniciando Bot de extração")
    def iniciar():
        emp=[i for i in db.SQLConn().parametro_read()]
        for i in range(len(emp)):
            try:
                sleep(1)
                int(emp[i]['ie'])
                RequestNFe(cliente='192.168.1.186', only_emp=['cnpj',f'{emp[i]['cnpj']}', str(date.today().month)])
                sleep(5)
            except:
                continue

        for i in range(len(emp)):
            try:
                sleep(5)
                RequestGuias(cliente='192.168.1.186', empresa=f"{emp[i]["cnpj"]}",extrair=[1,1,1,1], )
                sleep(1)
            except:
                continue
    

def iniciar_singular(emp):
    try:
        RequestNFe(cliente='192.168.1.186', only_emp=["cnpj", f"{emp}", f"{date.today().month}"]) 
    except Exception as e:
        print(f"Erro modulo {e}")


# print(f'EXTRAÇÃO FINALIZADA...efetuando desligamento')
# sleep(10)
# try:
#     subprocess.run(["shutdown","/s","/t","0"], check=True)
# except subprocess.CalledProcessError as e:
#     print(f"Erro ao desligar maquina {e}")



# empresas=db.SQLConn().parametro_read()
# for i,v in enumerate(empresas):
#     if v['ie']!=None and v['ie']!='None' and v['ie']!='Null' and v['ie']!="":
#         RequestNFe(cliente='192.168.1.186', only_emp=['cnpj', v['cnpj']])
#     sleep(1.5)