import requests
import json
import time
import os
from datetime import datetime

def get_cached_token():
    """
    Verifica se existe um token válido armazenado em 'token_cache.json'.
    Se não existir ou estiver expirado, chama get_token() para obter um novo token.
    """
    cache_file = "token_cache.json"
    if os.path.exists(cache_file):
        with open(cache_file, "r", encoding="utf-8") as f:
            cache_data = json.load(f)
        if ("token" in cache_data and "expires" in cache_data and 
                cache_data["expires"] > time.time()):
            return cache_data["token"]
    token = get_token()
    if not token:
        raise Exception("Falha ao obter token.")
    with open(cache_file, "w", encoding="utf-8") as f:
        json.dump({"token": token, "expires": time.time() + 14400}, f)
    return token

def get_token():
    """
    Chama o endpoint de token e extrai o token da resposta.
    O endpoint retorna uma string no formato: "Token obtido: <seu_token>"
    """
    token_url = "http://localhost/BI-HITS/dados/Hits/token/token.php"
    payload = {
        "username": "seu_usuario",  # Ajuste conforme necessário
        "password": "sua_senha"       # Ajuste conforme necessário
    }
    try:
        response = requests.post(token_url, data=payload, timeout=30)
        response.raise_for_status()
        raw = response.text
        print("Raw token response:", raw)
        prefix = "Token obtido:"
        if raw.startswith(prefix):
            token = raw.replace(prefix, "").strip()
            return token
        else:
            data = response.json()
            return data.get("token")
    except Exception as e:
        print("Erro ao obter token:", e)
        return None

def fetch_rooming_nights(page, headers, ini_date, fin_date, size, retries=3, timeout=60):
    """
    Busca os registros do endpoint RoomingNights para a página especificada.
    Implementa re-tentativas em caso de erro.
    """
    url = "https://api.hitspms.net/Datashare/RevenueManagement/RoomingNights"
    params = {
        "IniDate": ini_date,
        "FinDate": fin_date,
        "Page": page,
        "Size": size
    }
    attempt = 0
    while attempt < retries:
        try:
            response = requests.get(url, headers=headers, params=params, timeout=timeout)
            response.raise_for_status()
            result = response.json()
            # Se a resposta vier encapsulada em um dicionário (ex: com chave "data"), extraia a lista
            if isinstance(result, dict) and "data" in result:
                result = result["data"]
            return result
        except Exception as e:
            print(f"Erro na página {page} na tentativa {attempt+1}: {e}")
            attempt += 1
            time.sleep(3)
    return []

def main():
    # Define o período: de 01/01/2024 até 31/12/2025
    ini_date = "2024-01-01T00:00:00"
    fin_date = "2025-12-31T23:59:59"
    size = 50  # Máximo por página (conforme a documentação)
    page = 0
    all_data = []
    debug_paginas = []
    
    # Obtém o token (utilizando cache)
    token = get_cached_token()
    
    headers = {
        "X-API-VERSION": "1",
        "X-API-TENANT-NAME": "thecoralbeachresort",  # Ajuste conforme necessário
        "X-API-PROPERTY-CODE": "1",                   # Ajuste conforme necessário
        "X-API-PARTNER-USERID": "0",
        "X-API-LANGUAGE-CODE": "pt-br",
        "X-Client-Id": "THECORALBR",                  # Insira sua chave de partner, se aplicável
        "Authorization": f"Bearer {token}"
    }
    
    while True:
        data = fetch_rooming_nights(page, headers, ini_date, fin_date, size)
        if not isinstance(data, list):
            print(f"Página {page} retornou uma estrutura inesperada: {data}")
            break
        
        count = len(data)
        debug_paginas.append(f"Página {page}: {count} registros carregados.")
        print(f"[Página {page}] {count} registros carregados.")
        
        if count == 0:
            break
        
        all_data.extend(data)
        
        # Se a quantidade retornada for menor que o tamanho solicitado, provavelmente chegamos ao fim
        if count < size:
            break
        
        page += 1
    
    print("\nLogs de Paginação:")
    for log in debug_paginas:
        print(log)
    
    # Nova lógica para salvar o arquivo com data e hora atuais
    current_time = datetime.now()
    formatted_time = current_time.strftime("%Y%m%d_%H%M%S")
    output_dir = r"C:\xampp\htdocs\BI-HITS\dados\json"
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)
    output_file = os.path.join(output_dir, f"roomingnights_{formatted_time}.json")
    
    try:
        with open(output_file, "w", encoding="utf-8") as f:
            json.dump(all_data, f, ensure_ascii=False, indent=4)
        print(f"\nDados salvos com sucesso em {output_file}")
    except Exception as e:
        print("Erro ao salvar os dados:", e)

if __name__ == '__main__':
    main()