import requests
import jwt  # Requer: pip install PyJWT
from datetime import datetime, timezone
from http.cookies import SimpleCookie

class FgtsClient:
    def __init__(self):
        # Headers copiados fielmente do seu cURL
        self.headers = {
            "Host": "fgtsdigital.sistema.gov.br",
            "Sec-Ch-Ua-Platform": '"Linux"',
            "Accept-Language": "pt-BR,pt;q=0.9",
            "Accept": "application/json, text/plain, */*",
            "Sec-Ch-Ua": '"Chromium";v="143", "Not A(Brand";v="24"',
            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
            "Sec-Ch-Ua-Mobile": "?0",
            "Sec-Fetch-Site": "same-origin",
            "Sec-Fetch-Mode": "cors",
            "Sec-Fetch-Dest": "empty",
            "Referer": "https://fgtsdigital.sistema.gov.br/portal/servicos",
            "Accept-Encoding": "gzip, deflate, br",
            "Priority": "u=1, i",
            "Connection": "keep-alive"
        }
        self.base_url = "https://fgtsdigital.sistema.gov.br/proxy-api/v2/perfil"

    def _parse_cookie_str_to_dict(self, cookie_str: str) -> dict:
        """Helper para converter string de cookie (k=v; k2=v2) para dicionário."""
        cookie = SimpleCookie()
        cookie.load(cookie_str)
        return {k: v.value for k, v in cookie.items()}

    def _dict_to_cookie_str(self, cookie_jar) -> str:
        """Converte o CookieJar do requests de volta para string pura."""
        return "; ".join([f"{cookie.name}={cookie.value}" for cookie in cookie_jar])

    def swap_context(self, company_cookie_decrypted: str, customer_cnpj: str):
        """
        Executa o GET /perfil emulando a troca de empresa para cliente.
        Retorna o novo cookie completo e a data de expiração.
        """
        
        # 1. Prepara os Cookies
        # Transformamos a string do banco em dict para a lib requests gerenciar
        cookies_dict = self._parse_cookie_str_to_dict(company_cookie_decrypted)
        
        # 2. Parâmetros da URL (do seu cURL)
        params = {
            "tipoPerfil": "2",  # 2 = Perfil de Procurador/Cliente
            "niPerfil": customer_cnpj
        }

        try:
            # 3. Faz a requisição
            # verify=False emula o -k do cURL
            response = requests.get(
                self.base_url, 
                headers=self.headers, 
                params=params, 
                cookies=cookies_dict, 
                verify=False,
                timeout=15
            )
            
            response.raise_for_status()

            # response_cookies_string = "; ".join([f"{cookie.name}={cookie.value}" for cookie in response.cookies])

            # return {response.status_code, response.text, response_cookies_string}

            # 4. Processa o Retorno
            # O requests atualiza o 'cookies_dict' original com os novos 'Set-Cookie' da resposta.
            # O objeto response.cookies contém a fusão do que foi enviado + o que foi recebido.
            
            # Precisamos capturar o novo JWT (fgtsd_token) que veio na resposta
            new_jwt = response.cookies.get("fgtsd_token")

            # return new_jwt, response
            
            if not new_jwt:
                # Fallback: Se não veio no cookie, as vezes vem no JSON de resposta
                try:
                    json_resp = response.json()
                    new_jwt = json_resp.get("accessToken") # Ajustar chave conforme retorno real
                except:
                    pass
            
            if not new_jwt:
                raise Exception("Token JWT (fgtsd_token) não encontrado na resposta do FGTS.")

            # 5. Decodifica o JWT para pegar a expiração
            # options={"verify_signature": False} pois não temos a chave privada do governo
            decoded = jwt.decode(new_jwt, options={"verify_signature": False})
            exp_timestamp = decoded.get("exp")
            
            if not exp_timestamp:
                raise Exception("Campo 'exp' não encontrado no JWT.")

            expires_on = datetime.fromtimestamp(exp_timestamp, tz=timezone.utc)

            # 6. Reconstrói a string de cookies completa
            # Isso garante que pegamos o cookie da Company + as atualizações do Customer (fgtsd_tipo_perfil=2, etc)
            full_new_cookie = self._dict_to_cookie_str(response.cookies)

            return {
                "cookie": full_new_cookie,
                "expires_on": expires_on
            }

        except requests.RequestException as e:
            print(f"Erro de conexão com FGTS: {e}")
            raise e
        except Exception as e:
            print(f"Erro ao processar troca de perfil: {e}")
            raise e