UnitOfWork.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.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Windows.Automation;
using OpenQA.Selenium;
using static GenerallyPositive.Enums;
using GenerallyPositive.Browser;
using GenerallyPositive.Application;
using static GenerallyPositive.Browser.Browser;
 
 
namespace GenerallyPositive
{
    public class UnitOfWork
    {
        public List<Selector> WithSelectorList { get; internal set; } = null;
 
        // list of IN (nested) selectors defined
        public List<Selector> InSelectorList { get; internal set; } = null;
        public  Selector CurrentSelector { get; internal set; } = null;
        public Selector NextPageButton { get; internal set; } = null;
        public bool InfiniteScroll { get; internal set; } = false;
        public int PageCount { get; internal set; } = 1;

        internal IGPALGrid<string> RetGrid { get; set; } = null;
        public List<string> TokenList { get; internal set; } = null;

        internal class WebElementWithType
        {
            internal Selector selector;
            internal GPALElement gPalElement;
            internal ElementType elementType;
            internal bool currentNode;
 
            // .InElement can match many, and the searches after it run once inside each. These say which
            // ones it matched and which of them the pass being walked is about
            internal List<GPALElement> elements;
            internal int current;
 
            // What the walk should use for this step: the one being iterated when there are many, the single
            // element otherwise, which is every step that is not a plural .InElement
            internal GPALElement CurrentElement =>
                null != elements && current < elements.Count ? elements[current] : gPalElement;
 
            internal WebElementWithType(Selector selector, GPALElement webElement, ElementType elementType)
            {
                this.gPalElement = webElement;
                this.elementType = elementType;
                this.currentNode = true;
                this.selector = selector;
            }
        }
        internal List<WebElementWithType> ContextPath { get; set; }
        internal GPALElement ShadowRoot { get; set; }
        // response bodies from .Fetch, one per page per row of tokens, in the order they were requested
        internal List<string> FetchResults { get; set; } = new List<string>();
        // rows of values .Fetch drops into the request's numbered tokens, one row per set of requests
        internal IGPALGrid<string> FetchTokens { get; set; }
//        internal GPALElement ShadowRootGPALElement { get; set; }
 
        internal class ElementNode
        {
            public AutomationElement AutomationElement { get; internal set; }
            public Control ControlElement { get; internal set; }
            public GPALElement GPALElement { get; internal set; }
            public InteractionType InteractionType { get; internal set; } = InteractionType.Selenium;
            public int OffsetX { get; internal set; } = 0;
            public int OffsetY { get; internal set; } = 0;
        }
        // data grid of elements rows and columns
        // used with FillInFrom
        // used with FillInFromTokens
        internal GPALGrid<UnitOfWork.ElementNode> ElementGrid { get; set; } = null;
        public List<string> HeaderList { get; internal set; } = null;
        // the column names the control supplied for itself, a UIA TablePattern's headers. Kept apart from
        // HeaderList because WithHeader clears that one, and a name the control gave us is still the best name
        // for a column the workflow did not name
        public List<string> ControlHeaderList { get; internal set; } = null;
        internal SortedDictionary<int, string> MatchedRowIndexes { get; set; } = null;
        public bool PartialMatch { get; internal set; } = false;
 
        // toggles, if BrowserAction is called, the next WithSelector will start a new UOW (old UOW saved but no longer in scope)
        public bool ActionCalled { get; internal set; } = false;
        internal bool GetGridCalled { get; set; } = false;
        public int WithAllThatMatch { get; internal set; } = int.MaxValue;    // all rows, default
        internal WaitTime WaitForInMs { get; set; } = WaitTime.Never;
        internal DateTime? WaitForSatisfied { get; set; } = null;
        internal string WaitForTitle { get; set; } = null;
        internal string WaitForTitleRegex { get; set; } = null;
        internal ElementState WaitForElementState { get; set; } = ElementState.NotSet;
 
        internal int ColCount { get; set; } = 0;
        internal int RowCount { get; set; } = 0;
 
        internal Browser.Browser.CallAfterFillInDelegate CallAfterFillIn { get; set; }
        internal List<CallIfDelegate> CallIfFound { get; set; }
        internal List<CallIfDelegate> CallIfNotFound { get; set; }
        internal Application.Application.CallAfterFillInDelegate AppCallAfterFillIn { get; set; }
        internal List<Application.Application.CallIfDelegate> AppCallIfFound { get; set; }
        internal List<Application.Application.CallIfDelegate> AppCallIfNotFound { get; set; }
 
        public CallIfStatus CallIfFoundHandled { get; internal set; } = CallIfStatus.NotHandled;
        public CallIfStatus CallIfNotFoundHandled { get; internal set; } = CallIfStatus.NotHandled;
        public CallIfStatus AppCallIfFoundHandled { get; internal set; } = CallIfStatus.NotHandled;
        public CallIfStatus AppCallIfNotFoundHandled { get; internal set; } = CallIfStatus.NotHandled;

        public GPALFile InputFile { get; internal set; }
        public IGPALDatabase InputDatabase { get; internal set; }
 
        public Browser.Browser Browser { get; internal set; }
 
        internal UnitOfWork()
        {
            WithSelectorList = new List<Selector>();
            InSelectorList = new List<Selector>();
            HeaderList = new List<string>();
            ControlHeaderList = new List<string>();
            CallIfFound = new List<CallIfDelegate>();
            CallIfNotFound = new List<CallIfDelegate>();
            AppCallIfFound = new List<Application.Application.CallIfDelegate>();
            AppCallIfNotFound = new List<Application.Application.CallIfDelegate>();
            MatchedRowIndexes = new SortedDictionary<int, string>();
            ElementGrid = new GPALGrid<UnitOfWork.ElementNode>();
            ContextPath = new List<WebElementWithType>();
            WaitForInMs = GPAL.GPALSettings.WaitForInMs;  // if globally defined, then set the 'default' waitfor time
            ShadowRoot = null;
            RetGrid = GPAL.GridForType<string>();
        }
 
    }
}