Execute C# code.cs

using System;
using System.Text;
using System.Net.Http;
using System.Net.Http.Headers;
using Newtonsoft.Json;

public class CPHInline
{
    private class TCordSearch
    {
        public string lat { get; set; }
        public string lon { get; set; }
        public string name { get; set; }
        public string display_name { get; set; }
    }

    public class WeatherInfo
    {
        public double Latitude { get; set; }
        public double Longitude { get; set; }
        public double Generationtime_Ms { get; set; }
        public int Utc_Offset_Seconds { get; set; }
        public string Timezone { get; set; }
        public string Timezone_Abbreviation { get; set; }
        public double Elevation { get; set; }
        public CurrentWeatherUnits Current_Weather_Units { get; set; }
        public CurrentWeather Current_Weather { get; set; }
    }

    public class CurrentWeatherUnits
    {
        public string Time { get; set; }
        public string Interval { get; set; }
        public string Temperature { get; set; }
        public string Windspeed { get; set; }
        public string Winddirection { get; set; }
        public string Is_Day { get; set; }
        public string Weathercode { get; set; }
    }

    public class CurrentWeather
    {
        public string Time { get; set; }
        public int Interval { get; set; }
        public double Temperature { get; set; }
        public double Windspeed { get; set; }
        public int Winddirection { get; set; }
        public int Is_Day { get; set; }
        public int Weathercode { get; set; }
    }

    private static readonly HttpClient _httpClient = new HttpClient
    {
        Timeout = TimeSpan.FromSeconds(30)
    };
    
    private static readonly string geoSearch = "https://nominatim.openstreetmap.org/search?city={0}&format=json&limit=1";
    private static readonly string defaultURL = "https://api.open-meteo.com/v1/forecast?latitude={0}&longitude={1}&current_weather=true";
    private static string defaultCity;
    private static string defaultLat;
    private static string defaultLon;
    
    public void Init()
    {
        _httpClient.DefaultRequestHeaders.Clear();
        defaultCity = CPH.GetGlobalVar<string>("weather_default_city", true);
        defaultLat = CPH.GetGlobalVar<string>("weather_default_lat", true);
        defaultLon = CPH.GetGlobalVar<string>("weather_default_lon", true);
        LogInfo( string.Format( "Has been loaded with default city: {0}, default Lat: {1}, default Lon: {2}", defaultCity, defaultLat, defaultLon ) );
    }

    public void Dispose()
    {
        _httpClient.Dispose();
    }

    //Functions for logging - added as separate to automatically add name a tag for the command...
    private void LogInfo(String LogLine)
    {
        CPH.LogInfo("[Weather Command] " + LogLine);
    }

    private void LogError(String LogLine)
    {
        CPH.LogError("[Weather Command] " + LogLine);
    }

    // a function that will return the message to same source as the caller came from
    // currently only twitch and youtube implemented, if want other source add as else if() 
    private void SendMessage(string message)
    {
        CPH.TryGetArg("commandSource", out string commandSource);
        switch (commandSource)
        {
            case "twitch":
                CPH.SendMessage(message);
                break;
            case "youtube":
                CPH.SendYouTubeMessage(message);
                break;
            case "kick":
                CPH.SendKickMessage( message );
                break;
            default:
                LogError("Can't send a message - Source Not Implemented");
                break;
        }
    }

    //function that translates weather code into a description
    //taken from Open-Meteo docs...
    public static string GetWeatherDescription(int code)
    {
        return code switch
        {
            0 => "Clear sky",
            1 or 2 or 3 => "Mainly clear, partly cloudy, and overcast",
            45 or 48 => "Fog and depositing rime fog",
            51 or 53 or 55 => "Drizzle: Light, moderate, and dense intensity",
            56 or 57 => "Freezing Drizzle: Light and dense intensity",
            61 or 63 or 65 => "Rain: Slight, moderate and heavy intensity",
            66 or 67 => "Freezing Rain: Light and heavy intensity",
            71 or 73 or 75 => "Snow fall: Slight, moderate, and heavy intensity",
            77 => "Snow grains",
            80 or 81 or 82 => "Rain showers: Slight, moderate, and violent",
            85 or 86 => "Snow showers: Slight and heavy",
            95 => "Thunderstorm: Slight or moderate",
            96 or 99 => "Thunderstorm with slight and heavy hail",
            _ => "Unknown weather code"
        };
    }

    //generic Post request that expects to return a JSON object of type T ( provided by caller )
    public static T PostRequest<T>(string URL)
    {
        _httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("CSharpApp/1.0");
        string json = _httpClient.GetStringAsync(URL).GetAwaiter().GetResult();
        return JsonConvert.DeserializeObject<T>(json);
    }

	// check if we need to search for the city, if we dont have input city or the input city is same as default city - then apply latitude and longitude from defaults...
	// this will work even if you have setup defaultCity without setting up the coordinates...
    private static bool doSearch(ref string inputCity, out string lat, out string lon)
    {
        lat = null;
        lon = null;
        if (string.IsNullOrWhiteSpace(inputCity) || string.Equals( inputCity, defaultCity, StringComparison.OrdinalIgnoreCase ) )
        {
            lat = defaultLat;
            lon = defaultLon;
            inputCity = defaultCity;
        }

        return string.IsNullOrWhiteSpace(lat) || string.IsNullOrWhiteSpace(lon);
    }

    public bool Execute()
    {
        CPH.TryGetArg("messageStripped", out string rawInput);
        bool needsSearch = doSearch(ref rawInput, out string lat, out string lon);
        
        //logic check - cant search if we dont have a city...
        if (needsSearch && string.IsNullOrWhiteSpace(rawInput))
        {
            LogError("Can't search without provided city ( defaultCity not setup? )");
            return false;
        }

        if ( needsSearch )
        {
            try
            {
                LogInfo( string.Format( "Looking for coordinates of: " + rawInput ) );
                string geoSearchURL = string.Format( geoSearch, Uri.EscapeDataString( rawInput ) );
                var CordSearchResult = PostRequest<TCordSearch[]>( geoSearchURL );
                LogInfo( string.Format( "Number of found cordinate results: " ) + CordSearchResult?.Length );
                if ( CordSearchResult?.Length > 0 )
                {
                    ( lat, lon, rawInput ) = ( CordSearchResult[ 0 ].lat, CordSearchResult[ 0 ].lon, CordSearchResult[ 0 ].name);
                    LogInfo( string.Format( "location found: latitude:{0}, Longitude: {1} for city of {2}", lat, lon, rawInput ) );
                }
            }
            catch ( Exception ex )
            {
                LogError( "Error: " + ex.Message );
            }
        }

        //logic check - cant get weather without Lat/Lon...
        if ( string.IsNullOrWhiteSpace( lat ) || string.IsNullOrWhiteSpace( lon ) )
        {
            LogError( "Latitude/Longitude not found - unable to get weather!" );
            return false;
        }

        try
        {
            string URL = string.Format( defaultURL, lat, lon );
            var weather = PostRequest<WeatherInfo>( URL );
            var w = weather.Current_Weather;
            string message = $"Weather in {rawInput}: {w.Temperature}°C, Wind: {w.Windspeed} km/h, Direction: {w.Winddirection}°, Condition : {GetWeatherDescription(w.Weathercode)}";
            SendMessage( message );
        }
        catch (Exception ex)
        {
            LogError("Error: " + ex.Message);
        }

        return true;
    }
}