GPALRequest.cs

// =============================================================================
// GPAL - Generally Positive Automation Library
// Copyright © 2026 Software Decisions, Inc. All rights reserved.
//
// This file is part of GPAL.
// Licensed under the Business Source License 1.1
//
// Primary development, architecture, and vision by Michael B. Vederman,
// CEO of Software Decisions, Inc., Texas.
//
// Internal development maintained privately.
// Public releases appear on GitHub: https://github.com/SoftwareDecisionsInc/GPAL.
//
// See LICENSE for full terms, including Additional Use Grant.
// =============================================================================
 
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
 
namespace GenerallyPositive
{
    public class GPALCall
    {
        public string Url { get; set; }
        public string Method { get; set; }
        public string ResourceType { get; set; }
        public string PostData { get; set; }
        public string Initiator { get; set; }
        public int Status { get; set; }
        internal string RequestId { get; set; }
        public Dictionary<string, string> Headers { get; set; } = new Dictionary<string, string>();
    }

    public class GPALRequest : IAllowRequestSettings
    {
        public string Path { get; internal set; }

        public string Method { get; internal set; } = "GET";

        public string Body { get; internal set; }

        public string ContentType { get; internal set; } = "application/json";

        public List<KeyValuePair<string, string>> Parameters { get; internal set; } = new List<KeyValuePair<string, string>>();

        public List<KeyValuePair<string, string>> Headers { get; internal set; } = new List<KeyValuePair<string, string>>();

        public int FirstPage { get; internal set; }

        public string PageToken { get; internal set; } = "{page}";

        public Browser.Browser.CallAfterFetchDelegate AfterFetch { get; internal set; }

        public string Name { get; internal set; }
 
        internal GPALRequest()
        {
        }

        public GPALRequest ToGPALObject()
        {
            return this;
        }

        public IAllowRequestSettings WithPath(string path)
        {
            Path = path;
            return this;
        }

        public IAllowRequestSettings WithHttpMethod(Enums.HttpVerb method)
        {
            Method = method;
            return this;
        }

        public IAllowRequestSettings WithParameter(string nameValue)
        {
            Parameters.Add(SplitPair(nameValue, '='));
            return this;
        }

        public IAllowRequestSettings WithTokenFor(string parameterName)
        {
            // the next number, counted from what is already tokenized, so calls stack without being told an index
            int token = 0;
 
            while (true == Path?.Contains($"{{{token}}}") || true == Body?.Contains($"{{{token}}}"))
                token++;
 
            // a value lives in one of two places and a workflow should not have to care which. in a url it is
            // name=value up to the next &, in a json body it is "name":"value" or "name":value
            string inUrl = $"([?&]{Regex.Escape(parameterName)}=)[^&]*";
            string inJson = "(\"" + Regex.Escape(parameterName) + "\"\\s*:\\s*)(\"[^\"]*\"|[^,}\\s]+)";
 
            if (false == string.IsNullOrEmpty(Path))
                Path = Regex.Replace(Path, inUrl, "${1}" + $"{{{token}}}");
 
            if (false == string.IsNullOrEmpty(Body))
            {
                Body = Regex.Replace(Body, inUrl, "${1}" + $"{{{token}}}");
                Body = Regex.Replace(Body, inJson, "${1}" + $"\"{{{token}}}\"");
            }
 
            return this;
        }

        public IAllowRequestSettings WithHeader(string nameValue)
        {
            Headers.Add(SplitPair(nameValue, ':'));
            return this;
        }

        public IAllowRequestSettings WithBody(string body)
        {
            Body = body;
            return this;
        }

        public IAllowRequestSettings WithContentType(Enums.ContentType contentType)
        {
            ContentType = contentType;
            return this;
        }

        public IAllowRequestSettings WithFirstPage(int firstPage)
        {
            FirstPage = firstPage;
            return this;
        }

        public IAllowRequestSettings WithPageToken(string token = "{page}")
        {
            PageToken = token;
            return this;
        }

        public IAllowRequestSettings CallAfterFetch(Browser.Browser.CallAfterFetchDelegate callAfterFetch)
        {
            AfterFetch = callAfterFetch;
            return this;
        }

        public IAllowToGPALObject<GPALRequest> WithName(string name)
        {
            Name = name;
            return this;
        }

        internal string ResolveUrl(int page, List<string> row)
        {
            List<string> query = new List<string>();
 
            foreach (KeyValuePair<string, string> parameter in Parameters)
                query.Add($"{Uri.EscapeDataString(parameter.Key)}={Uri.EscapeDataString(Resolve(parameter.Value ?? string.Empty, page, row))}");
 
            string path = Resolve(Path, page, row);
 
            return 0 == query.Count
                ? path
                : path + (path?.Contains("?") ?? false ? "&" : "?") + string.Join("&", query);
        }

        internal string ResolveBody(int page, List<string> row)
        {
            return Resolve(Body, page, row);
        }

        string Resolve(string text, int page, List<string> row)
        {
            string resolved = text?.Replace(PageToken, (FirstPage + page).ToString());
 
            if (null != resolved && null != row)
                for (int token = 0; token < row.Count; token++)
                    resolved = resolved.Replace($"{{{token}}}", row[token] ?? string.Empty);
 
            return resolved;
        }

        internal int TokenCount()
        {
            int highest = -1;
 
            foreach (string text in TokenizedText())
                foreach (Match match in Regex.Matches(text ?? string.Empty, @"\{(\d+)\}"))
                    if (match.Value != PageToken)
                        highest = Math.Max(highest, int.Parse(match.Groups[1].Value));
 
            return highest + 1;
        }

        List<string> TokenizedText()
        {
            List<string> text = new List<string> { Path, Body };
 
            foreach (KeyValuePair<string, string> parameter in Parameters)
                text.Add(parameter.Value);
 
            foreach (KeyValuePair<string, string> header in Headers)
                text.Add(header.Value);
 
            return text;
        }

        internal string[] HeaderPairs(int page, List<string> row)
        {
            List<string> pairs = new List<string>();
 
            foreach (KeyValuePair<string, string> header in Headers)
            {
                pairs.Add(header.Key);
                pairs.Add(Resolve(header.Value, page, row));
            }
 
            return pairs.ToArray();
        }

        static KeyValuePair<string, string> SplitPair(string pair, char separator)
        {
            KeyValuePair<string, string> split = new KeyValuePair<string, string>(pair, string.Empty);
            int at = pair?.IndexOf(separator) ?? -1;
 
            if (0 <= at)
                split = new KeyValuePair<string, string>(pair.Substring(0, at).Trim(), pair.Substring(at + 1).Trim());
 
            return split;
        }
    }
}