using DiunaBI.Application.DTOModels;
using Microsoft.AspNetCore.Components;
using MudBlazor;
using System.Reflection;

namespace DiunaBI.UI.Shared.Pages;

public partial class LayerDetailPage : ComponentBase
{
    [Parameter]
    public Guid Id { get; set; }

    [Inject]
    private ISnackbar Snackbar { get; set; } = null!;

    [Inject]
    private IDialogService DialogService { get; set; } = null!;

    private LayerDto? layer;
    private List<RecordDto> records = new();
    private List<string> displayedColumns = new();
    private double valueSum = 0;
    private bool isLoading = false;
    private Guid? editingRecordId = null;
    private RecordDto? editingRecord = null;
    private bool isAddingNew = false;
    private RecordDto newRecord = new();
    private bool isEditable => layer?.Type == LayerType.Dictionary || layer?.Type == LayerType.Administration;

    protected override async Task OnInitializedAsync()
    {
        await LoadLayer();
    }

    protected override async Task OnParametersSetAsync()
    {
        await LoadLayer();
    }

    private async Task LoadLayer()
    {
        isLoading = true;
        StateHasChanged();

        try
        {
            layer = await LayerService.GetLayerByIdAsync(Id);

            if (layer != null && layer.Records != null)
            {
                records = layer.Records;
                CalculateDisplayedColumns();
                CalculateValueSum();
            }
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"Error loading layer: {ex.Message}");
            Snackbar.Add("Error loading layer", Severity.Error);
        }
        finally
        {
            isLoading = false;
            StateHasChanged();
        }
    }

    private void CalculateDisplayedColumns()
    {
        displayedColumns.Clear();

        // Check which Value columns have data
        for (int i = 1; i <= 32; i++)
        {
            var columnName = $"Value{i}";
            var hasData = records.Any(r => GetRecordValueByName(r, columnName) != null);

            if (hasData)
            {
                displayedColumns.Add(columnName);
            }
        }

        // Check if Desc1 has data
        if (records.Any(r => !string.IsNullOrEmpty(r.Desc1)))
        {
            displayedColumns.Add("Description1");
        }
    }

    private void CalculateValueSum()
    {
        valueSum = records
            .Where(r => r.Value1.HasValue)
            .Sum(r => r.Value1!.Value);
    }

    private string GetRecordValue(RecordDto record, string columnName)
    {
        if (columnName == "Description1")
        {
            return record.Desc1 ?? string.Empty;
        }

        var value = GetRecordValueByName(record, columnName);
        return value.HasValue ? value.Value.ToString("N2") : string.Empty;
    }

    private double? GetRecordValueByName(RecordDto record, string columnName)
    {
        var property = typeof(RecordDto).GetProperty(columnName, BindingFlags.Public | BindingFlags.Instance);
        if (property != null && property.PropertyType == typeof(double?))
        {
            return property.GetValue(record) as double?;
        }
        return null;
    }

    private void Export()
    {
        // TODO: Implement export functionality
        Snackbar.Add("Export functionality coming soon", Severity.Error);
    }

    private void ProcessLayer()
    {
        // TODO: Implement process layer functionality
        Snackbar.Add("Process layer functionality coming soon", Severity.Error);
    }

    // Record editing methods
    private void StartEdit(RecordDto record)
    {
        editingRecordId = record.Id;
        editingRecord = new RecordDto
        {
            Id = record.Id,
            Code = record.Code,
            Desc1 = record.Desc1,
            LayerId = record.LayerId
        };
    }

    private void CancelEdit()
    {
        editingRecordId = null;
        editingRecord = null;
    }

    private async Task SaveEdit()
    {
        if (editingRecord == null || layer == null) return;

        if (string.IsNullOrWhiteSpace(editingRecord.Code))
        {
            Snackbar.Add("Code is required", Severity.Warning);
            return;
        }

        if (string.IsNullOrWhiteSpace(editingRecord.Desc1))
        {
            Snackbar.Add("Description is required", Severity.Warning);
            return;
        }

        try
        {
            var updated = await LayerService.UpdateRecordAsync(layer.Id, editingRecord.Id, editingRecord);
            if (updated != null)
            {
                var record = records.FirstOrDefault(r => r.Id == editingRecord.Id);
                if (record != null)
                {
                    record.Code = updated.Code;
                    record.Desc1 = updated.Desc1;
                    record.ModifiedAt = updated.ModifiedAt;
                }
                editingRecordId = null;
                editingRecord = null;
                Snackbar.Add("Record updated successfully", Severity.Success);
                StateHasChanged();
            }
            else
            {
                Snackbar.Add("Failed to update record", Severity.Error);
            }
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"Error updating record: {ex.Message}");
            Snackbar.Add("Error updating record", Severity.Error);
        }
    }

    private async Task DeleteRecord(RecordDto record)
    {
        if (layer == null) return;

        var result = await DialogService.ShowMessageBox(
            "Confirm Delete",
            $"Are you sure you want to delete record '{record.Code}'?",
            yesText: "Delete",
            cancelText: "Cancel");

        if (result == true)
        {
            try
            {
                var success = await LayerService.DeleteRecordAsync(layer.Id, record.Id);
                if (success)
                {
                    records.Remove(record);
                    CalculateDisplayedColumns();
                    CalculateValueSum();
                    Snackbar.Add("Record deleted successfully", Severity.Success);
                }
                else
                {
                    Snackbar.Add("Failed to delete record", Severity.Error);
                }
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine($"Error deleting record: {ex.Message}");
                Snackbar.Add("Error deleting record", Severity.Error);
            }
        }
    }

    private void StartAddNew()
    {
        isAddingNew = true;
        newRecord = new RecordDto { LayerId = layer?.Id ?? Guid.Empty };
    }

    private void CancelAddNew()
    {
        isAddingNew = false;
        newRecord = new();
    }

    private async Task SaveNewRecord()
    {
        if (layer == null) return;

        if (string.IsNullOrWhiteSpace(newRecord.Code))
        {
            Snackbar.Add("Code is required", Severity.Warning);
            return;
        }

        if (string.IsNullOrWhiteSpace(newRecord.Desc1))
        {
            Snackbar.Add("Description is required", Severity.Warning);
            return;
        }

        try
        {
            var created = await LayerService.CreateRecordAsync(layer.Id, newRecord);
            if (created != null)
            {
                records.Add(created);
                CalculateDisplayedColumns();
                CalculateValueSum();
                isAddingNew = false;
                newRecord = new();
                Snackbar.Add("Record added successfully", Severity.Success);
            }
            else
            {
                Snackbar.Add("Failed to add record", Severity.Error);
            }
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"Error adding record: {ex.Message}");
            Snackbar.Add("Error adding record", Severity.Error);
        }
    }
}