AiQ_GUI/MobileTests/MobileAPI.cs

using AiQ_GUI;
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

namespace AiQ_GUI.Mobile_Tests
{
    public static class MobileAPI
    {
        // Login credentials
        private const string DefaultUsername = "ADMIN";
        private const string DefaultPassword = "1234";

        public static async Task CheckFirmwareAsync()
        {
            using HttpClient client = new HttpClient
            {
                BaseAddress = new Uri($"http://{MainForm.Instance.CamOnTest.IP}")
            };

            try
            {
                // Login and get JWT token
                string token = await LoginAsync(client, DefaultUsername, DefaultPassword);

                // Attach JWT to all requests
                client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);

                // Request firmware information
                HttpResponseMessage response = await client.GetAsync("/app/v1/system/firmware");

                string body = await response.Content.ReadAsStringAsync();

                response.EnsureSuccessStatusCode();

                JsonElement json = JsonSerializer.Deserialize<JsonElement>(body);

                string version = json.GetProperty("version").GetString()?.Trim();

                // Compare against expected SRZFirmware from UniversalData
                if (string.IsNullOrEmpty(UniversalData.SRZFirmware))
                {
                    MainForm.Instance.AddToActionsList($"Firmware check failed: Expected SRZFirmware not loaded in UniversalData", Level.ERROR);
                    MainForm.Instance.AddLabelToPanel($"Firmware = {version}", true);
                }
                else if (version == UniversalData.SRZFirmware)
                {
                    MainForm.Instance.AddLabelToPanel($"Firmware = {version}", false);
                }
                else
                {
                    MainForm.Instance.AddLabelToPanel($"Firmware = {version}", true);
                }
            }
            catch (Exception ex)
            {
                MainForm.Instance.AddToActionsList($"Firmware check failed: {ex.Message}", Level.ERROR);
                MainForm.Instance.AddLabelToPanel("Firmware = Unknown", true);
            }
        }

        public static async Task ChangeDayNightModeAsync(uint mode)
        {
            // mode: 0 = Auto, 1 = Day, 2 = Night
            string modeName = mode switch
            {
                0 => "Auto",
                1 => "Day",
                2 => "Night",
                _ => "Unknown"
            };

            // operatingMode required by firmware (!)
            // day -> 1, night -> 0
            int operatingMode = mode switch
            {
                1 => 1, // Day
                2 => 0, // Night
                _ => 1  // Auto: keep day as safe default
            };

            using HttpClient client = new HttpClient
            {
                BaseAddress = new Uri($"http://{MainForm.Instance.CamOnTest.IP}")
            };

            try
            {
                // Login
                string token = await LoginAsync(client, DefaultUsername, DefaultPassword);
                client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);

                var payload = new
                {
                    dayNightMode = new
                    {
                        mode = mode,
                        dayToNightSens = 4,
                        nightToDaySens = 24,
                        transitionDelay = 20,
                        operatingMode = operatingMode
                    }
                };

                HttpResponseMessage response = await client.PostAsJsonAsync("/app/v1/camera/image", payload);

                if (response.IsSuccessStatusCode)
                {
                    MainForm.Instance.AddToActionsList($"Camera set to {modeName} mode successfully",Level.Success);
                }
                else
                {
                    string error = await response.Content.ReadAsStringAsync();
                    MainForm.Instance.AddToActionsList($"Failed to set {modeName} mode: {response.StatusCode} - {error}",Level.ERROR);
                }
            }
            catch (Exception ex)
            {
                MainForm.Instance.AddToActionsList($"Error changing to {modeName} mode: {ex.Message}",Level.ERROR);
            }
        }


        public static async Task SetDayModeAsync()
        {
            await ChangeDayNightModeAsync(1);
        }

        public static async Task SetNightModeAsync()
        {
            await ChangeDayNightModeAsync(2);
        }

        public static async Task SetAutoModeAsync()
        {
            await ChangeDayNightModeAsync(0);
        }

        private static async Task<string> LoginAsync(HttpClient client, string user, string password)
        {
            var payload = new
            {
                userId = user,
                userPassword = Sha256(password)
            };

            HttpResponseMessage response = await client.PostAsJsonAsync("/app/v1/login", payload);

            response.EnsureSuccessStatusCode();

            JsonElement json = await response.Content.ReadFromJsonAsync<JsonElement>();

            return json.GetProperty("token").GetString();
        }

        private static string Sha256(string input)
        {
            using SHA256 sha = SHA256.Create();
            byte[] bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(input));
            return BitConverter.ToString(bytes).Replace("-", "").ToLower();
        }
    }
}