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

namespace AyCode.Blazor.Components.Components.Grids;

/// <summary>
/// Interface for InfoPanel to support grid access
/// </summary>
public interface IInfoPanelBase
{
    void ClearEditMode();
    void SetEditMode(IMgGridBase grid, object editModel);
    void RefreshData(IMgGridBase grid, object? dataItem, int visibleIndex = -1);
}

/// <summary>
/// Context for InfoPanel templates containing data item and edit mode state
/// </summary>
public record InfoPanelContext(object? DataItem, bool IsEditMode);

/// <summary>
/// InfoPanel component for displaying and editing grid row details
/// </summary>
public partial class MgGridInfoPanel : ComponentBase, IAsyncDisposable, IInfoPanelBase
{
    [Inject] private IJSRuntime JSRuntime { get; set; } = null!;

    /// <summary>
    /// Whether to show readonly fields when in edit mode. Default is false.
    /// </summary>
    [Parameter] public bool ShowReadOnlyFieldsInEditMode { get; set; } = false;

    /// <summary>
    /// Minimum width for 2 columns layout. Default is 500px.
    /// </summary>
    [Parameter] public int TwoColumnBreakpoint { get; set; } = 400;

    /// <summary>
    /// Minimum width for 3 columns layout. Default is 800px.
    /// </summary>
    [Parameter] public int ThreeColumnBreakpoint { get; set; } = 800;

    /// <summary>
    /// Minimum width for 4 columns layout. Default is 1200px.
    /// </summary>
    [Parameter] public int FourColumnBreakpoint { get; set; } = 1300;

    /// <summary>
    /// Fixed column count. If set (1-4), overrides responsive breakpoints. Default is null (responsive).
    /// </summary>
    [Parameter] public int? FixedColumnCount { get; set; }

    /// <summary>
    /// Reference to the wrapper component - automatically registers this InfoPanel
    /// </summary>
    [CascadingParameter]
    public MgGridWithInfoPanel? GridWrapper { get; set; }

    private ElementReference _panelElement;
    private bool _isJsInitialized;
    private const int DefaultTopOffset = 300;

    protected IMgGridBase? _currentGrid;
    protected object? _currentDataItem;
    protected int _focusedRowVisibleIndex = -1;
    protected List<DxGridDataColumn> _allDataColumns = [];

    // Edit mode state
    protected bool _isEditMode;
    protected object? _editModel;

    // Type-based caches for performance optimization
    private readonly Dictionary<(Type, string), IEditSettings?> _editSettingsCache = [];
    private readonly Dictionary<Type, List<DxGridDataColumn>> _columnsCache = [];
    private readonly Dictionary<(Type, object, object), string?> _comboBoxTextCache = [];
    
    // Track if we need to update UI
    private bool _pendingStateChange;

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if (firstRender)
        {
            GridWrapper?.RegisterInfoPanel(this);
            await InitializeStickyAsync();
        }
    }

    private async Task InitializeStickyAsync()
    {
        try
        {
            await JSRuntime.InvokeVoidAsync(
                "MgGridInfoPanel.initSticky",
                _panelElement,
                DefaultTopOffset);
            _isJsInitialized = true;
        }
        catch (JSException)
        {
            // JS might not be loaded yet, ignore
        }
    }

    /// <summary>
    /// Refreshes the InfoPanel with data from the specified grid row (view mode)
    /// </summary>
    public void RefreshData(IMgGridBase grid, object? dataItem, int visibleIndex = -1)
    {
        ArgumentNullException.ThrowIfNull(grid);
        
        _currentGrid = grid;
        _currentDataItem = dataItem;
        _focusedRowVisibleIndex = visibleIndex;
        
        // Clear edit mode when refreshing with new data
        _isEditMode = false;
        _editModel = null;
        
        // Use cached columns if available
        if (_currentGrid != null && _currentDataItem != null)
        {
            var dataItemType = _currentDataItem.GetType();
            _allDataColumns = GetAllDataColumnsCached(dataItemType, _currentGrid);
        }
        else
        {
            _allDataColumns = [];
        }

        // Batch state changes
        if (!_pendingStateChange)
        {
            _pendingStateChange = true;
            InvokeAsync(async () =>
            {
                _pendingStateChange = false;
                StateHasChanged();
                await OnDataItemChanged.InvokeAsync(dataItem);
            });
        }
    }

    /// <summary>
    /// Sets the InfoPanel to edit mode with the given edit model
    /// </summary>
    public void SetEditMode(IMgGridBase grid, object editModel)
    {
        ArgumentNullException.ThrowIfNull(grid);
        ArgumentNullException.ThrowIfNull(editModel);
        
        _currentGrid = grid;
        _editModel = editModel;
        _isEditMode = true;
        _currentDataItem = _editModel;
        
        var dataItemType = _editModel.GetType();
        _allDataColumns = GetAllDataColumnsCached(dataItemType, _currentGrid);
        
        // Batch state changes
        if (!_pendingStateChange)
        {
            _pendingStateChange = true;
            InvokeAsync(() =>
            {
                _pendingStateChange = false;
                StateHasChanged();
            });
        }
    }

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

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

    public async ValueTask DisposeAsync()
    {
        if (_isJsInitialized)
        {
            try
            {
                await JSRuntime.InvokeVoidAsync("MgGridInfoPanel.disposeSticky", _panelElement);
            }
            catch
            {
                // Ignore disposal errors
            }
        }
        
        // Clear all caches on dispose
        _editSettingsCache.Clear();
        _columnsCache.Clear();
        _comboBoxTextCache.Clear();
    }

    /// <summary>
    /// Gets the data item to display/edit (EditModel in edit mode, otherwise CurrentDataItem)
    /// </summary>
    protected object? 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>
    protected 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;

            var dataItemType = dataItem.GetType();

            // Try to resolve display text from EditSettings
            var editSettings = GetEditSettingsCached(dataItemType, column.FieldName);
            if (editSettings is DxComboBoxSettings comboSettings)
            {
                var displayText = ResolveComboBoxDisplayTextCached(dataItemType, comboSettings, 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 Type-based caching
    /// </summary>
    private IEditSettings? GetEditSettingsCached(Type dataItemType, string fieldName)
    {
        if (_currentGrid == null || string.IsNullOrEmpty(fieldName))
            return null;

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

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

        _editSettingsCache[cacheKey] = settings;
        return settings;
    }

    /// <summary>
    /// Cached version of ResolveComboBoxDisplayText with Type-based key
    /// </summary>
    private string? ResolveComboBoxDisplayTextCached(Type dataItemType, DxComboBoxSettings settings, object value)
    {
        // Use settings object reference and value as cache key
        var cacheKey = (dataItemType, (object)settings, value);
        
        if (_comboBoxTextCache.TryGetValue(cacheKey, out var cached))
            return cached;
        
        var result = ResolveComboBoxDisplayText(settings, value);
        _comboBoxTextCache[cacheKey] = result;
        
        return result;
    }

    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 static 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 => $"{value:N0}",
            _ => value.ToString() ?? string.Empty
        };
    }

    /// <summary>
    /// Gets the columns to display based on edit mode and ShowReadOnlyFieldsInEditMode setting
    /// </summary>
    protected IEnumerable<DxGridDataColumn> GetVisibleColumns()
    {
        if (!_isEditMode || ShowReadOnlyFieldsInEditMode)
        {
            return _allDataColumns;
        }
        
        // In edit mode with ShowReadOnlyFieldsInEditMode=false, hide readonly columns
        return _allDataColumns.Where(c => !c.ReadOnly);
    }

    protected 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>
    /// Cached version of GetAllDataColumns with Type-based key
    /// </summary>
    private List<DxGridDataColumn> GetAllDataColumnsCached(Type dataItemType, IMgGridBase grid)
    {
        if (_columnsCache.TryGetValue(dataItemType, out var cached))
            return cached;
        
        var columns = GetAllDataColumns(grid);
        _columnsCache[dataItemType] = columns;
        
        return columns;
    }

    protected static List<DxGridDataColumn> GetAllDataColumns(IMgGridBase 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)
        {
            // Ignore errors
        }

        return columns;
    }

    /// <summary>
    /// Gets the EditSettings type for rendering logic
    /// </summary>
    private EditSettingsType GetEditSettingsType(DxGridDataColumn column)
    {
        var dataItem = GetActiveDataItem();
        if (dataItem == null) return EditSettingsType.None;
        
        var dataItemType = dataItem.GetType();
        var settings = GetEditSettingsCached(dataItemType, 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
    }
}