GPALGrid.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;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static GenerallyPositive.Enums;
 
namespace GenerallyPositive
{
    internal class GPALGrid<T> : IGPALGrid<T>
    {
        private List<List<T>> data;
        // rows arrive from whatever thread ran the workflow that made them, and GPAL.Workflow runs several
        // of those at once, so adding a row is one step rather than a read of Count and a write after it
        private readonly object rowLock = new object();

        internal bool UseDedupe { get; private set; } = false;

        public IGPALGrid<T> WithDedupeData(bool useDedupe = true)
        {
            UseDedupe = useDedupe;
            return this;
        }

        internal GPALGrid()
        {
            data = new List<List<T>>();
        }

        public IAllowGridActions<T> AddRow(List<T> row)
        {
            if (row == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "Row is null in AddRow(List<T>). Skipping addition.", this, GPALObjectType.Other);
                return this;
            }
 
            lock (rowLock)
                data.Add(row);
 
            return this;
        }
        internal void Add(List<T> row)
        {
            if (row == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "Row is null in AddRow(List<T>). Skipping addition.", this, GPALObjectType.Other);
            }
 
            data.Add(row);
        }
 
        public IAllowGridActions<T> Add(IGPALGrid<T> grid)
        {
            foreach (List<T> row in grid)
                data.Add(row);
 
            return this;
        }
        public IAllowGridActions<T> AddRow(object anonymousObject)
        {
            if (anonymousObject == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "Anonymous object is null in AddRow(object). Skipping addition.", this, GPALObjectType.Other);
                return this;
            }
 
            // Convert anonymous object properties to a list of values
            var values = anonymousObject.GetType()
                .GetProperties()
                .Select(prop => prop.GetValue(anonymousObject, null))
                .ToList();
 
            // Validate column count if the grid already has rows
            lock (rowLock)
            {
                int expectedColumns = Columns;
                if (data.Count > 0 && values.Count != expectedColumns)
                    GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Anonymous object has [{values.Count}] values, but expected [{expectedColumns}]. Adding row as-is.", this, GPALObjectType.Other);
            }
 
            // Convert each value to type T
            var row = new List<T>();
            foreach (var value in values)
            {
                try
                {
                    if (value == null)
                    {
                        row.Add(default(T));
                        continue;
                    }
                    row.Add((T)Convert.ChangeType(value, typeof(T)));
                }
                catch (Exception ex)
                {
                    GPAL.PublishSimpleEvent(GPALEventType.ERROR, $"Cannot convert value [{value}] to type [{typeof(T).Name}]. Using default value", this, GPALObjectType.Other, ex);
                    row.Add(default(T));
                }
            }
 
            lock (rowLock)
                data.Add(row);
 
            return this;
        }

        public IAllowGridActions<T> AddRow(params T[] values)
        {
            if (values == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "Values array is null in AddRow(params T[]). Skipping addition.", this, GPALObjectType.Other);
                return this;
            }
 
            // Validate column count if the grid already has rows, and add while still holding the gate
            lock (rowLock)
            {
                int expectedColumns = Columns;
                if (data.Count > 0 && values.Length != expectedColumns)
                    GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Params array has [{values.Length}] values, but expected [{expectedColumns}]. Adding row as-is.", this, GPALObjectType.Other);
 
                data.Add(new List<T>(values));
            }
            return this;
        }

        public IAllowGridActions<T> DeleteRow(int rowIdx)
        {
            if (rowIdx >= 0 && rowIdx < data.Count)
            {
                data.RemoveAt(rowIdx);
            }
            else
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Invalid row index [{rowIdx}] in DeleteRow(int). Row count is [{data.Count}]. Skipping deletion.", this, GPALObjectType.Other);
            }
            return this;
        }

        public IAllowGridActions<T> DeleteRow(RowPosition rowPosition = RowPosition.Last)
        {
            int rowIdx;
 
            if (data.Count == 0)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "Grid is empty in DeleteRow(RowPosition). Skipping deletion.", this, GPALObjectType.Other);
                return this;
            }
 
            if (rowPosition == RowPosition.First)
            {
                rowIdx = 0;
            }
            else // position == RowPosition.Last
            {
                rowIdx = data.Count - 1;
            }
 
            data.RemoveAt(rowIdx);
            return this;
        }

        public IAllowGridActions<T> AddColumn(List<T> column)
        {
            if (column == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "Column is null in AddColumn. Skipping addition.", this, GPALObjectType.Other);
                return this;
            }
 
            for (int i = 0; i < column.Count; i++)
            {
                if (data.Count <= i)
                {
                    data.Add(new List<T>());
                }
                data[i].Add(column[i]);
            }
            return this;
        }

        public int Rows => data.Count;

        public int Columns 
        {
            get
            {
                int count = 0;
 
                foreach (var row in data)
                    count = Math.Max(count, row.Count);
 
                return count;
            }
        }

        public IAllowGridActions<T> AddCell(T value, int row, int column)
        {
            if (row >= 0 && row < Rows && column >= 0 && column < Columns)
            {
                data[row][column] = value;
            }
            else
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Invalid cell coordinates ([{row}], [{column}]) in AddCell. Grid size is [{Rows}]x[{Columns}]. Skipping operation.", this, GPALObjectType.Other);
            }
            return this;
        }

        public T GetCell(int row, int column)
        {
            if (row >= 0 && row < Rows && column >= 0 && column < Columns)
            {
                return data[row][column];
            }
 
            GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Invalid cell coordinates ([{row}], [{column}]) in GetCell. Grid size is [{Rows}]x[{Columns}]. Returning default value.", this, GPALObjectType.Other);
            return default(T);
        }

        public IAllowGridActions<T> Clear()
        {
            data = new List<List<T>>();
            return this;
        }

        public List<T> this[int index]
        {
            get
            {
                if (index >= data.Count)
                {
                    for (int idx = index; idx >= data.Count; idx--)
                        data.Add(new List<T>());
                }
 
                return data[index];
            }
            set
            {
                if (index >= data.Count)
                {
                    for (int idx = index; idx >= data.Count; idx--)
                        data.Add(new List<T>());
                }
 
                if (value == null)
                {
                    GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Value is null in indexer set at index [{index}]. Setting to empty list.", this, GPALObjectType.Other);
                    data[index] = new List<T>();
                    return;
                }
 
                data[index] = value;
            }
        }

        public T this[int row, int column]
        {
            get { return GetCell(row, column); }
            set { AddCell(value, row, column); }
        }

        public IGPALGrid<T> ToGPALObject()
        {
            return this;
        }

        public bool Contains(T value)
        {
            if (value == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "Value is null in Contains. Returning false.", this, GPALObjectType.Other);
                return false;
            }
 
            string valueString = value.ToString();
            foreach (List<T> list in data)
                foreach (T item in list)
                    if (item != null && item.ToString().Contains(valueString))
                        return true;
            return false;
        }

        public int Count() => data.Count();

        public IEnumerator<List<T>> GetEnumerator()
        {
            return data.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public object Clone()
        {
            GPALGrid<T> clone = new GPALGrid<T>();
 
            foreach (List<T> row in data)
            {
                List<T> clonedRow = new List<T>();
                foreach (T item in row)
                {
                    if (item is ICloneable cloneable)
                    {
                        clonedRow.Add((T)cloneable.Clone());
                    }
                    else
                    {
                        clonedRow.Add(item);
                    }
                }
                clone.AddRow(clonedRow);
            }
 
            return clone;
        }

        public IAllowGridActions<T> InputFrom(GPALFile input)
        {
            FileHelper.TokenizeFile(input); // CAVEAT: NOTE: could tokenize multiple files? if wildcard? but we only grab top list
            data = (List<List<T>>)((IGPALFileInternal)input).TokenList[0].Clone();
            return this;
        }

        public IAllowGridActions<T> SaveTo(GPALFile output)
        {
            GPAL.Converter.WithInput(this).SaveTo(output);
            return this;
        }

        public IAllowGridActions<T> InputFrom(IGPALDatabase input)
        {
            throw new NotImplementedException();
        }

        public IAllowGridActions<T> SaveTo(IGPALDatabase output)
        {
            throw new NotImplementedException();
        }

        public List<T> ToList()
        {
            List<T> retVal = new List<T>();
 
            foreach (List<T> row in data)
                foreach (T col in row)
                    retVal.Add(col);
 
            return retVal;
        }
    }
}