using System.Globalization;
using System.Text;
using Newtonsoft.Json;

namespace ShellyExporter
{
    public class Metrics
    {
        public enum Type
        {
            PlugS = 1,
            Em3 = 2
        }

        public enum Version
        {
            Gen1 = 1,
            Gen2 = 2
        }
        public class Data
        {
            public string? Power { get; set; }
            public string? Overpower { get; set; }
            public bool? IsValid { get; set; }
            public string? Timestamp { get; set; }
            public string? Total { get; set; }
            public string? Temperature { get; set; }
            public string? Voltage { get; set; }
            public string? Current { get; set; }
        }
        
        public static async Task<StringBuilder> Get(string path, string name, Version shellyVersion, Type type)
        {
            var sb = new StringBuilder();

            Data data;
            switch (type)
            {
                case Type.PlugS:
                    switch (shellyVersion)
                    {
                        case Version.Gen1:
                            data = await GetPlugSGen1(path);
                            break;
                        case Version.Gen2:
                            data = await GetPlugSGen2(path);
                            break;
                        default:
                            throw new ArgumentOutOfRangeException(nameof(shellyVersion), shellyVersion, null);
                    }
                    break;
                //TODO 
                // case Type.Em3:
                //     switch (shellyVersion)
                //     {
                //         case Version.Gen1:
                //             data = await GetPlugSGen1(path);
                //             break;
                //         case Version.Gen2:
                //             data = await GetPlugSGen1(path);
                //             break;
                //         default:
                //             throw new ArgumentOutOfRangeException();
                //     }
                //     break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(type), type, null);
            }

            
            if (data.Power != null)
                sb.AppendLine($"meters_power_wats{{item=\"{name}\"}} {data.Power}");
            if (data.Overpower != null)
                sb.AppendLine($"meters_overpower_wats{{item=\"{name}\"}} " + data.Overpower);
            if (data.IsValid != null)
                sb.AppendLine($"meters_is_valid{{item=\"{name}\"}} " + ((bool)data.IsValid ? 1 : 0));
            if (data.Timestamp != null)
                sb.AppendLine($"meters_timestamp{{item=\"{name}\"}} " + data.Timestamp);
            if (data.Total != null)
             sb.AppendLine($"meters_power_total{{item=\"{name}\"}} " + data.Total);
            if (data.Voltage != null)
                sb.AppendLine($"meters_voltage_V{{item=\"{name}\"}} " + data.Voltage);
            if (data.Current != null)
                sb.AppendLine($"meters_current_A{{item=\"{name}\"}} " + data.Current);
            if (data.Temperature != null)
                sb.AppendLine($"temperature{{item=\"{name}\"}} " + data.Temperature);

            return sb;
        }

        private static async Task<Data> GetPlugSGen1(string path)
        {
            var data = new Data();
            var client = new HttpClient();
            var response = await client.GetStringAsync(path + "/status");

            dynamic responseObject = JsonConvert.DeserializeObject(response);

            if (responseObject == null)
                return data;

            if (responseObject.meters != null)
            {
                data.Power = responseObject.meters[0].power;
                data.Overpower = responseObject.meters[0].overpower;
                data.IsValid = responseObject.meters[0].is_valid;
                data.Timestamp = responseObject.meters[0].timestamp;
                data.Total = responseObject.meters[0].total;
            }

            if (responseObject.tmp.tC != null)
            {
                data.Temperature = responseObject.tmp.tC;
            }

            return data;
        }
        
        private static async Task<Data> GetPlugSGen2(string path)
        {
            var data = new Data();
            var client = new HttpClient();
            var response = await client.GetStringAsync(path + "/rpc/Switch.GetStatus?id=0");

            dynamic responseObject = JsonConvert.DeserializeObject(response);

            if (responseObject == null)
                return data;
            
            if (responseObject.apower != null)
                data.Power = responseObject.apower;
            
            if (responseObject.current != null)
                data.Current = responseObject.current;
            
            if (responseObject.voltage != null)
                data.Voltage = responseObject.voltage;
            
            if (responseObject.aenergy != null)
            {
                if (responseObject.aenergy.total != null)
                    data.Total = (Convert.ToDecimal(responseObject.aenergy.total) * (decimal)60).ToString(CultureInfo.InvariantCulture);
                
                if (responseObject.aenergy.minute_ts != null)
                    data.Timestamp = responseObject.aenergy.minute_ts;
            }

            if (responseObject.temperature != null
                && responseObject.temperature.tC != null)
                data.Temperature = responseObject.temperature.tC;

            return data;
        }
    }
}