M3UFromXtream.cs

using Newtonsoft.Json;
using System.Text.RegularExpressions;

namespace M3UFromXtream
{
    internal class M3UFromXtream
    {
        private static readonly HttpClient httpClient = new HttpClient();

        static M3UFromXtream()
        {
            httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("Mozilla/5.0");
        }
        private static string? version = string.Empty;

        static async Task Main(string[] args)
        {
            version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version?.ToString() ?? string.Empty;

            Console.WriteLine($"M3UFromXtream Version {version}");
            Console.WriteLine("");

            if (args.Length < 3 || args.Length > 4)
            {
                Console.WriteLine("Usage: M3UFromXtream <url> <username> <password> [output-file]");
                Console.WriteLine("Example: M3UFromXtream http://example.com:8080 user pass output.m3u");
                return;
            }

            string baseUrl = args[0];
            string username = args[1];
            string password = args[2];
            string outputFile = args.Length > 3 ? args[3] : "playlist.m3u";

            httpClient.Timeout = TimeSpan.FromSeconds(10);

            try
            {
                Console.WriteLine("Connecting to Xtream Code API...");
                await GenerateM3UFromXtream(baseUrl, username, password, outputFile).ConfigureAwait(false);
                Console.WriteLine($"M3U playlist successfully created: {outputFile}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
            }
        }

        /// <summary>
        /// Generates an M3U playlist file from Xtream API data.
        /// </summary>
        /// <remarks>This method retrieves categories and streams from the Xtream API and writes them to
        /// an M3U file. The generated file includes metadata such as the generation date and version
        /// information.</remarks>
        /// <param name="baseUrl">The base URL of the Xtream API. Must not end with a slash.</param>
        /// <param name="username">The username for Xtream API authentication.</param>
        /// <param name="password">The password for Xtream API authentication.</param>
        /// <param name="outputFile">The path to the output file where the M3U playlist will be saved.</param>
        /// <returns></returns>
        static async Task GenerateM3UFromXtream(string baseUrl, string username, string password, string outputFile)
        {
            baseUrl = baseUrl.TrimEnd('/');

            var categories = await GetCategories(baseUrl, username, password).ConfigureAwait(false);
            Console.WriteLine($"Found {categories.Count} categories");

            using var writer = new StreamWriter(outputFile);
            writer.WriteLine("#EXTM3U");
            writer.WriteLine($"# Generated by M3UFromXtream Version: {version}");
            writer.WriteLine($"# Generated on: {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
            writer.WriteLine();

            int channelCount = 0;

            foreach (var category in categories)
            {
                Console.WriteLine($"Processing category: {category.CategoryName}");

                bool success = false;
                int failCounter = 0;
                List<Stream> streams = new List<Stream>();
                while (!success && failCounter < 3)
                {
                    try
                    {
                        streams = await GetStreams(baseUrl, username, password, category.CategoryId).ConfigureAwait(false);
                        success = true;
                    }
                    catch(Exception ex)
                    {
                        failCounter++;
                        Console.WriteLine($"{failCounter} Error retrieving streams for category {category.CategoryName}: {ex.Message}");
                        //  continue;
                    }
                }

                if(success is false)
                {
                    Console.WriteLine($"Failed to retrieve streams for category {category.CategoryName} after 3 attempts. Aborting.");
                    continue;
                }

                foreach (var stream in streams)
                {
                    if (string.IsNullOrEmpty(stream.Name) || string.IsNullOrEmpty(stream.StreamType))
                        continue;

                    string streamUrl = $"{baseUrl}/{username}/{password}/{stream.StreamId}";

                    writer.WriteLine(
                        $"#EXTINF:-1 tvg-id=\"{(stream.EpgChannelId ?? "").Replace("\r", "").Replace("\n", "")}\" " +
                        $"tvg-name=\"{EscapeM3UField(stream.Name).Replace("\r", "").Replace("\n", "")}\" " +
                        $"tvg-logo=\"{(stream.StreamIcon ?? "").Replace("\r", "").Replace("\n", "")}\" " +
                        $"group-title=\"{EscapeM3UField(category.CategoryName).Replace("\r", "").Replace("\n", "")}\"," +
                        $"{EscapeM3UField(stream.Name).Replace("\r", "").Replace("\n", "")}"
                    );
                    writer.WriteLine(streamUrl);
                    writer.WriteLine();

                    channelCount++;
                }
            }

            Console.WriteLine($"Total channels processed: {channelCount}");
        }

        /// <summary>
        /// Retrieves a list of live categories from the specified server.
        /// </summary>
        /// <remarks>This method sends an HTTP GET request to the server using the provided credentials to
        /// retrieve live categories. Ensure that the <paramref name="baseUrl"/>, <paramref name="username"/>, and
        /// <paramref name="password"/> are valid and correctly formatted.</remarks>
        /// <param name="baseUrl">The base URL of the server to connect to.</param>
        /// <param name="username">The username for authentication.</param>
        /// <param name="password">The password for authentication.</param>
        /// <returns>A task representing the asynchronous operation. The task result contains a list of <see cref="Category"/>
        /// objects representing the live categories. Returns an empty list if no categories are found.</returns>
        static async Task<List<Category>> GetCategories(string baseUrl, string username, string password)
        {
            string url = $"{baseUrl}/player_api.php?username={username}&password={password}&action=get_live_categories";

            using var httpResponse = await httpClient.GetAsync(url).ConfigureAwait(false);
            string response = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
            if (!httpResponse.IsSuccessStatusCode)
                throw new HttpRequestException($"Server returned {(int)httpResponse.StatusCode}: {response}");
            //using (StreamWriter file = File.CreateText(@"C:\testdata\XcCategpries.json"))
            //{
            //    file.Write(JsonPrettify(response));
            //}

            var categories = JsonConvert.DeserializeObject<List<Category>>(response);

            return categories ?? new List<Category>();
        }

        /// <summary>
        /// Retrieves a list of live streams for a specified category from the server.
        /// </summary>
        /// <param name="baseUrl">The base URL of the server to connect to.</param>
        /// <param name="username">The username for authentication.</param>
        /// <param name="password">The password for authentication.</param>
        /// <param name="categoryId">The identifier of the category for which to retrieve streams.</param>
        /// <returns>A task representing the asynchronous operation. The task result contains a list of <see cref="Stream"/>
        /// objects representing the live streams in the specified category. Returns an empty list if no streams are
        /// found.</returns>
        static async Task<List<Stream>> GetStreams(string baseUrl, string username, string password, string categoryId)
        {
            string url = $"{baseUrl}/player_api.php?username={username}&password={password}&action=get_live_streams&category_id={categoryId}";

            using var httpResponse = await httpClient.GetAsync(url).ConfigureAwait(false);
            var response = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
            if (!httpResponse.IsSuccessStatusCode)
                throw new HttpRequestException($"Server returned {(int)httpResponse.StatusCode}: {response}");

            //using (StreamWriter file = File.CreateText(@$"C:\testdata\XcStreams_{categoryId}.json"))
            //{
            //    file.Write(JsonPrettify(response));
            //}

            var streams = JsonConvert.DeserializeObject<List<Stream>>(response);

            return streams ?? new List<Stream>();
        }

        /// <summary>
        /// Escapes special characters in an M3U field to ensure proper formatting.
        /// </summary>
        /// <remarks>This method replaces double quotes, commas, and colons with their escaped
        /// counterparts to prevent misinterpretation in M3U playlists.</remarks>
        /// <param name="field">The M3U field string to be escaped. Cannot be null.</param>
        /// <returns>A new string with special characters escaped. Returns an empty string if the input is null or empty.</returns>
        static string EscapeM3UField(string field)
        {
            if (string.IsNullOrEmpty(field))
                return string.Empty;

            // Escape special characters in M3U fields
            return field.Replace("\"", "\\\"")
                        .Replace(",", "\\,")
                        .Replace(":", "\\:");
        }

        /// <summary>
        /// Indents and adds line breaks to make JSON pretty for printing/viewing.
        /// </summary>
        /// <param name="json">Raw JSON string</param>
        /// <returns>Formatted JSON string</returns>
        public static string JsonPrettify(string json)
        {
            var obj = JsonConvert.DeserializeObject(json);
            return JsonConvert.SerializeObject(obj, Formatting.Indented);
        }
    }
}