using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

// language: C#, file: apexauth.cs, target: .NET Framework 4.6+ / .NET Core / .NET 6/7/8/9
// Zero-dependency C# SDK for ApexAuth.

namespace ApexAuth
{
    public class ApexAuthApp : api
    {
        public ApexAuthApp(string name, string ownerid, string secret, string version, string url)
            : base(name, ownerid, secret, version, url) { }
    }

    public class api
    {
        public string name { get; set; }
        public string ownerid { get; set; }
        public string secret { get; set; }
        public string version { get; set; }
        public string url { get; set; }

        public user_data_class user_data = new user_data_class();
        public response_class response = new response_class();

        private readonly HttpClient client = new HttpClient();
        private string sessionToken = "";
        private string encKey = "";

        public class user_data_class
        {
            public string username { get; set; } = "";
            public string ip { get; set; } = "";
            public string hwid { get; set; } = "";
            public string createdate { get; set; } = "";
            public string lastlogin { get; set; } = "";
            public string expiry { get; set; } = "";
            public List<string> subscriptions { get; set; } = new List<string>();
        }

        public class response_class
        {
            public bool success { get; set; } = false;
            public string message { get; set; } = "";
        }

        public api(string name, string ownerid, string secret, string version, string url)
        {
            this.name = name;
            this.ownerid = ownerid;
            this.secret = secret;
            this.version = version;
            string u = url?.TrimEnd('/') ?? "";
            if (u.EndsWith("/api/v1", StringComparison.OrdinalIgnoreCase)) u = u.Substring(0, u.Length - 7);
            this.url = u;
            client.Timeout = TimeSpan.FromSeconds(15);
        }

        public static string GetHwid()
        {
            try
            {
                string raw = Environment.MachineName + "|" + Environment.ProcessorCount + "|" + Environment.UserName + "|" + Environment.OSVersion;
                using (var sha = SHA256.Create())
                {
                    byte[] bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(raw));
                    var sb = new StringBuilder();
                    foreach (byte b in bytes)
                    {
                        sb.Append(b.ToString("x2"));
                    }
                    return sb.ToString();
                }
            }
            catch
            {
                return "csharp-hwid-" + Environment.MachineName.ToLowerInvariant();
            }
        }

        private string CalculateHmacSha256(string payload, string key)
        {
            byte[] keyBytes = Encoding.UTF8.GetBytes(key);
            byte[] payloadBytes = Encoding.UTF8.GetBytes(payload);
            using (var hmac = new HMACSHA256(keyBytes))
            {
                byte[] hash = hmac.ComputeHash(payloadBytes);
                var sb = new StringBuilder();
                foreach (byte b in hash)
                {
                    sb.Append(b.ToString("x2"));
                }
                return sb.ToString();
            }
        }

        private string PostRaw(string endpoint, string jsonBody, bool bypassSign)
        {
            try
            {
                string fullUrl = url + endpoint;
                string timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
                string nonce = Guid.NewGuid().ToString("N").Substring(0, 16);

                var request = new HttpRequestMessage(HttpMethod.Post, fullUrl);
                request.Headers.Add("x-app-secret", secret);
                request.Headers.Add("x-owner-id", ownerid);
                request.Headers.Add("x-app-name", name);
                request.Headers.Add("x-timestamp", timestamp);
                request.Headers.Add("x-nonce", nonce);

                if (!bypassSign)
                {
                    string sign = CalculateHmacSha256(jsonBody + timestamp + nonce, secret);
                    request.Headers.Add("x-signature", sign);
                }

                if (!string.IsNullOrEmpty(jsonBody))
                {
                    request.Content = new StringContent(jsonBody, Encoding.UTF8, "application/json");
                }

                var res = client.SendAsync(request).GetAwaiter().GetResult();
                return res.Content.ReadAsStringAsync().GetAwaiter().GetResult();
            }
            catch (Exception ex)
            {
                response.success = false;
                response.message = "Network error: " + ex.Message;
                return "{\"success\":false,\"message\":\"" + ex.Message + "\"}";
            }
        }

        private string ExtractJsonString(string json, string key)
        {
            var match = Regex.Match(json, "\"" + Regex.Escape(key) + "\"\\s*:\\s*\"([^\"]*)\"");
            return match.Success ? match.Groups[1].Value : "";
        }

        private bool ExtractJsonBool(string json, string key)
        {
            var match = Regex.Match(json, "\"" + Regex.Escape(key) + "\"\\s*:\\s*(true|false)", RegexOptions.IgnoreCase);
            return match.Success && match.Groups[1].Value.Equals("true", StringComparison.OrdinalIgnoreCase);
        }

        private void ParseResponse(string raw)
        {
            response.success = ExtractJsonBool(raw, "success");
            response.message = ExtractJsonString(raw, "message");

            if (raw.Contains("\"session_token\"") || raw.Contains("\"sessionid\""))
            {
                string tok = ExtractJsonString(raw, "session_token");
                if (string.IsNullOrEmpty(tok)) tok = ExtractJsonString(raw, "sessionid");
                if (!string.IsNullOrEmpty(tok)) sessionToken = tok;
            }

            if (raw.Contains("\"encryption_key\""))
            {
                encKey = ExtractJsonString(raw, "encryption_key");
            }

            if (response.success && (raw.Contains("\"hwid\"") || raw.Contains("\"subscriptions\"")))
            {
                user_data.username = ExtractJsonString(raw, "username");
                user_data.ip = ExtractJsonString(raw, "ip");
                user_data.hwid = ExtractJsonString(raw, "hwid");
                user_data.createdate = ExtractJsonString(raw, "createdate");
                user_data.lastlogin = ExtractJsonString(raw, "lastlogin");
                user_data.expiry = ExtractJsonString(raw, "expires");

                user_data.subscriptions.Clear();
                var subMatches = Regex.Matches(raw, "\"subscription\"\\s*:\\s*\"([^\"]+)\"");
                foreach (Match m in subMatches)
                {
                    user_data.subscriptions.Add(m.Groups[1].Value);
                }
            }
        }

        // ==========================================
        // CORE AUTHENTICATION PUBLIC METHODS
        // ==========================================

        public void init()
        {
            string body = "{\"name\":\"" + name + "\",\"ownerid\":\"" + ownerid + "\",\"secret\":\"" + secret + "\",\"version\":\"" + version + "\"}";
            string res = PostRaw("/api/v1/init", body, true);
            ParseResponse(res);
        }

        public void register(string username, string pass, string key, string email = "")
        {
            string body = "{\"username\":\"" + username + "\",\"email\":\"" + email + "\",\"password\":\"" + pass + "\",\"license\":\"" + key + "\",\"hwid\":\"" + GetHwid() + "\"}";
            string res = PostRaw("/api/v1/register", body, false);
            ParseResponse(res);
        }

        public void login(string username, string pass)
        {
            string body = "{\"username\":\"" + username + "\",\"password\":\"" + pass + "\",\"hwid\":\"" + GetHwid() + "\"}";
            string res = PostRaw("/api/v1/login", body, false);
            ParseResponse(res);
        }

        public void license(string key)
        {
            string body = "{\"license\":\"" + key + "\",\"hwid\":\"" + GetHwid() + "\"}";
            string res = PostRaw("/api/v1/license", body, false);
            ParseResponse(res);
        }

        public void check()
        {
            string body = "{\"session_token\":\"" + sessionToken + "\",\"hwid\":\"" + GetHwid() + "\"}";
            string res = PostRaw("/api/v1/check", body, false);
            ParseResponse(res);
        }

        public string var(string varid)
        {
            string body = "{\"name\":\"" + varid + "\"}";
            string res = PostRaw("/api/v1/var", body, false);
            ParseResponse(res);
            return ExtractJsonString(res, "value");
        }

        public void log(string message)
        {
            string body = "{\"message\":\"" + message + "\"}";
            string res = PostRaw("/api/v1/log", body, false);
            ParseResponse(res);
        }

        public void ban(string reason = "")
        {
            string body = "{\"reason\":\"" + reason + "\",\"hwid\":\"" + GetHwid() + "\"}";
            string res = PostRaw("/api/v1/ban", body, false);
            ParseResponse(res);
        }

        public void upgrade(string username, string key)
        {
            string body = "{\"username\":\"" + username + "\",\"key\":\"" + key + "\"}";
            string res = PostRaw("/api/v1/upgrade", body, false);
            ParseResponse(res);
        }

        public byte[] download(int fileid)
        {
            string body = "{\"file_id\":" + fileid + "}";
            string res = PostRaw("/api/v1/file", body, false);
            ParseResponse(res);

            string fileUrl = ExtractJsonString(res, "download_url");
            if (string.IsNullOrEmpty(fileUrl)) return new byte[0];

            if (!fileUrl.StartsWith("http", StringComparison.OrdinalIgnoreCase))
            {
                fileUrl = url + "/" + fileUrl.TrimStart('/');
            }

            try
            {
                return client.GetByteArrayAsync(fileUrl).GetAwaiter().GetResult();
            }
            catch
            {
                return new byte[0];
            }
        }
    }
}