Extensions.cs

using System.ComponentModel;
using System;
using System.Net;
using System.Net.Sockets;
using System.Runtime.CompilerServices;
using System.Text;
using Grayjay.ClientServer.Models;
using Grayjay.ClientServer.Pooling;
using Grayjay.Engine;
using Grayjay.Engine.Pagers;
using Grayjay.ClientServer.Proxy;
using Grayjay.Engine.Models.Video.Additions;

namespace Grayjay.ClientServer
{
    public static class Extensions
    {
        public static GrayjayPlugin FromPool(this GrayjayPlugin client, PlatformMultiClientPool pool)
            => pool.GetClientPooled(client);


        public static PagerResult<T> AsPagerResult<T>(this IPager<T> pager)
        {
            var results = pager.GetResults();
            var hasMore = pager.HasMorePages();
            return new PagerResult<T>()
            {
                PagerID = pager.ID,
                Results = results,
                HasMore = hasMore
            };
        }
        public static PagerResult<R> AsPagerResult<T, R>(this IPager<T> pager, Func<T, bool> filter, Func<T, R> modifier)
        {
            var results = pager.GetResults().Where(filter).Select(modifier).ToArray();
            var hasMore = pager.HasMorePages();
            return new PagerResult<R>()
            {
                PagerID = pager.ID,
                Results = results,
                HasMore = hasMore
            };
        }
        public static PagerResult<R> AsPagerResult<T, R>(this IPager<T> pager, Func<T, R> modifier)
        {
            var results = pager.GetResults().Select(modifier).ToArray();
            var hasMore = pager.HasMorePages();
            return new PagerResult<R>()
            {
                PagerID = pager.ID,
                Results = results,
                HasMore = hasMore
            };
        }

        public static byte[] DecodeBase64(this string base64)
        {
            if (base64.Length == 0)
                return new byte[0];
            int padding = 4 - (base64.Length % 4);
            if (padding < 4)
                base64 += new string('=', padding);
            return Convert.FromBase64String(base64);
        }

        public static byte[] DecodeBase64Url(this string base64)
        {
            if (base64.Length == 0)
                return new byte[0];
            base64 = base64.Replace('-', '+').Replace('_', '/');
            int padding = 4 - (base64.Length % 4);
            if (padding < 4)
                base64 += new string('=', padding);
            return Convert.FromBase64String(base64);
        }

        public static string EncodeBase64(this byte[] bytes)
        {
            return Convert.ToBase64String(bytes);
        }

        public static string EncodeBase64NoPadding(this byte[] bytes)
        {
            return Convert.ToBase64String(bytes).Replace("=", "");
        }

        public static string EncodeBase64Url(this byte[] bytes)
        {
            string base64 = Convert.ToBase64String(bytes);
            base64 = base64.Replace('+', '-').Replace('/', '_');
            return base64.TrimEnd('=');
        }

        public static TimeSpan NowDiff(this DateTime current)
        {
            return DateTime.Now.Subtract(current);
        }

        public static async Task SkipAsync(this Stream stream, int size, CancellationToken cancellationToken)
        {
            byte[] buffer = new byte[8192];
            int remaining = size;

            while (remaining > 0)
            {
                int toRead = Math.Min(buffer.Length, remaining);
                int read = await stream.ReadAsync(buffer, 0, toRead, cancellationToken);
                if (read == 0)
                {
                    throw new EndOfStreamException("End of stream reached before skip could be completed.");
                }
                remaining -= read;
            }
        }


        private const long CountInGbit = 1_000_000_000;
        private const long CountInMbit = 1_000_000;
        private const long CountInKbit = 1_000;

        public static string ToHumanBitrate(this int value) => ((long)value).ToHumanBitrate();
        public static string ToHumanBitrate(this long value)
        {
            long v = Math.Abs(value);
            if (v >= CountInGbit)
                return $"{value / CountInGbit}gbps";
            else if (v >= CountInMbit)
                return $"{value / CountInMbit}mbps";
            else if (v >= CountInKbit)
                return $"{value / CountInKbit}kbps";

            return $"{value}bps";
        }

        private static readonly string DecimalFormat = "0.00";

        public static string ToHumanBytesSpeed(this int value) => ((long)value).ToHumanBytesSpeed();
        public static string ToHumanBytesSpeed(this long value)
        {
            long v = Math.Abs(value);
            string formattedValue = value.ToString();
            if (v >= CountInGbit)
                formattedValue = $"{(value / (double)CountInGbit).ToString(DecimalFormat)}GB/s";
            else if (v >= CountInMbit)
                formattedValue = $"{(value / (double)CountInMbit).ToString(DecimalFormat)}MB/s";
            else if (v >= CountInKbit)
                formattedValue = $"{(value / (double)CountInKbit).ToString(DecimalFormat)}KB/s";

            return formattedValue;
        }

        public static string ToHumanBytesSize(this int value, bool withDecimal = true) => ((long)value).ToHumanBytesSize(withDecimal);
        public static string ToHumanBytesSize(this long value, bool withDecimal = true)
        {
            long v = Math.Abs(value);
            string formattedValue = value.ToString();

            if (withDecimal)
            {
                if (v >= CountInGbit)
                    formattedValue = $"{(value / (double)CountInGbit).ToString(DecimalFormat)}GB";
                else if (v >= CountInMbit)
                    formattedValue = $"{(value / (double)CountInMbit).ToString(DecimalFormat)}MB";
                else if (v >= CountInKbit)
                    formattedValue = $"{(value / (double)CountInKbit).ToString(DecimalFormat)}KB";
            }
            else
            {
                if (v >= CountInGbit)
                    formattedValue = $"{(value / (double)CountInGbit).ToString("0")}GB";
                else if (v >= CountInMbit)
                    formattedValue = $"{(value / (double)CountInMbit).ToString("0")}MB";
                else if (v >= CountInKbit)
                    formattedValue = $"{(value / (double)CountInKbit).ToString("0")}KB";
            }

            return formattedValue;
        }


        public static long DifferenceNowMinutes(this DateTime date)
        {
            return (long)DateTime.Now.Subtract(date).TotalMinutes;
        }
        public static long DifferenceNowSeconds(this DateTime date)
        {
            return (long)DateTime.Now.Subtract(date).TotalSeconds;
        }



        const string _allowedFileNameCharacters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz-.";
        public static string SanitizeFileName(this string fileName)
        {
            foreach(char invalidChar in fileName.Distinct().Where(x=>!_allowedFileNameCharacters.Contains(x)))
                fileName = fileName.Replace(invalidChar, '_');
            return fileName;
        }

        // Windows MAX_PATH is 260; reserve some room for the directory prefix.
        private const int MaxFileNameLength = 200;
        /// <summary>
        /// Truncates a file name (after sanitization) so that the base name fits within
        /// <see cref="MaxFileNameLength"/> characters, preserving the extension.
        /// </summary>
        public static string TruncateFileName(this string fileName)
        {
            if (fileName.Length <= MaxFileNameLength)
                return fileName;

            string ext = Path.GetExtension(fileName);   // e.g. ".mp4"
            string baseName = Path.GetFileNameWithoutExtension(fileName);
            int allowedBase = MaxFileNameLength - ext.Length;
            if (allowedBase < 1) allowedBase = 1;
            return baseName.Substring(0, Math.Min(baseName.Length, allowedBase)) + ext;
        }
        public static string SanitizeFileNameWithPath(this string path)
        {
            string dirName = Path.GetDirectoryName(path);
            string fileName = Path.GetFileName(path);

            foreach (char invalidChar in fileName.Distinct().Where(x => !_allowedFileNameCharacters.Contains(x)))
                fileName = fileName.Replace(invalidChar, '_');
            return Path.Combine(dirName, fileName);
        }

        public static string ToUrlAddress(this IPAddress address)
        {
            if (address.AddressFamily == AddressFamily.InterNetwork)
                return address.ToString();
            else if (address.AddressFamily == AddressFamily.InterNetworkV6)
            {
                if (address.IsIPv4MappedToIPv6)
                    return address.MapToIPv4().ToString();
                else
                {
                    string hostAddr = address.ToString();
                    int index = hostAddr.IndexOf('%');
                    if (index != -1)
                    {
                        string addrPart = hostAddr.Substring(0, index);
                        string scopeId = hostAddr.Substring(index + 1);
                        return $"[{addrPart}%25{scopeId}]";
                    }
                    else
                        return $"[{hostAddr}]";
                }
            }
            else
                throw new ArgumentException("Invalid address type", nameof(address));
        }

        public static string EnsureAbsoluteUrl(this string path, Uri baseUri)
        {
            Uri? resultUri;

            if (Uri.TryCreate(path, UriKind.Absolute, out resultUri))
            {
                if ((resultUri.Scheme == Uri.UriSchemeHttp) || (resultUri.Scheme == Uri.UriSchemeHttps))
                    return path;
            }

            resultUri = new Uri(baseUri, path);
            return resultUri.ToString();
        }

        public static string EnsureAbsoluteUrl(this string path, string baseUrl)
        {
            Uri baseUri = new Uri(baseUrl);
            return path.EnsureAbsoluteUrl(baseUri);
        }

        public static string Capitalize(this string value)
        {
            if (string.IsNullOrEmpty(value))
                return value;
            return char.ToUpper(value[0]) + value.Substring(1);
        }


        /*
        public static bool MatchesDomain(this string domain, string queryDomain)
        {
            if (queryDomain.StartsWith("."))
                return domain.EndsWith(queryDomain) || domain == queryDomain.TrimStart('.');
            else
                return domain == queryDomain;
        }*/


        public static Func<string, HttpProxyRequest, (string, HttpProxyRequest)> ToProxyFunc(this IRequestModifier mod)
        {
            return (url, req) =>
            {
                var headers = req.Headers;

                var modReq = mod.ModifyRequest(url, headers);

                /*
                foreach(var header in modReq.Headers)
                {
                    var key = req.Headers.Keys.FirstOrDefault(x => x.Equals(header.Key, StringComparison.OrdinalIgnoreCase));
                    if (key != null)
                        req.Headers[key] = header.Value;
                    else
                        req.Headers.Add(header.Key, header.Value);
                }*/
                if(modReq.Headers != null)
                    req.Headers = new Dictionary<string, string>(modReq.Headers, StringComparer.OrdinalIgnoreCase);

                if (string.IsNullOrEmpty(modReq.Url))
                    modReq.Url = url;
                return (modReq.Url, req);
            };
        }
        public static Func<HttpProxyRequest, HttpProxyResponse> ToProxyFunc(this RequestExecutor exe)
        {
            throw new NotImplementedException();
        }






        public static string VideoContainerToExtension(this string container) {
            if (container.Contains("video/mp4") || container == "application/vnd.apple.mpegurl")
                return "mp4";
            else if (container.Contains("application/x-mpegURL"))
                return "m3u8";
            else if (container.Contains("video/3gpp"))
                return "3gp";
            else if (container.Contains("video/quicktime"))
                return "mov";
            else if (container.Contains("video/webm"))
                return "webm";
            else if (container.Contains("video/x-matroska"))
                return "mkv";
            else
                //throw new InvalidDataException("Could not determine container type for audio (" + container + ")");
            //else
                return "video";
        }

        public static string AudioContainerToExtension(this string container)
        {
            if (container.Contains("audio/mp4"))
                return "mp4a";
            else if (container.Contains("audio/mpeg"))
                return "mpga";
            else if (container.Contains("audio/mp3"))
                return "mp3";
            else if (container.Contains("audio/webm"))
                return "webm";
            else if (container == "application/vnd.apple.mpegurl")
                return "mp4";
            else
                //throw new InvalidDataException("Could not determine container type for audio (" + container + ")");
            //else
                return "audio";
        }
    }
}