AyCode.Blazor/AyCode.Blazor.Components/Components/Grids/MgGridInfoPanel.razor.cs

using DevExpress.Blazor;
using Microsoft.AspNetCore.Components;

namespace AyCode.Blazor.Components.Components.Grids;

public partial class MgGridInfoPanel<TDataItem> : ComponentBase where TDataItem : class
{
    private DxGrid? _currentGrid;
    private TDataItem? _currentDataItem;
    private int _focusedRowVisibleIndex = -1;
    private List<DxGridDataColumn> _allDataColumns = [];

    // Edit mode state
    private bool _isEditMode;
    private TDataItem? _editModel;

    // Cache for edit settings to avoid repeated lookups
    private readonly Dictionary<string, IEditSettings?> _editSettingsCache = [];

    /// <summary>
    /// Refreshes the InfoPanel with data from the specified grid row (view mode)
    /// </summary>
    public void RefreshData(DxGrid grid, TDataItem? dataItem, int visibleIndex = -1)
    {
        ArgumentNullException.ThrowIfNull(grid);
        
        _currentGrid = grid;
        _currentDataItem = dataItem;
        _focusedRowVisibleIndex = visibleIndex;
        _editSettingsCache.Clear();
        
        // Ha nem vagyunk edit módban, frissítjük az oszlopokat
        if (!_isEditMode)
        {
            if (_currentGrid != null && _currentDataItem != null)
            {
                _allDataColumns = GetAllDataColumns(_currentGrid);
            }
            else
            {
                _allDataColumns = [];
            }
        }

        StateHasChanged();
    }

    /// <summary>
    /// Sets the InfoPanel to edit mode with the given edit model
    /// </summary>
    public void SetEditMode(TDataItem editModel)
    {
        _editModel = editModel;
        _isEditMode = true;
        _currentDataItem = editModel;
        
        if (_currentGrid != null)
        {
            _allDataColumns = GetAllDataColumns(_currentGrid);
        }
        
        StateHasChanged();
    }

    /// <summary>
    /// Clears edit mode and returns to view mode
    /// </summary>
    public void ClearEditMode()
    {
        _isEditMode = false;
        _editModel = null;
        StateHasChanged();
    }

    /// <summary>
    /// Clears the InfoPanel completely
    /// </summary>
    public void Clear()
    {
        _currentGrid = null;
        _currentDataItem = null;
        _focusedRowVisibleIndex = -1;
        _allDataColumns = [];
        _editSettingsCache.Clear();
        _isEditMode = false;
        _editModel = null;
        StateHasChanged();
    }

    /// <summary>
    /// Gets the data item to display/edit (EditModel in edit mode, otherwise CurrentDataItem)
    /// </summary>
    private TDataItem? GetActiveDataItem() => _isEditMode && _editModel != null ? _editModel : _currentDataItem;

    /// <summary>
    /// Gets the display text for a field using the grid's internal formatting.
    /// For ComboBox columns, tries to get the text from the lookup data source.
    /// </summary>
    private string GetDisplayTextFromGrid(DxGridDataColumn column)
    {
        var dataItem = GetActiveDataItem();
        if (_currentGrid == null || dataItem == null || string.IsNullOrWhiteSpace(column.FieldName))
            return string.Empty;

        try
        {
            var value = _currentGrid.GetDataItemValue(dataItem, column.FieldName);
            
            if (value == null)
                return string.Empty;

            // Try to resolve display text from EditSettings
            var editSettings = GetEditSettings(column.FieldName);
            if (editSettings != null)
            {
                var displayText = ResolveEditSettingsDisplayText(editSettings, value);
                if (!string.IsNullOrEmpty(displayText))
                    return displayText;
            }

            // Apply column's DisplayFormat if available
            if (!string.IsNullOrEmpty(column.DisplayFormat))
            {
                try
                {
                    return string.Format(column.DisplayFormat, value);
                }
                catch
                {
                    // If format fails, fall through to default formatting
                }
            }

            return FormatValue(value);
        }
        catch
        {
            return string.Empty;
        }
    }

    /// <summary>
    /// Gets edit settings for the specified field (with caching)
    /// </summary>
    private IEditSettings? GetEditSettings(string fieldName)
    {
        if (_currentGrid == null || string.IsNullOrEmpty(fieldName))
            return null;

        if (_editSettingsCache.TryGetValue(fieldName, out var cached))
            return cached;

        IEditSettings? settings = null;
        try
        {
            // Try each EditSettings type
            settings = TryGetEditSettings<DxComboBoxSettings>(fieldName)
                    ?? TryGetEditSettings<DxDateEditSettings>(fieldName)
                    ?? TryGetEditSettings<DxTimeEditSettings>(fieldName)
                    ?? TryGetEditSettings<DxSpinEditSettings>(fieldName)
                    ?? TryGetEditSettings<DxCheckBoxSettings>(fieldName)
                    ?? TryGetEditSettings<DxMemoSettings>(fieldName)
                    ?? TryGetEditSettings<DxMaskedInputSettings>(fieldName)
                    ?? TryGetEditSettings<DxTextBoxSettings>(fieldName)
                    ?? (IEditSettings?)TryGetEditSettings<DxDropDownEditSettings>(fieldName);
        }
        catch
        {
            // Ignore errors
        }

        _editSettingsCache[fieldName] = settings;
        return settings;
    }

    private T? TryGetEditSettings<T>(string fieldName) where T : class, IEditSettings
    {
        try
        {
            return _currentGrid?.GetColumnEditSettings<T>(fieldName);
        }
        catch
        {
            return null;
        }
    }

    /// <summary>
    /// Resolves display text based on EditSettings type
    /// </summary>
    private string? ResolveEditSettingsDisplayText(IEditSettings settings, object value)
    {
        return settings switch
        {
            DxComboBoxSettings comboSettings => ResolveComboBoxDisplayText(comboSettings, value),
            _ => null
        };
    }

    /// <summary>
    /// Resolves the display text from a ComboBox data source
    /// </summary>
    private string? ResolveComboBoxDisplayText(DxComboBoxSettings settings, object value)
    {
        if (settings.Data == null || string.IsNullOrEmpty(settings.ValueFieldName) || string.IsNullOrEmpty(settings.TextFieldName))
            return null;

        try
        {
            foreach (var item in (System.Collections.IEnumerable)settings.Data)
            {
                if (item == null) continue;

                var itemType = item.GetType();
                var valueProperty = itemType.GetProperty(settings.ValueFieldName);
                var textProperty = itemType.GetProperty(settings.TextFieldName);

                if (valueProperty == null || textProperty == null) continue;

                var itemValue = valueProperty.GetValue(item);
                if (itemValue != null && itemValue.Equals(value))
                {
                    return textProperty.GetValue(item)?.ToString();
                }
            }
        }
        catch
        {
            // If lookup fails, return null and fall back to default formatting
        }

        return null;
    }

    private string FormatValue(object? value)
    {
        if (value == null)
            return string.Empty;

        return value switch
        {
            DateTime dateTime => dateTime.ToString("yyyy-MM-dd HH:mm:ss"),
            DateOnly dateOnly => dateOnly.ToString("yyyy-MM-dd"),
            TimeOnly timeOnly => timeOnly.ToString("HH:mm:ss"),
            TimeSpan timeSpan => timeSpan.ToString(@"hh\:mm\:ss"),
            bool boolValue => boolValue ? "Igen" : "Nem",
            decimal decValue => decValue.ToString("N2"),
            double dblValue => dblValue.ToString("N2"),
            float fltValue => fltValue.ToString("N2"),
            int or long or short or byte => string.Format("{0:N0}", value),
            _ => value.ToString() ?? string.Empty
        };
    }

    private List<DxGridDataColumn> GetAllDataColumns(DxGrid grid)
    {
        var columns = new List<DxGridDataColumn>();

        try
        {
            var allColumns = grid.GetDataColumns();
            if (allColumns != null)
            {
                foreach (var column in allColumns)
                {
                    if (column is DxGridDataColumn dataColumn && 
                        !string.IsNullOrWhiteSpace(dataColumn.FieldName))
                    {
                        columns.Add(dataColumn);
                    }
                }
            }
        }
        catch (Exception)
        {
            // Fallback: empty list if GetDataColumns fails
        }

        return columns;
    }

    private object? GetCellValue(DxGridDataColumn column)
    {
        var dataItem = GetActiveDataItem();
        if (_currentGrid == null || dataItem == null || string.IsNullOrWhiteSpace(column.FieldName))
            return null;

        try
        {
            return _currentGrid.GetDataItemValue(dataItem, column.FieldName);
        }
        catch
        {
            return null;
        }
    }

    /// <summary>
    /// Gets the EditSettings type for rendering logic
    /// </summary>
    private EditSettingsType GetEditSettingsType(DxGridDataColumn column)
    {
        var settings = GetEditSettings(column.FieldName);
        
        return settings switch
        {
            DxComboBoxSettings => EditSettingsType.ComboBox,
            DxDateEditSettings => EditSettingsType.DateEdit,
            DxTimeEditSettings => EditSettingsType.TimeEdit,
            DxSpinEditSettings => EditSettingsType.SpinEdit,
            DxCheckBoxSettings => EditSettingsType.CheckBox,
            DxMemoSettings => EditSettingsType.Memo,
            _ => EditSettingsType.None
        };
    }

    private enum EditSettingsType
    {
        None,
        ComboBox,
        DateEdit,
        TimeEdit,
        SpinEdit,
        CheckBox,
        Memo
    }
}