DiunaBI/DiunaBI.API/Controllers/LayersController.cs

using System.Globalization;
using System.Text;
using System.Text.Json;
using Google.Apis.Sheets.v4;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using DiunaBI.Application.DTOModels;
using DiunaBI.Application.DTOModels.Common;
using DiunaBI.Domain.Entities;
using DiunaBI.Infrastructure.Data;
using DiunaBI.Infrastructure.Services;

namespace DiunaBI.API.Controllers;

[Authorize]
[ApiController]
[Route("[controller]")]
public class LayersController : Controller
{
    private readonly AppDbContext _db;
    private readonly SpreadsheetsResource.ValuesResource? _googleSheetValues;
    private readonly GoogleDriveHelper _googleDriveHelper;
    private readonly IConfiguration _configuration;
    private readonly PluginManager _pluginManager;
    private readonly ILogger<LayersController> _logger;

    public LayersController(
        AppDbContext db,
        SpreadsheetsResource.ValuesResource? googleSheetValues,
        GoogleDriveHelper googleDriveHelper,
        IConfiguration configuration,
        PluginManager pluginManager,
        ILogger<LayersController> logger
    )
    {
        _db = db;
        _googleSheetValues = googleSheetValues;
        _googleDriveHelper = googleDriveHelper;
        _configuration = configuration;
        _pluginManager = pluginManager;
        _logger = logger;
    }

    [HttpGet]
    [Route("")]
    public IActionResult GetAll([FromQuery] int start, [FromQuery] int limit, [FromQuery] string? name, [FromQuery] Domain.Entities.LayerType? type)
    {
        try
        {
            // Validate pagination parameters
            if (limit <= 0 || limit > 1000)
            {
                return BadRequest("Limit must be between 1 and 1000");
            }
            if (start < 0)
            {
                return BadRequest("Start must be non-negative");
            }

            var query = _db.Layers.Where(x => !x.IsDeleted);

            if (name != null)
            {
                query = query.Where(x => x.Name != null && x.Name.Contains(name));
            }

            if (type.HasValue)
            {
                query = query.Where(x => x.Type == type.Value);
            }

            var totalCount = query.Count();

            var items = query
                .OrderByDescending(x => x.Number)
                .Skip(start)
                .Take(limit)
                .AsNoTracking()
                .Select(x => new LayerDto
                {
                    Id = x.Id,
                    Number = x.Number,
                    Name = x.Name,
                    Type = (Application.DTOModels.LayerType)x.Type,
                    CreatedAt = x.CreatedAt,
                    ModifiedAt = x.ModifiedAt,
                    CreatedById = x.CreatedById,
                    ModifiedById = x.ModifiedById,
                    IsDeleted = x.IsDeleted,
                    IsCancelled = x.IsCancelled,
                    ParentId = x.ParentId
                })
                .ToList();

            var pagedResult = new PagedResult<LayerDto>
            {
                Items = items,
                TotalCount = totalCount,
                Page = (start / limit) + 1,
                PageSize = limit
            };

            _logger.LogDebug("GetAll: Retrieved {Count} of {TotalCount} layers (page {Page}) with filter name={Name}, type={Type}",
                items.Count, totalCount, pagedResult.Page, name, type);

            return Ok(pagedResult);
        }
        catch (Exception e)
        {
            _logger.LogError(e, "GetAll: Error retrieving layers");
            return BadRequest("An error occurred processing your request");
        }
    }
    [HttpGet]
    [Route("{id:guid}")]
    public IActionResult Get(Guid id)
    {
        try
        {
            var layer = _db.Layers
                .Include(x => x.CreatedBy)
                .Include(x => x.ModifiedBy)
                .Include(x => x.Records).AsNoTracking().First(x => x.Id == id && !x.IsDeleted);

            _logger.LogDebug("Get: Retrieved layer {LayerId} {LayerName}", id, layer.Name);
            return Ok(layer);
        }
        catch (Exception e)
        {
            _logger.LogError(e, "Get: Error retrieving layer {LayerId}", id);
            return BadRequest("An error occurred processing your request");
        }
    }
    [HttpGet]
    [Route("getConfiguration/{apiKey}/{number:int}")]
    [AllowAnonymous]
    public IActionResult GetConfigurationByNumber(string apiKey, int number)
    {
        if (apiKey != _configuration["apiKey"])
        {
            _logger.LogWarning("Configuration: Unauthorized request - wrong apiKey for layer {LayerNumber}", number);
            return Unauthorized();
        }

        try
        {
            if (!Request.Headers.TryGetValue("Authorization", out var authHeader))
            {
                _logger.LogWarning("Configuration: Unauthorized request - no authorization header for layer {LayerNumber}", number);
                return Unauthorized();
            }

            var credentialsArr = authHeader.ToString().Split(" ");
            if (credentialsArr.Length != 2)
            {
                _logger.LogWarning("Configuration: Unauthorized request - wrong auth header format for layer {LayerNumber}", number);
                return Unauthorized();
            }

            var authValue = Encoding.UTF8.GetString(Convert.FromBase64String(credentialsArr[1]));
            var username = authValue.Split(':')[0];
            var password = authValue.Split(':')[1];
            if (username != _configuration["apiUser"] || password != _configuration["apiPass"])
            {
                _logger.LogWarning("Configuration: Unauthorized request - bad credentials for layer {LayerNumber}", number);
                return Unauthorized();
            }

            var config = _db.Layers
                .Include(x => x.Records)
                .AsNoTracking()
                .First(x => x.Number == number && !x.IsDeleted);

            if (config is null)
            {
                _logger.LogWarning("Configuration: Layer {LayerNumber} not found", number);
                return BadRequest();
            }

            var type = config.Records?.Where(x => x.Code == "Type").FirstOrDefault();
            if (type is null || type.Desc1 != "ExternalConfiguration")
            {
                _logger.LogWarning("Configuration: Layer {LayerNumber} is not ExternalConfiguration type", number);
                return BadRequest();
            }

            _logger.LogInformation("Configuration: Sending configuration for layer {LayerNumber}", number);
            return Ok(config);
        }
        catch (Exception e)
        {
            _logger.LogError(e, "Configuration: Error occurred while processing layer {LayerNumber}", number);
            return BadRequest();
        }
    }
    [HttpGet]
    [Route("exportToGoogleSheet/{id:guid}")]
    public IActionResult ExportToGoogleSheet(Guid id)
    {
        if (_googleSheetValues is null)
        {
            _logger.LogError("Export: Google Sheets API not initialized");
            throw new Exception("Google Sheets API not initialized");
        }

        try
        {
            var layer = _db.Layers
                .Include(x => x.Records!.OrderByDescending(y => y.Code)).AsNoTracking().First(x => x.Id == id && !x.IsDeleted);

            var export = _pluginManager.GetExporter("GoogleSheet");
            if (export == null)
            {
                _logger.LogError("Export: GoogleSheet exporter not found for layer {LayerId}", id);
                throw new Exception("GoogleSheet exporter not found");
            }

            _logger.LogInformation("Export: Starting GoogleSheet export for layer {LayerId} {LayerName}", id, layer.Name);
            export.Export(layer);
            _logger.LogInformation("Export: Successfully exported layer {LayerId} to GoogleSheet", id);

            return Ok(true);
        }
        catch (Exception e)
        {
            _logger.LogError(e, "Export: Failed to export layer {LayerId} to GoogleSheet", id);
            throw;
        }
    }
    [HttpGet]
    [Route("ProcessQueue/{apiKey}")]
    [AllowAnonymous]
    public IActionResult ProcessQueue(string apiKey)
    {
        if (Request.Host.Value != _configuration["apiLocalUrl"] || apiKey != _configuration["apiKey"])
        {
            _logger.LogWarning("ProcessQueue: Unauthorized request with apiKey {ApiKey}", apiKey);
            return Unauthorized();
        }

        _logger.LogInformation("ProcessQueue: Starting queue processing");
        // Queue processing implementation would go here
        return Ok();
    }
    [HttpGet]
    [Route("AutoImport/{apiKey}/{nameFilter}")]
    [AllowAnonymous]
    public IActionResult AutoImport(string apiKey, string nameFilter)
    {
        if (apiKey != _configuration["apiKey"])
        {
            _logger.LogWarning("AutoImport: Unauthorized request with apiKey {ApiKey}", apiKey);
            return Unauthorized();
        }

        if (_googleSheetValues is null)
        {
            _logger.LogError("AutoImport: Google Sheets API not initialized");
            throw new Exception("Google Sheets API not initialized");
        }

        var importWorkerLayers = _db.Layers
            .Include(x => x.Records)
            .Where(x =>
                x.Name != null && x.Name.Contains(nameFilter) &&
                x.Records!.Any(y => y.Code == "Type" && y.Desc1 == "ImportWorker") &&
                x.Records!.Any(y => y.Code == "IsEnabled" && y.Desc1 == "True"
                )
            )
            .OrderByDescending(x => x.CreatedAt)
            .AsNoTracking()
            .ToList();

        _logger.LogInformation("AutoImport: Starting import with filter {NameFilter}, found {LayerCount} layers",
            nameFilter, importWorkerLayers.Count);

        try
        {
            if (importWorkerLayers.Count == 0)
            {
                _logger.LogInformation("AutoImport: No layers to import");
                return Ok();
            }

            foreach (var importWorker in importWorkerLayers)
            {
                try
                {
                    var type = importWorker.Records!.FirstOrDefault(x => x.Code == "ImportType")?.Desc1 ?? "Standard";
                    var source = importWorker.Records!.FirstOrDefault(x => x.Code == "Source")?.Desc1 ?? "GoogleSheet";

                    var plugin = importWorker.Records!.FirstOrDefault(x => x.Code == "Plugin")?.Desc1;
                    if (plugin == null)
                    {
                        _logger.LogError("AutoImport: Plugin not found for layer {LayerName} ({LayerId}), skipping",
                            importWorker.Name, importWorker.Id);
                        continue;
                    }

                    _logger.LogInformation("AutoImport: Processing layer {LayerName} with type {ImportType} and source {Source}",
                        importWorker.Name, type, source);

                    if (source == "DataInbox" && type == "Import-D3")
                    {
                        var d3Importer = _pluginManager.GetImporter(plugin);
                        if (d3Importer == null)
                        {
                            throw new Exception("MorskaD3 importer not found");
                        }
                        d3Importer.Import(importWorker);

                        _logger.LogInformation("AutoImport: Successfully processed D3 import for {LayerName} ({LayerId})",
                            importWorker.Name, importWorker.Id);
                        continue;
                    }

                    switch (type)
                    {
                        case "D1":
                            var d1Importer = _pluginManager.GetImporter(plugin);
                            if (d1Importer == null)
                            {
                                throw new Exception("MorskaD1 importer not found");
                            }
                            d1Importer.Import(importWorker);
                            Thread.Sleep(5000); // be aware of GSheet API quota

                            _logger.LogInformation("AutoImport: Successfully processed D1 import for {LayerName} ({LayerId})",
                                importWorker.Name, importWorker.Id);
                            break;

                        case "FK2":
                            var fk2Importer = _pluginManager.GetImporter(plugin);
                            if (fk2Importer == null)
                            {
                                throw new Exception("MorskaFK2 importer not found");
                            }
                            fk2Importer.Import(importWorker);
                            Thread.Sleep(5000); // be aware of GSheet API quota

                            _logger.LogInformation("AutoImport: Successfully processed FK2 import for {LayerName} ({LayerId})",
                                importWorker.Name, importWorker.Id);
                            break;

                        default:
                            var startDate = importWorker.Records!.FirstOrDefault(x => x.Code == "StartDate")?.Desc1;
                            if (startDate == null)
                            {
                                throw new Exception("StartDate record not found");
                            }

                            var endDate = importWorker.Records!.First(x => x.Code == "EndDate").Desc1;
                            if (endDate == null)
                            {
                                throw new Exception("EndDate record not found");
                            }

                            var startDateParsed = DateTime.ParseExact(startDate, "yyyy.MM.dd", null);
                            var endDateParsed = DateTime.ParseExact(endDate, "yyyy.MM.dd", null);

                            if (startDateParsed.Date <= DateTime.UtcNow.Date && endDateParsed.Date >= DateTime.UtcNow.Date)
                            {
                                var importer = _pluginManager.GetImporter(plugin);
                                if (importer == null)
                                {
                                    throw new Exception("MorskaImporter not found");
                                }
                                importer.Import(importWorker);
                                Thread.Sleep(5000); // be aware of GSheet API quota

                                _logger.LogInformation("AutoImport: Successfully processed standard import for {LayerName} ({LayerId})",
                                    importWorker.Name, importWorker.Id);
                            }
                            else if (IsImportedLayerUpToDate(importWorker) == false)
                            {
                                var importer = _pluginManager.GetImporter(plugin);
                                if (importer == null)
                                {
                                    throw new Exception("MorskaImporter not found");
                                }
                                importer.Import(importWorker);
                                Thread.Sleep(5000); // be aware of GSheet API quota

                                _logger.LogWarning("AutoImport: Reimported out-of-date layer {LayerName} ({LayerId})",
                                    importWorker.Name, importWorker.Id);
                            }
                            else
                            {
                                _logger.LogInformation("AutoImport: Layer {LayerName} ({LayerId}) is up to date, skipping",
                                    importWorker.Name, importWorker.Id);
                            }
                            break;
                    }
                }
                catch (Exception e)
                {
                    _logger.LogError(e, "AutoImport: Failed to process layer {LayerName} ({LayerId})",
                        importWorker.Name, importWorker.Id);
                }
            }

            _logger.LogInformation("AutoImport: Completed processing {LayerCount} layers", importWorkerLayers.Count);
            return Ok();
        }
        catch (Exception e)
        {
            _logger.LogError(e, "AutoImport: Process error");
            return BadRequest("An error occurred processing your request");
        }
    }

    [HttpGet]
    [Route("AutoProcess/{apiKey}")]
    [AllowAnonymous]
    public IActionResult AutoProcess(string apiKey)
    {
        if (apiKey != _configuration["apiKey"])
        {
            _logger.LogWarning("AutoImport: Unauthorized request with apiKey {ApiKey}", apiKey);
            return Unauthorized();
        }

        if (_googleSheetValues is null)
        {
            _logger.LogError("AutoProcess: Google Sheets API not initialized");
            throw new Exception("Google Sheets API not initialized");
        }

        string[] processTypes =
        [
            "T3-SingleSource",
            "T3-SourceYearSummary",
            "T3-MultiSourceSummary",
            "T3-MultiSourceYearSummary",
            "T4-SingleSource",
            "T5-LastValues",
            "T1-R1",
            "T4-R2",
            "T1-R3",
            "D6"
        ];

        _logger.LogInformation("AutoProcess: Starting processing for {ProcessTypeCount} process types", processTypes.Length);

        foreach (var type in processTypes)
        {
            try
            {
                var processWorkerLayers = _db.Layers
                    .Include(x => x.Records)
                    .Where(x =>
                        x.Records!.Any(y => y.Code == "Type" && y.Desc1 == "ProcessWorker") &&
                        x.Records!.Any(y => y.Code == "IsEnabled" && y.Desc1 == "True") &&
                        x.Records!.Any(y => y.Code == "ProcessType" && y.Desc1 == type)
                    )
                    .OrderBy(x => x.CreatedAt)
                    .AsNoTracking()
                    .ToList();

                _logger.LogInformation("AutoProcess: Processing type {ProcessType}, found {LayerCount} layers",
                    type, processWorkerLayers.Count);

                foreach (var processWorker in processWorkerLayers)
                {
                    try
                    {
                        ProcessLayer(processWorker);
                        _logger.LogInformation("AutoProcess: Successfully processed {LayerName} ({LayerId}) with type {ProcessType}",
                            processWorker.Name, processWorker.Id, type);
                    }
                    catch (Exception e)
                    {
                        _logger.LogError(e, "AutoProcess: Failed to process {LayerName} ({LayerId}) with type {ProcessType}",
                            processWorker.Name, processWorker.Id, type);
                    }
                }
            }
            catch (Exception e)
            {
                _logger.LogError(e, "AutoProcess: Error processing type {ProcessType}", type);
            }
        }

        _logger.LogInformation("AutoProcess: Completed processing all process types");
        return Ok();
    }

    private void ProcessLayer(Layer processWorker)
    {
        if (_googleSheetValues == null)
        {
            throw new Exception("Google Sheets API not initialized");
        }

        var year = processWorker.Records?.SingleOrDefault(x => x.Code == "Year")?.Desc1;
        if (year == null)
        {
            throw new Exception("Year record not found");
        }

        var plugin = processWorker.Records?.SingleOrDefault(x => x.Code == "Plugin")?.Desc1;
        if (plugin == null)
        {
            throw new Exception("Plugin record not found");
        }

        var processType = processWorker.Records?.SingleOrDefault(x => x.Code == "ProcessType")?.Desc1;
        switch (processType)
        {
            case null:
                throw new Exception("ProcessType record not found");
            case "T3-SourceYearSummary":
                {
                    var processor = _pluginManager.GetProcessor(plugin);
                    if (processor == null)
                    {
                        throw new Exception("T3.SourceYearSummary processor not found");
                    }
                    processor.Process(processWorker);
                    return;
                }
            case "T3-MultiSourceYearSummary":
                {
                    var processor = _pluginManager.GetProcessor(plugin);
                    if (processor == null)
                    {
                        throw new Exception("T3.MultiSourceYearSummary processor not found");
                    }
                    processor.Process(processWorker);
                    return;
                }
            case "T3-MultiSourceCopySelectedCodesYearSummary":
                {
                    var processor = _pluginManager.GetProcessor(plugin);
                    if (processor == null)
                    {
                        throw new Exception("T3.MultiSourceCopySelectedCodesYearSummary processor not found");
                    }
                    processor.Process(processWorker);
                    return;
                }
            case "T1-R1":
                {
                    var processor = _pluginManager.GetProcessor(plugin);
                    if (processor == null)
                    {
                        throw new Exception("T1.R1 processor not found");
                    }
                    processor.Process(processWorker);
                    return;
                }
            case "T4-R2":
                {
                    var processor = _pluginManager.GetProcessor(plugin);
                    if (processor == null)
                    {
                        throw new Exception("T4.R2 processor not found");
                    }
                    processor.Process(processWorker);
                    return;
                }
            case "T1-R3":
                {
                    var processor = _pluginManager.GetProcessor(plugin);
                    if (processor == null)
                    {
                        throw new Exception("T1.R3 processor not found");
                    }
                    processor.Process(processWorker);
                    return;
                }
            case "D6":
                {
                    var processor = _pluginManager.GetProcessor(plugin);
                    if (processor == null)
                    {
                        throw new Exception("D6 processor not found");
                    }
                    processor.Process(processWorker);
                    return;
                }
        }

        var month = processWorker.Records?.SingleOrDefault(x => x.Code == "Month")?.Desc1;
        if (month == null)
        {
            throw new Exception("Month record not found");
        }

        switch (processType!)
        {
            case "T3-SingleSource":
                {
                    var t3SingleSource = _pluginManager.GetProcessor(plugin);
                    if (t3SingleSource == null)
                    {
                        throw new Exception("T3.SingleSource processor not found");
                    }
                    t3SingleSource.Process(processWorker);
                    break;
                }
            case "T4-SingleSource":
                {
                    var t4SingleSource = _pluginManager.GetProcessor(plugin);
                    if (t4SingleSource == null)
                    {
                        throw new Exception("T4.SingleSource processor not found");
                    }
                    t4SingleSource.Process(processWorker);
                    break;
                }
            case "T5-LastValues":
                {
                    var t5LastValues = _pluginManager.GetProcessor(plugin);
                    if (t5LastValues == null)
                    {
                        throw new Exception("T5.LastValues processor not found");
                    }
                    t5LastValues.Process(processWorker);
                    break;
                }
            case "T3-MultiSourceSummary":
                {
                    var t3MultiSourceSummary = _pluginManager.GetProcessor(plugin);
                    if (t3MultiSourceSummary == null)
                    {
                        throw new Exception("T3.MultiSourceSummary processor not found");
                    }
                    t3MultiSourceSummary.Process(processWorker);
                    break;
                }
            case "T3-MultiSourceCopySelectedCodes":
                {
                    var t3MultiSourceCopySelectedCode = _pluginManager.GetProcessor(plugin);
                    if (t3MultiSourceCopySelectedCode == null)
                    {
                        throw new Exception("T3.MultiSourceCopySelectedCodes processor not found");
                    }
                    t3MultiSourceCopySelectedCode.Process(processWorker);
                    break;
                }
        }
    }
    [HttpGet]
    [Route("CheckProcessors")]
    [AllowAnonymous]

    private static void WriteToConsole(params string[] messages)
    {
        foreach (var message in messages)
        {
            Console.WriteLine($"DiunaLog: {message}");
        }
    }

    private bool IsImportedLayerUpToDate(Layer importWorker)
    {
        if (_googleSheetValues is null)
        {
            throw new Exception("Google Sheets API not initialized");
        }

        var newestLayer = _db.Layers
            .Include(x => x.Records)
            .Where(x => x.ParentId == importWorker.Id)
            .OrderByDescending(x => x.CreatedAt)
            .AsNoTracking()
            .FirstOrDefault();

        if (newestLayer is null)
        {
            _logger.LogDebug("IsImportedLayerUpToDate: No child layers found for {LayerName}, treating as up to date", importWorker.Name);
            return true; // importWorker is not active yet, no check needed
        }

        var sheetId = importWorker.Records!.FirstOrDefault(x => x.Code == "SheetId")?.Desc1;
        if (sheetId == null)
        {
            throw new Exception($"SheetId not found, {importWorker.Name}");
        }

        var sheetTabName = importWorker.Records!.FirstOrDefault(x => x.Code == "SheetTabName")?.Desc1;
        if (sheetTabName == null)
        {
            throw new Exception($"SheetTabName not found, {importWorker.Name}");
        }

        var dataRange = importWorker.Records!.FirstOrDefault(x => x.Code == "DataRange")?.Desc1;
        if (dataRange == null)
        {
            throw new Exception($"DataRange not found, {importWorker.Name}");
        }

        try
        {
            var dataRangeResponse = _googleSheetValues.Get(sheetId, $"{sheetTabName}!{dataRange}").Execute();
            var data = dataRangeResponse.Values;

            var isUpToDate = true;

            for (var i = 0; i < data[1].Count; i++)
            {
                if (data[0][i].ToString() == "") continue;
                var record = newestLayer.Records!.FirstOrDefault(x => x.Code == data[0][i].ToString());
                if (record == null)
                {
                    _logger.LogDebug("IsImportedLayerUpToDate: Code {Code} not found in DiunaBI for layer {LayerName}",
                        data[0][i].ToString(), importWorker.Name);
                    isUpToDate = false;
                    continue;
                }

                if (!double.TryParse(data[1][i].ToString(), CultureInfo.GetCultureInfo("pl-PL"), out var value) ||
                    double.Abs((double)(record.Value1 - value)!) < 0.01) continue;
                isUpToDate = false;
            }

            foreach (var record in newestLayer.Records!)
            {
                if (data[0].Contains(record.Code))
                {
                    continue;
                }

                _logger.LogDebug("IsImportedLayerUpToDate: Code {Code} not found in GoogleSheet for layer {LayerName}",
                    record.Code, importWorker.Name);
                isUpToDate = false;
            }

            _logger.LogDebug("IsImportedLayerUpToDate: Layer {LayerName} is {Status}",
                importWorker.Name, isUpToDate ? "up to date" : "outdated");

            return isUpToDate;
        }
        catch (Exception e)
        {
            _logger.LogError(e, "IsImportedLayerUpToDate: Error checking if layer {LayerName} is up to date", importWorker.Name);
            throw;
        }
    }

    // Record CRUD operations
    [HttpPost]
    [Route("{layerId:guid}/records")]
    public IActionResult CreateRecord(Guid layerId, [FromBody] RecordDto recordDto)
    {
        try
        {
            var userId = Request.Headers["UserId"].ToString();
            if (string.IsNullOrEmpty(userId))
            {
                _logger.LogWarning("CreateRecord: No UserId in request headers");
                return Unauthorized();
            }

            var layer = _db.Layers.FirstOrDefault(x => x.Id == layerId && !x.IsDeleted);
            if (layer == null)
            {
                _logger.LogWarning("CreateRecord: Layer {LayerId} not found", layerId);
                return NotFound("Layer not found");
            }

            if (layer.Type != Domain.Entities.LayerType.Dictionary && layer.Type != Domain.Entities.LayerType.Administration)
            {
                _logger.LogWarning("CreateRecord: Layer {LayerId} is not editable (type: {LayerType})", layerId, layer.Type);
                return BadRequest("Only Dictionary and Administration layers can be edited");
            }

            if (string.IsNullOrWhiteSpace(recordDto.Code))
            {
                return BadRequest("Code is required");
            }

            if (string.IsNullOrWhiteSpace(recordDto.Desc1))
            {
                return BadRequest("Desc1 is required");
            }

            var record = new Record
            {
                Id = Guid.NewGuid(),
                Code = recordDto.Code,
                Desc1 = recordDto.Desc1,
                LayerId = layerId,
                CreatedAt = DateTime.UtcNow,
                ModifiedAt = DateTime.UtcNow,
                CreatedById = Guid.Parse(userId),
                ModifiedById = Guid.Parse(userId),
                IsDeleted = false
            };

            _db.Records.Add(record);

            // Capture history
            CaptureRecordHistory(record, RecordChangeType.Created, Guid.Parse(userId));

            // Update layer modified info
            layer.ModifiedAt = DateTime.UtcNow;
            layer.ModifiedById = Guid.Parse(userId);

            _db.SaveChanges();

            _logger.LogInformation("CreateRecord: Created record {RecordId} in layer {LayerId}", record.Id, layerId);

            return Ok(new RecordDto
            {
                Id = record.Id,
                Code = record.Code,
                Desc1 = record.Desc1,
                LayerId = record.LayerId,
                CreatedAt = record.CreatedAt,
                ModifiedAt = record.ModifiedAt,
                CreatedById = record.CreatedById,
                ModifiedById = record.ModifiedById
            });
        }
        catch (Exception e)
        {
            _logger.LogError(e, "CreateRecord: Error creating record in layer {LayerId}", layerId);
            return BadRequest("An error occurred processing your request");
        }
    }

    [HttpPut]
    [Route("{layerId:guid}/records/{recordId:guid}")]
    public IActionResult UpdateRecord(Guid layerId, Guid recordId, [FromBody] RecordDto recordDto)
    {
        try
        {
            var userId = Request.Headers["UserId"].ToString();
            if (string.IsNullOrEmpty(userId))
            {
                _logger.LogWarning("UpdateRecord: No UserId in request headers");
                return Unauthorized();
            }

            var layer = _db.Layers.FirstOrDefault(x => x.Id == layerId && !x.IsDeleted);
            if (layer == null)
            {
                _logger.LogWarning("UpdateRecord: Layer {LayerId} not found", layerId);
                return NotFound("Layer not found");
            }

            if (layer.Type != Domain.Entities.LayerType.Dictionary && layer.Type != Domain.Entities.LayerType.Administration)
            {
                _logger.LogWarning("UpdateRecord: Layer {LayerId} is not editable (type: {LayerType})", layerId, layer.Type);
                return BadRequest("Only Dictionary and Administration layers can be edited");
            }

            var record = _db.Records.FirstOrDefault(x => x.Id == recordId && x.LayerId == layerId);
            if (record == null)
            {
                _logger.LogWarning("UpdateRecord: Record {RecordId} not found in layer {LayerId}", recordId, layerId);
                return NotFound("Record not found");
            }

            if (string.IsNullOrWhiteSpace(recordDto.Code))
            {
                return BadRequest("Code is required");
            }

            if (string.IsNullOrWhiteSpace(recordDto.Desc1))
            {
                return BadRequest("Desc1 is required");
            }

            // Capture old values before updating
            var oldCode = record.Code;
            var oldDesc1 = record.Desc1;

            record.Desc1 = recordDto.Desc1;
            record.ModifiedAt = DateTime.UtcNow;
            record.ModifiedById = Guid.Parse(userId);

            // Capture history
            CaptureRecordHistory(record, RecordChangeType.Updated, Guid.Parse(userId), oldCode, oldDesc1);

            // Update layer modified info
            layer.ModifiedAt = DateTime.UtcNow;
            layer.ModifiedById = Guid.Parse(userId);

            _db.SaveChanges();

            _logger.LogInformation("UpdateRecord: Updated record {RecordId} in layer {LayerId}", recordId, layerId);

            return Ok(new RecordDto
            {
                Id = record.Id,
                Code = record.Code,
                Desc1 = record.Desc1,
                LayerId = record.LayerId,
                CreatedAt = record.CreatedAt,
                ModifiedAt = record.ModifiedAt,
                CreatedById = record.CreatedById,
                ModifiedById = record.ModifiedById
            });
        }
        catch (Exception e)
        {
            _logger.LogError(e, "UpdateRecord: Error updating record {RecordId} in layer {LayerId}", recordId, layerId);
            return BadRequest("An error occurred processing your request");
        }
    }

    [HttpDelete]
    [Route("{layerId:guid}/records/{recordId:guid}")]
    public IActionResult DeleteRecord(Guid layerId, Guid recordId)
    {
        try
        {
            var userId = Request.Headers["UserId"].ToString();
            if (string.IsNullOrEmpty(userId))
            {
                _logger.LogWarning("DeleteRecord: No UserId in request headers");
                return Unauthorized();
            }

            var layer = _db.Layers.FirstOrDefault(x => x.Id == layerId && !x.IsDeleted);
            if (layer == null)
            {
                _logger.LogWarning("DeleteRecord: Layer {LayerId} not found", layerId);
                return NotFound("Layer not found");
            }

            if (layer.Type != Domain.Entities.LayerType.Dictionary && layer.Type != Domain.Entities.LayerType.Administration)
            {
                _logger.LogWarning("DeleteRecord: Layer {LayerId} is not editable (type: {LayerType})", layerId, layer.Type);
                return BadRequest("Only Dictionary and Administration layers can be edited");
            }

            var record = _db.Records.FirstOrDefault(x => x.Id == recordId && x.LayerId == layerId);
            if (record == null)
            {
                _logger.LogWarning("DeleteRecord: Record {RecordId} not found in layer {LayerId}", recordId, layerId);
                return NotFound("Record not found");
            }

            // Capture history before deleting
            CaptureRecordHistory(record, RecordChangeType.Deleted, Guid.Parse(userId));

            _db.Records.Remove(record);

            // Update layer modified info
            layer.ModifiedAt = DateTime.UtcNow;
            layer.ModifiedById = Guid.Parse(userId);

            _db.SaveChanges();

            _logger.LogInformation("DeleteRecord: Deleted record {RecordId} from layer {LayerId}", recordId, layerId);

            return Ok();
        }
        catch (Exception e)
        {
            _logger.LogError(e, "DeleteRecord: Error deleting record {RecordId} from layer {LayerId}", recordId, layerId);
            return BadRequest("An error occurred processing your request");
        }
    }

    [HttpGet]
    [Route("{layerId:guid}/records/{recordId:guid}/history")]
    public IActionResult GetRecordHistory(Guid layerId, Guid recordId)
    {
        try
        {
            var history = _db.RecordHistory
                .Include(h => h.ChangedBy)
                .Where(h => h.RecordId == recordId && h.LayerId == layerId)
                .OrderByDescending(h => h.ChangedAt)
                .AsNoTracking()
                .Select(h => new RecordHistoryDto
                {
                    Id = h.Id,
                    RecordId = h.RecordId,
                    LayerId = h.LayerId,
                    ChangedAt = h.ChangedAt,
                    ChangedById = h.ChangedById,
                    ChangedByName = h.ChangedBy != null ? h.ChangedBy.UserName ?? h.ChangedBy.Email : "Unknown",
                    ChangeType = h.ChangeType.ToString(),
                    Code = h.Code,
                    Desc1 = h.Desc1,
                    ChangedFields = h.ChangedFields,
                    ChangesSummary = h.ChangesSummary,
                    FormattedChange = FormatHistoryChange(h)
                })
                .ToList();

            _logger.LogDebug("GetRecordHistory: Retrieved {Count} history entries for record {RecordId}", history.Count, recordId);

            return Ok(history);
        }
        catch (Exception e)
        {
            _logger.LogError(e, "GetRecordHistory: Error retrieving history for record {RecordId}", recordId);
            return BadRequest("An error occurred processing your request");
        }
    }

    [HttpGet]
    [Route("{layerId:guid}/records/deleted")]
    public IActionResult GetDeletedRecords(Guid layerId)
    {
        try
        {
            // Get the most recent "Deleted" history entry for each unique RecordId in this layer
            // First, get all deleted record history entries
            var deletedHistoryEntries = _db.RecordHistory
                .Where(h => h.LayerId == layerId && h.ChangeType == RecordChangeType.Deleted)
                .ToList();

            // Group in memory and get the most recent deletion for each record
            var mostRecentDeletes = deletedHistoryEntries
                .GroupBy(h => h.RecordId)
                .Select(g => g.OrderByDescending(h => h.ChangedAt).First())
                .ToList();

            // Get all unique user IDs from the history entries
            var userIds = mostRecentDeletes.Select(h => h.ChangedById).Distinct().ToList();

            // Load the users
            var users = _db.Users
                .Where(u => userIds.Contains(u.Id))
                .ToDictionary(u => u.Id, u => u.UserName ?? string.Empty);

            // Build the DTOs
            var deletedRecords = mostRecentDeletes
                .Select(h => new DeletedRecordDto
                {
                    RecordId = h.RecordId,
                    Code = h.Code,
                    Desc1 = h.Desc1,
                    DeletedAt = h.ChangedAt,
                    DeletedById = h.ChangedById,
                    DeletedByName = users.TryGetValue(h.ChangedById, out var userName) ? userName : string.Empty
                })
                .OrderByDescending(d => d.DeletedAt)
                .ToList();

            _logger.LogDebug("GetDeletedRecords: Retrieved {Count} deleted records for layer {LayerId}", deletedRecords.Count, layerId);
            return Ok(deletedRecords);
        }
        catch (Exception e)
        {
            _logger.LogError(e, "GetDeletedRecords: Error retrieving deleted records for layer {LayerId}", layerId);
            return BadRequest("An error occurred processing your request");
        }
    }

    // Helper method to capture record history
    private void CaptureRecordHistory(Record record, RecordChangeType changeType, Guid userId, string? oldCode = null, string? oldDesc1 = null)
    {
        var changedFields = new List<string>();
        var changesSummary = new Dictionary<string, Dictionary<string, string?>>();

        if (changeType == RecordChangeType.Updated)
        {
            if (oldCode != record.Code)
            {
                changedFields.Add("Code");
                changesSummary["Code"] = new Dictionary<string, string?>
                {
                    ["old"] = oldCode,
                    ["new"] = record.Code
                };
            }

            if (oldDesc1 != record.Desc1)
            {
                changedFields.Add("Desc1");
                changesSummary["Desc1"] = new Dictionary<string, string?>
                {
                    ["old"] = oldDesc1,
                    ["new"] = record.Desc1
                };
            }
        }

        var history = new RecordHistory
        {
            Id = Guid.NewGuid(),
            RecordId = record.Id,
            LayerId = record.LayerId,
            ChangedAt = DateTime.UtcNow,
            ChangedById = userId,
            ChangeType = changeType,
            Code = record.Code,
            Desc1 = record.Desc1,
            ChangedFields = changedFields.Any() ? string.Join(", ", changedFields) : null,
            ChangesSummary = changesSummary.Any() ? JsonSerializer.Serialize(changesSummary) : null
        };

        _db.RecordHistory.Add(history);
        _logger.LogInformation("CaptureRecordHistory: Captured {ChangeType} for record {RecordId}", changeType, record.Id);
    }

    // Helper method to format history change for display
    private static string FormatHistoryChange(RecordHistory h)
    {
        if (h.ChangeType == RecordChangeType.Created)
        {
            return $"Created record with Code: \"{h.Code}\", Description: \"{h.Desc1}\"";
        }

        if (h.ChangeType == RecordChangeType.Deleted)
        {
            return $"Deleted record Code: \"{h.Code}\", Description: \"{h.Desc1}\"";
        }

        // Updated
        if (!string.IsNullOrEmpty(h.ChangesSummary))
        {
            try
            {
                var changes = JsonSerializer.Deserialize<Dictionary<string, Dictionary<string, string?>>>(h.ChangesSummary);
                if (changes != null)
                {
                    var parts = new List<string>();
                    foreach (var (field, values) in changes)
                    {
                        var oldVal = values.GetValueOrDefault("old") ?? "empty";
                        var newVal = values.GetValueOrDefault("new") ?? "empty";
                        parts.Add($"{field}: \"{oldVal}\" → \"{newVal}\"");
                    }
                    return $"Updated: {string.Join(", ", parts)}";
                }
            }
            catch
            {
                // Fall back to simple message
            }
        }

        return $"Updated {h.ChangedFields ?? "record"}";
    }
}