import os
import sys
import pandas as pd
import mysql.connector
from datetime import datetime
from dotenv import load_dotenv

# Carrega configurações do .env
script_dir = os.path.dirname(os.path.abspath(__file__))
dotenv_path = os.path.join(script_dir, '../.env')
load_dotenv(dotenv_path)


DB_HOST = os.getenv("DB_HOST", "localhost")
DB_NAME = os.getenv("DB_NAME", "sgd_wkve_build")
DB_USER = os.getenv("DB_USER", "sgd_wkve_prod")
DB_PASS = os.getenv("DB_PASS", "2hOyYbkJUchq")

def converter_data_hora(data_str):
    if pd.isna(data_str) or str(data_str).strip() == "":
        return None
    data_str = str(data_str).strip()
    try:
        dt = datetime.strptime(data_str, "%d/%m/%Y %H:%M:%S")
        return dt.strftime("%Y-%m-%d %H:%M:%S")
    except ValueError:
        try:
            dt = datetime.strptime(data_str, "%d/%m/%Y")
            return dt.strftime("%Y-%m-%d %H:%M:%S")
        except ValueError:
            return None

def main():
    if len(sys.argv) < 2:
        print("Erro: Caminho do arquivo Excel não fornecido.")
        sys.exit(1)

    file_path = sys.argv[1]

    if not os.path.exists(file_path):
        print(f"Erro: Arquivo não encontrado - {file_path}")
        sys.exit(1)

    print(f"Processando arquivo: {file_path}")

    # Ler Excel (pulando cabeçalho se houver)
    try:
        df = pd.read_excel(file_path, header=0)
    except Exception as e:
        print(f"Erro ao ler arquivo Excel: {e}")
        sys.exit(1)

    # Conectar ao banco
    try:
        if DB_HOST == "localhost" and os.path.exists("/var/run/mysqld/mysqld.sock"):
            try:
                conn = mysql.connector.connect(
                    unix_socket="/var/run/mysqld/mysqld.sock",
                    database=DB_NAME,
                    user=DB_USER,
                    password=DB_PASS
                )
            except Exception as socket_err:
                print(f"Conexão via Unix socket falhou ({socket_err}). Tentando via TCP...")
                conn = mysql.connector.connect(
                    host=DB_HOST,
                    database=DB_NAME,
                    user=DB_USER,
                    password=DB_PASS
                )
        else:
            conn = mysql.connector.connect(
                host=DB_HOST,
                database=DB_NAME,
                user=DB_USER,
                password=DB_PASS
            )
        cursor = conn.cursor(dictionary=True)
    except Exception as e:
        print(f"Erro ao conectar ao banco de dados: {e}")
        sys.exit(1)

    date_columns = ['inicio_esperado', 'prazo', 'criacao', 'encerrado', 'entrega_estimada']
    
    # Processar linhas
    for index, row in df.iterrows():
        try:
            tarefa = str(row.iloc[0])
            if pd.isna(row.iloc[0]) or tarefa.strip() == "":
                continue

            status = str(row.iloc[1]) if pd.notna(row.iloc[1]) else None
            descricao_resumida = str(row.iloc[2]) if pd.notna(row.iloc[2]) else None
            companhia = str(row.iloc[3]) if pd.notna(row.iloc[3]) else None
            unidade_negocio = str(row.iloc[4]) if pd.notna(row.iloc[4]) else None
            grupo_suporte = str(row.iloc[5]) if pd.notna(row.iloc[5]) else None
            designado_para = str(row.iloc[6]) if pd.notna(row.iloc[6]) else None
            item_requisicao = str(row.iloc[7]) if pd.notna(row.iloc[7]) else None
            requisitado_por = str(row.iloc[8]) if pd.notna(row.iloc[8]) else None
            solicitado_para = str(row.iloc[9]) if pd.notna(row.iloc[9]) else None
            
            inicio_esperado = converter_data_hora(row.iloc[10])
            prazo = converter_data_hora(row.iloc[11])
            criacao = converter_data_hora(row.iloc[12])
            encerrado = converter_data_hora(row.iloc[13])
            entrega_estimada = converter_data_hora(row.iloc[14])
            
            info_adicionais = str(row.iloc[15]) if pd.notna(row.iloc[15]) else None
            serv_detalhado = str(row.iloc[16]) if pd.notna(row.iloc[16]) else None
            atualizadopor = str(row.iloc[17]) if pd.notna(row.iloc[17]) else None
            atualizacao = str(row.iloc[18]) if pd.notna(row.iloc[18]) else None
            motivo = str(row.iloc[19]) if pd.notna(row.iloc[19]) else None
            email = str(row.iloc[20]) if pd.notna(row.iloc[20]) else None
            email_ponto_focal = str(row.iloc[21]) if pd.notna(row.iloc[21]) else None

            # Verifica se já existe
            cursor.execute("SELECT * FROM tarefas WHERE tarefa = %s", (tarefa,))
            existing = cursor.fetchone()

            novos_dados = {
                'status_tarefas': status,
                'descricao_resumida': descricao_resumida,
                'companhia': companhia,
                'unidade_negocio': unidade_negocio,
                'grupo_suporte': grupo_suporte,
                'designado_para': designado_para,
                'item_requisicao': item_requisicao,
                'requisitado_por': requisitado_por,
                'solicitado_para': solicitado_para,
                'inicio_esperado': inicio_esperado,
                'prazo': prazo,
                'criacao': criacao,
                'encerrado': encerrado,
                'entrega_estimada': entrega_estimada,
                'info_adicionais': info_adicionais,
                'serv_detalhado': serv_detalhado,
                'atualizadopor': atualizadopor,
                'atualizacao': atualizacao,
                'motivo': motivo,
                'email': email,
                'email_ponto_focal': email_ponto_focal
            }

            if existing:
                campos_para_atualizar = []
                valores_para_atualizar = []
                alteracoes_log = []

                for campo, novo_valor in novos_dados.items():
                    valor_atual = existing.get(campo)
                    
                    if campo in date_columns:
                        if valor_atual is not None:
                            valor_atual = str(valor_atual)
                        if novo_valor is not None:
                            novo_valor = str(novo_valor)

                    if str(valor_atual) != str(novo_valor):
                        campos_para_atualizar.append(f"{campo} = %s")
                        valores_para_atualizar.append(novo_valor)
                        alteracoes_log.append((tarefa, campo, valor_atual, novo_valor))

                if campos_para_atualizar:
                    valores_para_atualizar.append(tarefa)
                    sql_update = f"UPDATE tarefas SET {', '.join(campos_para_atualizar)} WHERE tarefa = %s"
                    cursor.execute(sql_update, tuple(valores_para_atualizar))
                    
                    # Salva log de alteracoes
                    for log_entry in alteracoes_log:
                        cursor.execute(
                            "INSERT INTO log_alteracoes (tarefa, campo, valor_antigo, valor_novo) VALUES (%s, %s, %s, %s)",
                            log_entry
                        )
                    conn.commit()
                    print(f"Tarefa '{tarefa}' atualizada com sucesso.")
                else:
                    print(f"Tarefa '{tarefa}' já está atualizada.")
            else:
                sql_insert = """
                INSERT INTO tarefas (
                    tarefa, status_tarefas, descricao_resumida, companhia, unidade_negocio,
                    grupo_suporte, designado_para, item_requisicao, requisitado_por, solicitado_para, 
                    inicio_esperado, prazo, criacao, encerrado, entrega_estimada, info_adicionais,
                    serv_detalhado, atualizadopor, atualizacao, motivo, email, email_ponto_focal
                ) VALUES (
                    %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s
                )
                """
                valores_insert = (
                    tarefa, status, descricao_resumida, companhia, unidade_negocio,
                    grupo_suporte, designado_para, item_requisicao, requisitado_por, solicitado_para,
                    inicio_esperado, prazo, criacao, encerrado, entrega_estimada, info_adicionais,
                    serv_detalhado, atualizadopor, atualizacao, motivo, email, email_ponto_focal
                )
                cursor.execute(sql_insert, valores_insert)
                conn.commit()
                print(f"Tarefa '{tarefa}' inserida com sucesso.")

        except Exception as e:
            print(f"Erro processando linha {index} (tarefa: {row.iloc[0]}): {e}")

    # Sincronização dos dados (Equivalente ao sincronizacao/processo.php)
    print("Iniciando sincronização pós-importação...")
    try:
        # Passo 1: Atualização de Status
        print("Sincronizando tabela de status...")
        status_map = {
            'Em andamento': 6,
            'Resolvido': 8,
            'Pendente': 9,
            'Cancelado': 12,
            'Encerrado': 13
        }
        
        # Buscar tarefas
        cursor.execute("SELECT idtarefa, status_tarefas FROM tarefas")
        tarefas_status = cursor.fetchall()
        
        sql_upsert_status = """
            INSERT INTO status (idtarefa, id_status) VALUES (%s, %s)
            ON DUPLICATE KEY UPDATE id_status = VALUES(id_status)
        """
        
        status_records = []
        for t in tarefas_status:
            id_val = t['idtarefa']
            status_str = t['status_tarefas']
            status_id = status_map.get(status_str, 1) # Default é 1
            status_records.append((id_val, status_id))
            
        # Executar em lote
        if status_records:
            cursor.executemany(sql_upsert_status, status_records)
            conn.commit()
            print(f"Status atualizados: {len(status_records)} registros.")

        # Passo 2: Atualização de Levantamento
        print("Atualizando levantamento...")
        sql_levantamento = """
            INSERT INTO levantamento (
                idtarefa, tarefa, nome_demanda, escopo, data_solicitacao, 
                idUsuario, id_status, status_siged, 
                id_focal, id_gat, idlocalidade
            )
            SELECT 
                t.idtarefa, t.tarefa, t.info_adicionais, t.serv_detalhado, t.criacao, 
                57, s.id_status, sd.status_nome, 120,
                CASE 
                    WHEN t.grupo_suporte LIKE '%CARAJAS%' THEN 31
                    WHEN t.grupo_suporte LIKE '%SÃO LUIS%' THEN 58
                    WHEN t.grupo_suporte LIKE '%SOSSEGO%' THEN 32
                    WHEN t.grupo_suporte LIKE '%S11D%' THEN 37
                    WHEN t.grupo_suporte LIKE '%MARABÁ%' THEN 61
                    WHEN t.grupo_suporte LIKE '%SALOBO%' THEN 32
                    WHEN t.grupo_suporte LIKE '%SERRA SUL%' THEN 37
                    WHEN t.grupo_suporte LIKE '%ACAILÂNDIA%' THEN 61
                    WHEN t.grupo_suporte LIKE '%BELÉM%' THEN 87
                    WHEN t.grupo_suporte LIKE '%SANTA INÊS%' THEN 61
                    WHEN t.grupo_suporte LIKE '%OURILANDIA%' THEN 32
                    ELSE 1
                END,
                CASE
                    WHEN t.grupo_suporte LIKE '%SALOBO%' THEN 1
                    WHEN t.grupo_suporte LIKE '%CARAJAS%' THEN 3
                    WHEN t.grupo_suporte LIKE '%SÃO LUIS%' THEN 12
                    WHEN t.grupo_suporte LIKE '%SOSSEGO%' THEN 5
                    WHEN t.grupo_suporte LIKE '%S11D%' THEN 2
                    WHEN t.grupo_suporte LIKE '%MARABÁ%' THEN 11
                    WHEN t.grupo_suporte LIKE '%SERRA SUL%' THEN 2
                    WHEN t.grupo_suporte LIKE '%OURILANDIA%' THEN 6
                    WHEN t.grupo_suporte = 'PRJ Cabling WKVE -LA BR MG-DIFL' THEN 23
                    ELSE 12
                END
            FROM tarefas t
            LEFT JOIN status s ON t.idtarefa = s.idtarefa
            LEFT JOIN status_demanda sd ON s.id_status = sd.id_status
            ON DUPLICATE KEY UPDATE 
                nome_demanda = VALUES(nome_demanda),
                escopo       = VALUES(escopo)
        """
        cursor.execute(sql_levantamento)
        conn.commit()
        print(f"Levantamento atualizado com sucesso (linhas afetadas: {cursor.rowcount}).")

        # Passo 3: Correção de info_adicionais
        print("Corrigindo info_adicionais nulos...")
        sql_info_adicionais = "UPDATE tarefas SET info_adicionais = serv_detalhado WHERE info_adicionais IS NULL"
        cursor.execute(sql_info_adicionais)
        conn.commit()
        print(f"Info adicionais corrigidos (linhas afetadas: {cursor.rowcount}).")
        
        print("Sincronização concluída com sucesso!")
    except Exception as sync_err:
        print(f"Erro durante o processo de sincronização: {sync_err}")

    cursor.close()
    conn.close()

    # Se terminou tudo sem falhar fatalmente, remove o arquivo
    try:
        os.remove(file_path)
        print(f"Arquivo temporário {file_path} deletado com sucesso.")
    except OSError as e:
        print(f"Erro ao deletar o arquivo {file_path}: {e}")

if __name__ == "__main__":
    main()
