using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Newtonsoft.Json;

using Demo;  

public class Program
{
    private static readonly HttpClient client = new HttpClient();
    private static readonly SemaphoreSlim semaphore = new SemaphoreSlim(5); // Control concurrency
    private const int DataBatchSize = 3000; // Number of data items per batch
    private const int MaxRequestsPer5Seconds = 5; // Maximum requests per 5 seconds
    private static readonly TimeSpan RequestInterval = TimeSpan.FromSeconds(5); // Request interval
    private static string AccessToken = "YOUR_ACCESS_TOKEN_HERE"; // Replace with your actual AccessToken
    private const string ApiEndpoint = "YOUR_API_ENDPOINT_HERE"; // API endpoint URL

    public static async Task Main(string[] args)
    {
        // Sample data using the PowerGenerationData class
        var dataList = new List<PowerGenerationData>
        {
            new PowerGenerationData
            {
                RemoteInvId = "MY78222522114",
                Timestamp = "2023-07-01",
                PeriodProductionInKWh = "0.123",
                AccumulatedEnergyInKWh = "5.123"
            },
            new PowerGenerationData
            {
                RemoteInvId = "MY78222522115",
                Timestamp = "2023-07-02",
                PeriodProductionInKWh = "0.234",
                AccumulatedEnergyInKWh = "5.357"
            }
            // Continue adding data items
        };

        await ProcessAndSendDataInBatchesAsync(dataList);
    }

    private static async Task ProcessAndSendDataInBatchesAsync(List<PowerGenerationData> dataList)
    {
        // Calculate total number of data batches
        int totalDataBatches = (int)Math.Ceiling(dataList.Count / (double)DataBatchSize);

        // Process data in batches
        for (int batchIndex = 0; batchIndex < totalDataBatches; batchIndex++)
        {
            var batchData = dataList.Skip(batchIndex * DataBatchSize).Take(DataBatchSize).ToList();

            // Group data by RemoteInvId and map to DataItem
            var groupedDevices = batchData
                .GroupBy(item => item.RemoteInvId)
                .Select(g => new Device
                {
                    RemoteInvId = g.Key,
                    Data = g.Select(d => new DataItem
                    {
                        Timestamp = d.Timestamp,
                        PeriodProductionInKWh = d.PeriodProductionInKWh,
                        AccumulatedEnergyInKWh = d.AccumulatedEnergyInKWh
                    }).ToList()
                })
                .ToList();

            // Create request body
            var requestBody = new RequestBody { Devices = groupedDevices };
            var json = JsonConvert.SerializeObject(requestBody);

            // Control request rate
            await semaphore.WaitAsync();
            try
            {
                // Send request
                await PostDataAsync(json);

                // Wait to limit request frequency
                if ((batchIndex + 1) % MaxRequestsPer5Seconds == 0)
                {
                    await Task.Delay(RequestInterval);
                }
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
            finally
            {
                semaphore.Release();
            }
        }
    }

    private static async Task PostDataAsync(string jsonData)
    {
        var requestMessage = new HttpRequestMessage(HttpMethod.Post, ApiEndpoint)
        {
            Content = new StringContent(jsonData, Encoding.UTF8, "application/json")
        };

        // Add Authorization header
        requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", AccessToken);

        var response = await client.SendAsync(requestMessage);

        if (response.IsSuccessStatusCode)
        {
            Console.WriteLine("Data sent successfully.");
        }
        else
        {
            var responseContent = await response.Content.ReadAsStringAsync();
            Console.WriteLine($"Failed to send data: {responseContent}");
        }
    }
}

public class RequestBody
{
    [JsonProperty("Devices")]
    public List<Device> Devices { get; set; }
}

public class Device
{
    [JsonProperty("RemoteInvId")]
    public string RemoteInvId { get; set; }

    [JsonProperty("Data")]
    public List<DataItem> Data { get; set; }
}

public class DataItem
{
    [JsonProperty("Timestamp")]
    public string Timestamp { get; set; }

    [JsonProperty("PeriodProductionInKWh")]
    public string PeriodProductionInKWh { get; set; }

    [JsonProperty("AccumulatedEnergyInKWh")]
    public string AccumulatedEnergyInKWh { get; set; }
}

public class PowerGenerationData
{
    [JsonProperty("RemoteInvId")]
    public string RemoteInvId { get; set; }

    [JsonProperty("Timestamp")]
    public string Timestamp { get; set; }

    [JsonProperty("PeriodProductionInKWh")]
    public string PeriodProductionInKWh { get; set; }

    [JsonProperty("AccumulatedEnergyInKWh")]
    public string AccumulatedEnergyInKWh { get; set; }
}