using System.Collections.Concurrent;
using System.Data;
using System.Data.OleDb;
using System.Globalization;
using System.Net;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Xml.Linq;
using Npgsql;

internal class Plat_integ
{
    static string PG_CONN_STRING_PROD = "Server = smart-energia-dev-pgsql.cykff7tj7mik.us-east-1.rds.amazonaws.com; Port = 5432; Database = smartenergiaprod; Username = postgres; Password = VfHml#Z78!%kvvNM; Timeout = 60; CommandTimeout = 60; ApplicationName = new_med_5_min; Connection Lifetime = 120; Minimum Pool Size = 2; Maximum Pool Size = 2;";
    static readonly HttpClient client = new HttpClient(new HttpClientHandler
    {
        ClientCertificateOptions = ClientCertificateOption.Automatic,
        //Proxy = new WebProxy("127.0.0.1", 8888),
        //UseProxy = true,
        //ServerCertificateCustomValidationCallback = (HttpRequestMessage req, X509Certificate2? cert, X509Chain? chain, SslPolicyErrors errors) => true
    });

    static async Task Main()
    {
        Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
        DateTime inicio = DateTime.Now;

        string caminhoBD = @"\\srv-dados\documentos\Middle\Informativo Setorial\Modelo Word\BD1_dados cadastrais e faturas.accdb";
        string caminhoLog = $@"\\srv-dados\documentos\Back\Carteira x.x\Codigo\Erros\log_erros_{DateTime.Now:MM_dd_HH_mm}.csv";

        var perfis = Busca_dad_BD(caminhoBD);

        DateTime now = DateTime.Now;
        //DateTime dataIni = new DateTime(now.Year, now.Month, 1);
        //DateTime dataFim = new DateTime(now.Year, now.Month, now.Day);
        DateTime dataIni = new DateTime(now.Year, 7, 1);
        DateTime dataFim = new DateTime(now.Year, 8, 1);

        await ProcessarMedicoesAsync(dataIni, dataFim, perfis, caminhoLog);

        Console.WriteLine($"Concluído. Tempo total: {DateTime.Now - inicio}");

        Console.ReadKey();
    }
    public static List<Tuple<string, string>> Busca_dad_BD(string caminho_BD)
    {
        var lista = new List<Tuple<string, string>>();

        //strCOM = "SELECT Cod_5min, Codigo_SCDE FROM Dados_cadastrais WHERE LEN(Codigo_SCDE) > 5 AND Unidade_gerenciada = TRUE ORDER BY PerfilCCEE";
        string query = "SELECT Cod_5min, Codigo_SCDE FROM Dados_cadastrais WHERE LEN(Codigo_SCDE) > 5 and Cliente = 'TECNOGRAN' ORDER BY PerfilCCEE";
        //strCOM = "SELECT Cod_5min, Codigo_SCDE FROM Dados_cadastrais WHERE LEN(Codigo_SCDE) > 5 and Cliente = 'ALMAVIVA' and Unidade = 'GUARULHOS' ORDER BY PerfilCCEE";
        using var conn = new OleDbConnection($"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={caminho_BD};Jet OLEDB:Database Password=gds21");
        conn.Open();

        using var cmd = new OleDbCommand(query, conn);
        using var reader = cmd.ExecuteReader();

        while (reader.Read())
            lista.Add(new Tuple<string, string>(reader["Cod_5min"].ToString(), reader["Codigo_SCDE"].ToString()));

        return lista;
    }

    private static async Task ProcessarMedicoesAsync(DateTime dataIni, DateTime dataFim, List<Tuple<string, string>> perfis, string caminhoLog)
    {
        var errosPersistentes = new ConcurrentBag<string>();

        //using var conn = new NpgsqlConnection(PG_CONN_STRING_PROD);
        //await conn.OpenAsync();
        await using var dataSource = NpgsqlDataSource.Create(PG_CONN_STRING_PROD);

        //client.DefaultRequestHeaders.Clear();
        client.DefaultRequestHeaders.Add("SOAPAction", "listarMedidaCincoMinutos");
        var endpoint = new Uri("https://servicos.ccee.org.br/ws/v2/MedidaCincoMinutosBSv2");

        var datas = Enumerable.Range(0, (dataFim - dataIni).Days).Select(i => dataIni.AddDays(i));

        await Parallel.ForEachAsync(datas/*, new ParallelOptions { MaxDegreeOfParallelism = 1 }*/, async (dia, ct) =>
        {
            foreach (var item in perfis)
            {
                int tentativas = 0;
                bool sucesso = false;

                while (tentativas < 5 && !sucesso)
                {
                    try
                    {
                        string payload = Xml_requisicao(dia, item.Item1, item.Item2, 1);
                        var conteudo = new StringContent(payload, Encoding.UTF8, "application/xml");

                        using var response = await client.PostAsync(endpoint, conteudo, ct);

                        if ((int)response.StatusCode == 429) // limite da API
                        {
                            Console.WriteLine("⚠️ Limite de requisições atingido. Aguardando próximo minuto...");
                            var now = DateTime.UtcNow;
                            var delay = 60000 - (now.Second * 1000 + now.Millisecond);
                            await Task.Delay(delay, ct);
                            continue; // tentar de novo sem contar como falha
                        }

                        response.EnsureSuccessStatusCode();

                        string resposta = await response.Content.ReadAsStringAsync(ct);
                        await ProcessarXMLAsync(resposta, await dataSource.OpenConnectionAsync());

                        sucesso = true;
                    }
                    catch (Exception ex)
                    {
                        tentativas++;
                        if (tentativas == 5)
                        {
                            errosPersistentes.Add($"{item.Item1};{item.Item2};Erro;{ex.Message.Replace("\n", "-n-")}");
                        }
                        else
                        {
                            int backoff = (int)Math.Pow(2.4, tentativas) * 1000; // exponencial
                            Console.WriteLine($"Erro na requisição ({ex.Message}), tentativa {tentativas}. Aguardando {backoff / 1000}s...");
                            await Task.Delay(backoff, ct);
                        }
                    }
                }
            }
        });

        if (errosPersistentes.Count > 0)
        {
            File.WriteAllLines(caminhoLog, new[] { "Perfil;Ponto;Status;Message" }.Concat(errosPersistentes));
        }
    }
    public static string Xml_requisicao(DateTime data_req, string perfil, string cod_ponto, int pagina)
    {
        string cam_ent, tex_req, sdat_req;
        cam_ent = @"X:\Back\Plataforma de Integração CCEE\RequestPaginate.txt";
        cod_ponto += "P";
        sdat_req = data_req.ToString("yyyy-MM-ddT00:00:00");
        tex_req = File.ReadAllText(cam_ent);
        tex_req = tex_req.Replace("DATAALTERADA", sdat_req);
        tex_req = tex_req.Replace("PONTOMEDICAO", cod_ponto);
        tex_req = tex_req.Replace("CODPERFIL", perfil);
        tex_req = tex_req.Replace("PAGNUM", pagina.ToString());
        return tex_req;
    }
    private static async Task<int> ProcessarXMLAsync(string xml, NpgsqlConnection connection, List<XElement>? acumulador = null, int paginaAtual = 1, int totalPaginas = 1)
    {
        var doc = XDocument.Parse(xml);
        XNamespace ns = "http://xmlns.energia.org.br/BO/v2";

        int.TryParse(doc.Descendants().FirstOrDefault(e => e.Name.LocalName == "totalPaginas")?.Value, out totalPaginas);
        int.TryParse(doc.Descendants().FirstOrDefault(e => e.Name.LocalName == "numero")?.Value, out paginaAtual);


        var medidas = doc.Descendants(ns + "medida")
                         .Where(x => (string)x.Element(ns + "tipoEnergia") == "L");
        acumulador ??= new List<XElement>();
        acumulador.AddRange(medidas);

        //if (paginaAtual < totalPaginas)
        //{
        //    // Requisita próxima página
        //    string payload = Xml_requisicao(DateTime.Parse(acumulador.First().Element(ns + "data")!.Value),   // data de referência
        //                                    acumulador.First().Element(ns + "perfil")?.Value ?? "",         // perfil (ajustar conforme necessário)
        //                                    acumulador.First().Element(ns + "medidor")?.Element(ns + "codigo")?.Value ?? "",
        //                                    paginaAtual + 1);

        //    var conteudo = new StringContent(payload, Encoding.UTF8, "application/xml");
        //    using var resp = await client.PostAsync("https://servicos.ccee.org.br/ws/v2/MedidaCincoMinutosBSv2", conteudo);

        //    string proxXml = await resp.Content.ReadAsStringAsync();
        //    return await ProcessarXMLAsync(proxXml, conn, acumulador, paginaAtual + 1, totalPaginas);
        //}

        var medidasProcessadas = acumulador
        .Select(m =>
        {
            string origem = m.Element(ns + "coletaMedicao")?.Element(ns + "tipo")?.Element(ns + "nome")?.Value ?? "";
            string ponto = m.Element(ns + "medidor")?.Element(ns + "codigo")?.Value ?? "";
            DateTime data = DateTime.Parse(m.Element(ns + "data")?.Value ?? "");
            double diaNum = (data.ToOADate() - data.ToOADate() % 1);
            int minuto = data.Hour * 60 + data.Minute;
            if (minuto == 0) { minuto = 1440; diaNum--; }

            double.TryParse(m.Element(ns + "energiaAtiva")?.Element(ns + "consumo")?.Element(ns + "valor")?.Value, out double ativa_c);
            double.TryParse(m.Element(ns + "energiaAtiva")?.Element(ns + "geracao")?.Element(ns + "valor")?.Value, out double ativa_g);
            double.TryParse(m.Element(ns + "energiaReativa")?.Element(ns + "consumo")?.Element(ns + "valor")?.Value, out double reat_c);
            double.TryParse(m.Element(ns + "energiaReativa")?.Element(ns + "geracao")?.Element(ns + "valor")?.Value, out double reat_g);

            return new
            {
                Origem = origem,
                Ponto = ponto,
                DiaNum = diaNum,
                Minuto = minuto,
                AtivaC = ativa_c,
                AtivaG = ativa_g,
                ReatC = reat_c,
                ReatG = reat_g
            };
        })
        .GroupBy(x => new { x.Ponto, x.DiaNum, x.Minuto })
        .Select(g =>
        {
            // Se houver alguma Inspeção Lógica → prioriza
            var logica = g.FirstOrDefault(x => x.Origem == "Inspeção Lógica");
            return logica ?? g.First(); // se não tiver lógica, pega qualquer (coleta diária)
        });

        foreach (var m in medidasProcessadas)
        {
            // Primeiro tenta UPDATE
            string sqlUpdate = @"
                                    UPDATE med_5min
                                    SET origem = @origem,
                                        ativa_consumo = @ativa_c,
                                        ativa_geracao = @ativa_g,
                                        reativa_consumo = @reat_c,
                                        reativa_geracao = @reat_g
                                    WHERE ponto = @ponto
                                      AND dia_num = @dia_num
                                      AND minuto = @minuto;";

            using (var cmdUpdate = new NpgsqlCommand(sqlUpdate, connection))
            {
                cmdUpdate.Parameters.AddWithValue("origem", m.Origem);
                cmdUpdate.Parameters.AddWithValue("ativa_c", m.AtivaC);
                cmdUpdate.Parameters.AddWithValue("ativa_g", m.AtivaG);
                cmdUpdate.Parameters.AddWithValue("reat_c", m.ReatC);
                cmdUpdate.Parameters.AddWithValue("reat_g", m.ReatG);
                cmdUpdate.Parameters.AddWithValue("ponto", m.Ponto);
                cmdUpdate.Parameters.AddWithValue("dia_num", m.DiaNum);
                cmdUpdate.Parameters.AddWithValue("minuto", m.Minuto);

                int rowsAffected = await cmdUpdate.ExecuteNonQueryAsync();

                if (rowsAffected == 1)
                {
                    Console.WriteLine("atualizado");
                }
                // Se não atualizou ninguém → faz INSERT
                if (rowsAffected == 0)
                {
                    string sqlInsert = @"
                INSERT INTO med_5min
                (origem, dia_num, minuto, ativa_consumo, ativa_geracao, reativa_consumo, reativa_geracao, ponto)
                VALUES (@origem, @dia_num, @minuto, @ativa_c, @ativa_g, @reat_c, @reat_g, @ponto);
            ";

                    using var cmdInsert = new NpgsqlCommand(sqlInsert, connection);
                    cmdInsert.Parameters.AddWithValue("origem", m.Origem);
                    cmdInsert.Parameters.AddWithValue("dia_num", m.DiaNum);
                    cmdInsert.Parameters.AddWithValue("minuto", m.Minuto);
                    cmdInsert.Parameters.AddWithValue("ativa_c", m.AtivaC);
                    cmdInsert.Parameters.AddWithValue("ativa_g", m.AtivaG);
                    cmdInsert.Parameters.AddWithValue("reat_c", m.ReatC);
                    cmdInsert.Parameters.AddWithValue("reat_g", m.ReatG);
                    cmdInsert.Parameters.AddWithValue("ponto", m.Ponto);

                    await cmdInsert.ExecuteNonQueryAsync();

                    Console.WriteLine("inserido");
                }
            }
        }

        return totalPaginas;
    }
}