using System;
using System.Data.OleDb;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.Json;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Reflection.Metadata;
using Pipefy;
using Microsoft.VisualBasic;
using System.Net.Quic;
using Microsoft.Extensions.Configuration;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;
using Microsoft.Extensions.Configuration.UserSecrets;
using static System.Net.Mime.MediaTypeNames;

class Program
{
    static async Task Main(string[] args)
    {
        var configurationBuilder = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()).AddJsonFile("appsettings.json", optional: false);
        IConfiguration configuration = configurationBuilder.Build();
        AppSettings AppSettings = configuration.GetSection("AppSettings").Get<AppSettings>();

        if (AppSettings is null){ Environment.Exit(1); }

        Console.Clear();

        // URL da API que você deseja chamar
        string ConnSourcePath = AppSettings.DB_PATH;
        string apiUrl = AppSettings.PIPEFY_API_URL;
        string PipefyToken = AppSettings.PIPEFY_API_TOKEN;
        string PipefyTokenTableID = AppSettings.PIPEFY_TABLE_ID;
        string PipefyTokenTableIDGestores = AppSettings.PIPEFY_TABLE_ID_GESTORES;

        JArray allRecords = await GetPipefyDataAsync(apiUrl,PipefyToken,PipefyTokenTableID);
        JArray allGestores = await GetPipefyDataAsync(apiUrl, PipefyToken, PipefyTokenTableIDGestores);

        Console.Clear();

        if (allRecords is not null)
        {
            string strGestores = JsonConvert.SerializeObject(allGestores);
            // Desserialize o JSON em objetos C#
            var jsonGestores = JsonConvert.DeserializeObject<List<Pipefy.RootGestor>>(strGestores);

            List<Pipefy.ClasseGestores> jsonListGestores = convertGestoresJson(jsonGestores);

            string strJson = JsonConvert.SerializeObject(allRecords);
            // Desserialize o JSON em objetos C#
            var jsonData = JsonConvert.DeserializeObject<List<Pipefy.RootObject>>(strJson);

            List<Pipefy.ClasseEmpresas> jsonList = convertEmpresasJson(jsonData);

            // Consulte os dados da tabela no banco de dados Access
            List<Pipefy.ClasseEmpresas> databaseData = GetDataFromDatabase(ConnSourcePath);

            // Compare os dados e encontre os registros ausentes no JSON
            List<Pipefy.ClasseEmpresas> recordsMissingInJson = CompareData(databaseData, jsonList, jsonListGestores);

            if (recordsMissingInJson.Count != 0)
            {
                string strQuery = "{\"query\":\"mutation {\\r\\n  ";
                for (int i = 0; i < recordsMissingInJson.Count; i++)
                {
                    if (i % 49 == 0) { strQuery = "{\"query\":\"mutation {\\r\\n  "; }

                    strQuery = strQuery + $"N{i}: createTableRecord(input: {{ table_id: \\\"{PipefyTokenTableID}\\\", fields_attributes: [ {{ field_id: \\\"nome_da_empresa\\\", field_value: \\\"{recordsMissingInJson[i].nome_da_empresa.ToString()}\\\" }} {{ field_id: \\\"c_digo_smart\\\", field_value: \\\"{recordsMissingInJson[i].c_digo_smart.ToString()}\\\" }} {{ field_id: \\\"modalidade\\\", field_value: \\\"{recordsMissingInJson[i].modalidade.ToString()}\\\" }} {{ field_id: \\\"gestores\\\", field_value: \\\"{recordsMissingInJson[i].gestores.ToString()}\\\" }}]}}) {{ table_record {{ id }}}}\\r\\n  ";

                    if (i % 48 == 0 && i != 0) {
                        
                        strQuery = strQuery + "}\",\"variables\":{}}";

                        bool success = await CreatePipefyDataAsync(apiUrl, PipefyToken, PipefyTokenTableID, strQuery);

                        //if (!success) { 
                        //    int test2 = 10;
                        //}
                    }
                }

                strQuery = strQuery + "}\",\"variables\":{}}";

                bool success1 = await CreatePipefyDataAsync(apiUrl, PipefyToken, PipefyTokenTableID, strQuery);

                // Faça algo com os registros ausentes
                int maxCId = recordsMissingInJson.OrderByDescending(s => s.c_digo_smart.Length).First().c_digo_smart.Length;
                int maxCNome = recordsMissingInJson.OrderByDescending(s => s.nome_da_empresa.Length).First().nome_da_empresa.Length;
                int maxCMod = recordsMissingInJson.OrderByDescending(s => s.modalidade.Length).First().modalidade.Length;
                int maxCGestao = recordsMissingInJson.OrderByDescending(s => s.gestores.Length).First().gestores.Length;

                foreach (var record in recordsMissingInJson)
                {
                    Console.WriteLine(String.Format($"| ID: {{0,{maxCId}}} | Nome: {{1,{maxCNome}}} | Modalidade: {{2,{maxCMod}}} | Gestão: {{3,{maxCGestao}}} |",record.c_digo_smart,record.nome_da_empresa,record.modalidade,record.gestores));
                }
                
                Console.WriteLine($"");

            }
            
            Console.WriteLine($"{recordsMissingInJson.Count} registros encontrados.");

        }
        System.Threading.Thread.Sleep(10000);
    }
    private static async Task<bool> CreatePipefyDataAsync(string apiUrl, string PipefyToken, string PipefyTokenTableID, string query)
    {

        var httpClient = new HttpClient();
        // Defina os headers da requisição (opcional)
        httpClient.DefaultRequestHeaders.Add("Authorization", "Bearer " + PipefyToken);

        var request = new HttpRequestMessage(HttpMethod.Post, apiUrl);
        request.Headers.Add("Accept", "application/json");

        var content = new StringContent(query, null, "application/json");
        request.Content = content;
        var response = await httpClient.SendAsync(request);
        var body = JsonConvert.SerializeObject(response.Content);
        return response.IsSuccessStatusCode;
    }
    private static async Task<JArray> GetPipefyDataAsync(string apiUrl, string PipefyToken, string PipefyTokenTableID)
    {
        JArray allRecords = new JArray();

        string cursor = "null";

        string query = $"{{\"query\":\"query GetRecords($cursor: String){{    table_records(table_id: \\\"{PipefyTokenTableID}\\\",first:50,after:$cursor){{        pageInfo{{            hasNextPage            endCursor        }}        edges{{            node{{                id            record_fields{{                    field {{                        id                    }}                    value                    array_value                }}            }}        }}    }}}}\",\"variables\":{{\"cursor\":{cursor}}}}}";

        bool hasNextPage = true;

        while (hasNextPage)
        {
            var httpClient = new HttpClient();
            // Defina os headers da requisição (opcional)
            httpClient.DefaultRequestHeaders.Add("Authorization", "Bearer " + PipefyToken);

            var request = new HttpRequestMessage(HttpMethod.Post, apiUrl);
            request.Headers.Add("Accept", "application/json");

            var content = new StringContent(query, null, "application/json");
            request.Content = content;
            var response = await httpClient.SendAsync(request);

            if (response.IsSuccessStatusCode)
            {
                var responseContent = await response.Content.ReadAsStringAsync();
                var responseData = JObject.Parse(responseContent);

                Console.Clear();

                var records = responseData["data"]["table_records"]["edges"];
                foreach (var record in records)
                {
                    //Console.WriteLine(record);
                    allRecords.Add(record);
                }

                hasNextPage = responseData["data"]["table_records"]["pageInfo"]["hasNextPage"].Value<bool>();
                cursor = responseData["data"]["table_records"]["pageInfo"]["endCursor"].Value<string>();
                query = $"{{\"query\":\"query GetRecords($cursor: String){{    table_records(table_id: \\\"{PipefyTokenTableID}\\\",first:50,after:$cursor){{        pageInfo{{            hasNextPage            endCursor        }}        edges{{            node{{                record_fields{{                    field {{                        id                    }}                    value                    array_value                }}            }}        }}    }}}}\",\"variables\":{{\"cursor\":\"{cursor}\"}}}}";

            }
            else
            {
                Console.WriteLine($"Erro na solicitação GraphQL: {response.StatusCode}");
                allRecords.Clear();
                return allRecords;
            }
        }

        return allRecords;
    }

    static List<Pipefy.ClasseEmpresas> GetDataFromDatabase(string ConnSourcePath)
    {
        string connectionString = @"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" + ConnSourcePath;
        List<Pipefy.ClasseEmpresas> data = new List<Pipefy.ClasseEmpresas>();

        using (OleDbConnection connection = new OleDbConnection(connectionString))
        {
            connection.Open();

            // Execute uma consulta SQL para recuperar dados da tabela no banco de dados Access
            string sqlQuery = "SELECT * FROM tblEmpresas";
            using (OleDbCommand command = new OleDbCommand(sqlQuery, connection))
            {
                using (OleDbDataReader reader = command.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        Pipefy.ClasseEmpresas record = new Pipefy.ClasseEmpresas
                        {
                            c_digo_smart = (string)reader["Código Smart"].ToString(),
                            nome_da_empresa = (string)reader["Nome da empresa"],
                            modalidade = (string)reader["modalidade"],
                            gestores = (string)reader["gestores"],
                            rec_id = ""

                            // Adicione outras propriedades conforme necessário
                        };
                        data.Add(record);
                    }
                }
            }
        }

        return data;
    }
    static List<Pipefy.ClasseEmpresas> convertEmpresasJson(List<Pipefy.RootObject> jsonData)
    {
        List<Pipefy.ClasseEmpresas> data = new List<Pipefy.ClasseEmpresas>();

        for (int i = 0;i<jsonData.Count;i++)
        {
            Pipefy.ClasseEmpresas record = new Pipefy.ClasseEmpresas();
            record.rec_id = jsonData[i].node.id;

            for (int j = 0;j < jsonData[i].node.record_fields.Length;j++)
            {
                switch (jsonData[i].node.record_fields[j].field.id)
                {
                    case "nome_da_empresa":
                        record.nome_da_empresa = jsonData[i].node.record_fields[j].value;
                        break;
                    case "c_digo_smart":
                        record.c_digo_smart = jsonData[i].node.record_fields[j].value.Replace(".0","");
                        break;
                    case "modalidade":
                        record.modalidade = jsonData[i].node.record_fields[j].value;
                        break;
                    case "gestores":
                        record.gestores = jsonData[i].node.record_fields[j].array_value.FirstOrDefault().ToString();
                        break;

                }
            }

            // Adicione outras propriedades conforme necessário
            data.Add(record);
        }
        
        return data;
    }

    static List<Pipefy.ClasseGestores> convertGestoresJson(List<Pipefy.RootGestor> jsonData)
    {
        List<Pipefy.ClasseGestores> data = new List<Pipefy.ClasseGestores>();

        for (int i = 0; i < jsonData.Count; i++)
        {

            Pipefy.ClasseGestores record = new Pipefy.ClasseGestores();
            record.id = jsonData[i].node.id.ToString();

            for (int j = 0; j < jsonData[i].node.record_fields.Length; j++)
            {
                if (jsonData[i].node.record_fields[j].field.id == "gest_o")
                {
                        record.gestores = jsonData[i].node.record_fields[j].value;

                }
            }

            // Adicione outras propriedades conforme necessário
            data.Add(record);
        }

        return data;
    }

    static List<Pipefy.ClasseEmpresas> CompareData(List<Pipefy.ClasseEmpresas> databaseData, List<Pipefy.ClasseEmpresas> jsonList, List<Pipefy.ClasseGestores> jsonListGestores)
    {
        if (jsonList == null | jsonListGestores == null)
        {
            return databaseData;
        }

        List<Pipefy.ClasseEmpresas> recordsMissingInJson = new List<Pipefy.ClasseEmpresas>();
        var exists = false;

        foreach (var record in databaseData)
        {
            exists = false;

            for (var j = 0; j < jsonList.Count; j++) {

                //Console.WriteLine(jsonList[j].c_digo_smart.ToString().Replace(".0", "") + " - " + record.c_digo_smart.ToString() + " - " + (jsonList[j].c_digo_smart.ToString().Replace(".0", "") == record.c_digo_smart.ToString()));

                if (jsonList[j].c_digo_smart.ToString().Replace(".0", "") == record.c_digo_smart.ToString())
                {
                    exists = true;
                    break;
                }

            }
            
            Console.Clear();

            if (exists == false) {
                record.gestores = findGestores(record.gestores,jsonListGestores);
                
                if (record.gestores != "0")
                {
                    recordsMissingInJson.Add(record);
                }
                //else
                //{
                //    int test = 10;
                //}
            }
        }

        return recordsMissingInJson;
    }
    static string findGestores(string sCodigo, List<Pipefy.ClasseGestores> jsonListGestores)
    {
        for (var i = 0; i < jsonListGestores.Count; i++)
        {
            if (sCodigo == jsonListGestores[i].gestores.ToString())
            {
                return jsonListGestores[i].id;
            }
        }
        return "0";
    }
}