using BMA.EHR.Domain.Common;
using BMA.EHR.Domain.Shared;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Configuration;
using Nest;
using Newtonsoft.Json;
using System.Diagnostics;
using System.Net;
using System.Net.Http.Headers;
using System.Security.Claims;
using System.Text.Encodings.Web;
using System.Text.Json;
using JsonSerializer = System.Text.Json.JsonSerializer;

namespace BMA.EHR.Domain.Middlewares
{
    public class CombinedErrorHandlerAndLoggingMiddleware
    {
        private readonly RequestDelegate _next;
        private readonly IConfiguration _configuration;
        private static ElasticClient? _elasticClient;
        private static readonly object _lock = new object();
        private static readonly Dictionary<string, (GetProfileByKeycloakIdLocal Profile, DateTime ExpiryTime)> _profileCache = new();
        private static readonly TimeSpan _cacheExpiry = TimeSpan.FromMinutes(10);

        private string Uri = "";
        private string IndexFormat = "";
        private string SystemName = "";

        public CombinedErrorHandlerAndLoggingMiddleware(RequestDelegate next, IConfiguration configuration)
        {
            _next = next;
            _configuration = configuration;

            Uri = _configuration["ElasticConfiguration:Uri"] ?? "http://192.168.1.40:9200";
            IndexFormat = _configuration["ElasticConfiguration:IndexFormat"] ?? "bma-ehr-log-index";
            SystemName = _configuration["ElasticConfiguration:SystemName"] ?? "Unknown";

            // สร้าง ElasticClient แค่ครั้งเดียว
            if (_elasticClient == null)
            {
                lock (_lock)
                {
                    if (_elasticClient == null)
                    {
                        var settings = new ConnectionSettings(new Uri(Uri))
                            .DefaultIndex(IndexFormat)
                            .DisableDirectStreaming() // เพิ่มประสิทธิภาพ
                            .RequestTimeout(TimeSpan.FromSeconds(5)); // กำหนด timeout
                        _elasticClient = new ElasticClient(settings);
                    }
                }
            }
        }

        public async Task Invoke(HttpContext context)
        {
            var startTime = DateTime.UtcNow;
            var stopwatch = Stopwatch.StartNew();
            string? requestBodyJson = null;
            Exception? caughtException = null;

            // อ่าน Request Body
            string requestBody = await ReadRequestBodyAsync(context);
            if (!string.IsNullOrEmpty(requestBody))
            {
                requestBodyJson = await FormatRequestBody(context, requestBody);
            }

            var originalBodyStream = context.Response.Body;

            using (var memoryStream = new MemoryStream())
            {
                // เปลี่ยน stream ของ Response เพื่อให้สามารถอ่านได้
                context.Response.Body = memoryStream;

                string keycloakId = Guid.Empty.ToString("D");
                var token = context.Request.Headers["Authorization"];
                GetProfileByKeycloakIdLocal? pf = null;
                var tokenUserInfo = await ExtractTokenUserInfoAsync(token);

                // Store tokenUserInfo in HttpContext.Items for controllers to use
                context.Items["TokenUserInfo"] = tokenUserInfo;

                // ดึง keycloakId จาก JWT token
                keycloakId = tokenUserInfo.KeycloakId;

                // ดึง profile จาก claims หรือ cache หรือ API
                if (Guid.TryParse(keycloakId, out var parsedId) && parsedId != Guid.Empty)
                {
                    // Build profile from token claims if available
                    if (tokenUserInfo.OrgRootDnaId.HasValue && tokenUserInfo.ProfileId.HasValue)
                    {
                        pf = new GetProfileByKeycloakIdLocal
                        {
                            Id = tokenUserInfo.ProfileId.Value,
                            CitizenId = tokenUserInfo.PreferredUsername,
                            Prefix = tokenUserInfo.Prefix,
                            FirstName = tokenUserInfo.GivenName,
                            LastName = tokenUserInfo.FamilyName,
                            RootDnaId = tokenUserInfo.OrgRootDnaId,
                            Child1DnaId = tokenUserInfo.OrgChild1DnaId,
                            Child2DnaId = tokenUserInfo.OrgChild2DnaId,
                            Child3DnaId = tokenUserInfo.OrgChild3DnaId,
                            Child4DnaId = tokenUserInfo.OrgChild4DnaId,
                        };
                        Console.WriteLine($"[INFO] Using claims for profile - OrgRootDnaId: {pf.RootDnaId}, ProfileId: {pf.Id}");
                    }
                    else
                    {
                        // Fallback to API only if critical claims are missing
                        Console.WriteLine("[WARN] Critical claims missing, falling back to API call");
                        pf = await GetProfileWithCacheAsync(parsedId, token);
                    }
                }

                try
                {
                    await _next(context);
                    Console.WriteLine($"Request completed with status: {context.Response.StatusCode}");

                    // หลังจาก Authentication middleware ทำงานแล้ว ลองดึง claims อีกครั้ง
                    if (context.User?.Identity?.IsAuthenticated == true)
                    {
                        var authenticatedKeycloakId = context.User.FindFirst(ClaimTypes.NameIdentifier)?.Value
                                                   ?? context.User.FindFirst("sub")?.Value;
                        if (!string.IsNullOrEmpty(authenticatedKeycloakId) && authenticatedKeycloakId != keycloakId)
                        {
                            keycloakId = authenticatedKeycloakId;
                            Console.WriteLine($"Updated keycloakId from authenticated user: {keycloakId}");

                            // อัพเดต profile ด้วย keycloakId ที่ถูกต้อง
                            // try
                            // {
                            //     if (Guid.TryParse(keycloakId, out var parsedId))
                            //     {
                            //         //pf = await GetProfileByKeycloakIdAsync(parsedId, token);
                            //     }
                            // }
                            // catch (Exception ex)
                            // {
                            //     Console.WriteLine($"Error updating profile after authentication: {ex.Message}");
                            // }
                        }
                    }

                    // จัดการ response format หลังจาก request ผ่าน pipeline แล้ว
                    await FormatResponse(context, memoryStream);
                }
                catch (ObjectDisposedException)
                {
                    Console.WriteLine("ObjectDisposedException caught in main Invoke");
                    caughtException = new ObjectDisposedException("Response");
                    return;
                }
                catch (OperationCanceledException)
                {
                    Console.WriteLine("OperationCanceledException caught in main Invoke");
                    caughtException = new OperationCanceledException("Operation was cancelled");
                    return;
                }
                catch (Exception error)
                {
                    Console.WriteLine($"Exception caught in main Invoke: {error.Message}");
                    caughtException = error;
                    // จัดการ exception และ format เป็น response
                    await FormatExceptionResponse(context, error, memoryStream);
                }
                finally
                {
                    stopwatch.Stop();
                    
                    // อ่านข้อมูล response ก่อนที่ stream จะถูก dispose
                    string? responseBodyForLogging = null;
                    if (memoryStream.Length > 0)
                    {
                        memoryStream.Seek(0, SeekOrigin.Begin);
                        using var reader = new StreamReader(memoryStream, leaveOpen: true);
                        responseBodyForLogging = await reader.ReadToEndAsync();
                        memoryStream.Seek(0, SeekOrigin.Begin);
                    }
                    
                    // เก็บข้อมูลที่จำเป็นจาก HttpContext ก่อนที่มันจะถูก dispose
                    var logData = new
                    {
                        RemoteIpAddress = context.Connection.RemoteIpAddress?.ToString(),
                        HostValue = context.Request.Host.Value,
                        Method = context.Request.Method,
                        Path = context.Request.Path.ToString(),
                        QueryString = context.Request.QueryString.ToString(),
                        StatusCode = context.Response.StatusCode,
                        ContentType = context.Response.ContentType ?? ""
                    };
                    
                    // เขียนข้อมูลกลับไปยัง original Response body ก่อน
                    if (memoryStream.Length > 0)
                    {
                        memoryStream.Seek(0, SeekOrigin.Begin);
                        await memoryStream.CopyToAsync(originalBodyStream);
                    }

                    // ทำ logging แบบ await
                    Console.WriteLine("[DEBUG] Starting logging...");
                    try 
                    { 
                        await LogRequestAsync(_elasticClient!, startTime, stopwatch, pf, keycloakId, requestBodyJson, responseBodyForLogging, caughtException, logData);
                        Console.WriteLine("[DEBUG] Logging completed successfully");
                    } 
                    catch (Exception ex) 
                    { 
                        Console.WriteLine($"[ERROR] Logging error: {ex.Message}");
                        Console.WriteLine($"[ERROR] Stack trace: {ex.StackTrace}");
                    }
                }
            }

            Console.WriteLine("=== CombinedErrorHandlerAndLoggingMiddleware End ===");
        }

        private async Task<string> FormatRequestBody(HttpContext context, string requestBody)
        {
            try
            {
                if (context.Request.HasFormContentType)
                {
                    var form = await context.Request.ReadFormAsync();
                    var formData = new Dictionary<string, object>();

                    foreach (var field in form)
                    {
                        formData[field.Key] = field.Value.ToString();
                    }

                    if (form.Files.Count > 0)
                    {
                        var fileDataList = new List<object>();
                        foreach (var file in form.Files)
                        {
                            fileDataList.Add(new
                            {
                                FileName = file.FileName,
                                ContentType = file.ContentType,
                                Size = file.Length
                            });
                        }
                        formData["Files"] = fileDataList;
                    }

                    var jsonOptions = new JsonSerializerOptions
                    {
                        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
                        Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
                        WriteIndented = true,
                        Converters = { new DateTimeFixConverter() }
                    };
                    return JsonSerializer.Serialize(formData, jsonOptions);
                }
                else
                {
                    var jsonOptions = new JsonSerializerOptions
                    {
                        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
                        Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
                        WriteIndented = true,
                        Converters = { new DateTimeFixConverter() }
                    };
                    return JsonSerializer.Serialize(JsonSerializer.Deserialize<object>(requestBody), jsonOptions);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error formatting request body: {ex.Message}");
                return requestBody;
            }
        }

        private static async Task FormatResponse(HttpContext context, MemoryStream memoryStream)
        {
            try
            {
                if (context?.Response == null)
                    return;

                var response = context.Response;
                var statusCode = response.StatusCode;


                string? message = null;
                string? responseBodyJson = null;
                if (memoryStream.Length > 0)
                {
                    memoryStream.Seek(0, SeekOrigin.Begin);
                    var responseBody = new StreamReader(memoryStream).ReadToEnd();

                    var jsonOptions = new JsonSerializerOptions
                    {
                        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
                        Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
                        WriteIndented = true,
                        Converters = { new DateTimeFixConverter() }
                    };
                    responseBodyJson =
                        JsonSerializer.Serialize(JsonSerializer.Deserialize<object>(responseBody), jsonOptions);

                    var json = JsonSerializer.Deserialize<JsonElement>(responseBody);
                    if (json.ValueKind == JsonValueKind.Array)
                    {
                        message = "success";
                    }
                    else
                    {
                        if (json.TryGetProperty("message", out var messageElement))
                        {
                            message = messageElement.GetString();
                        }
                    }
                }

                Console.WriteLine($"FormatResponse: StatusCode={statusCode}, HasStarted={response.HasStarted}");

                // จัดการ response format แม้กับ status code จาก Authentication middleware
                if (!response.HasStarted && ShouldFormatResponse(statusCode))
                {
                    Console.WriteLine($"Formatting response for status: {statusCode}");

                    var responseModel = CreateResponseModel(statusCode, message);

                    // Clear memory stream และเขียน response ใหม่
                    memoryStream.SetLength(0);
                    memoryStream.Position = 0;

                    // ไม่เปลี่ยน status code ที่ Authentication middleware ตั้งไว้
                    response.ContentType = "application/json; charset=utf-8";

                    var jsonOptions = new JsonSerializerOptions
                    {
                        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
                        WriteIndented = false
                    };
                    var jsonResponse = JsonSerializer.Serialize(responseModel, jsonOptions);
                    var bytes = System.Text.Encoding.UTF8.GetBytes(jsonResponse);

                    // กำหนด Content-Length ให้ตรงกับขนาดจริง
                    response.ContentLength = bytes.Length;

                    await memoryStream.WriteAsync(bytes, 0, bytes.Length);

                    Console.WriteLine($"Response formatted successfully: {jsonResponse}");
                }
                // หากเป็น 401/403 แต่ยังไม่มี response body ให้สร้างใหม่
                else if (!response.HasStarted && (statusCode == 401 || statusCode == 403) && memoryStream.Length == 0)
                {
                    Console.WriteLine($"Creating response body for {statusCode} status");

                    var responseModel = CreateResponseModel(statusCode, message);
                    response.ContentType = "application/json; charset=utf-8";

                    var jsonOptions = new JsonSerializerOptions
                    {
                        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
                        WriteIndented = false
                    };
                    var jsonResponse = JsonSerializer.Serialize(responseModel, jsonOptions);
                    var bytes = System.Text.Encoding.UTF8.GetBytes(jsonResponse);

                    // กำหนด Content-Length ให้ตรงกับขนาดจริง
                    response.ContentLength = bytes.Length;

                    await memoryStream.WriteAsync(bytes, 0, bytes.Length);

                    Console.WriteLine($"Response body created: {jsonResponse}");
                }
            }
            catch (ObjectDisposedException)
            {
                Console.WriteLine("ObjectDisposedException in FormatResponse");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error in FormatResponse: {ex.Message}");
            }
        }

        private static async Task FormatExceptionResponse(HttpContext context, Exception error, MemoryStream memoryStream)
        {
            try
            {
                Console.WriteLine($"FormatExceptionResponse: Error={error.Message}");

                if (context?.Response == null)
                    return;

                var response = context.Response;
                Console.WriteLine($"Response HasStarted: {response.HasStarted}");

                if (!response.HasStarted)
                {
                    // Clear memory stream และเขียน error response
                    memoryStream.SetLength(0);
                    memoryStream.Position = 0;

                    response.StatusCode = (int)HttpStatusCode.InternalServerError;
                    response.ContentType = "application/json; charset=utf-8";

                    var responseModel = new ResponseObject
                    {
                        Status = response.StatusCode,
                        Message = GetErrorMessage(error),
                        Result = null
                    };

                    var jsonOptions = new JsonSerializerOptions
                    {
                        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
                        WriteIndented = false
                    };
                    var jsonResponse = JsonSerializer.Serialize(responseModel, jsonOptions);
                    var bytes = System.Text.Encoding.UTF8.GetBytes(jsonResponse);

                    // กำหนด Content-Length ให้ตรงกับขนาดจริง
                    response.ContentLength = bytes.Length;


                    await memoryStream.WriteAsync(bytes, 0, bytes.Length);

                    Console.WriteLine($"Exception response formatted: {jsonResponse}");
                }
                else
                {
                    Console.WriteLine("Cannot format exception response - response already started");
                }
            }
            catch (ObjectDisposedException)
            {
                Console.WriteLine("ObjectDisposedException in FormatExceptionResponse");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error in FormatExceptionResponse: {ex.Message}");
            }
        }

        private async Task LogRequestAsync(ElasticClient client, DateTime startTime, Stopwatch stopwatch,
            GetProfileByKeycloakIdLocal? pf, string keycloakId, string? requestBodyJson, string? responseBodyForLogging, Exception? caughtException, dynamic contextData)
        {
            Console.WriteLine("[DEBUG] LogRequestAsync called");
            try
            {
                var processTime = stopwatch.ElapsedMilliseconds;
                var endTime = DateTime.UtcNow;

                var statusCode = caughtException != null ? (int)HttpStatusCode.InternalServerError : (int)contextData.StatusCode;

                var logType = caughtException != null ? "error" : statusCode switch
                {
                    >= 500 => "error",
                    >= 400 => "warning",
                    _ => "info"
                };

                string? message = null;
                string? responseBodyJson = null;

                // ใช้ response body ที่ส่งมาจากการอ่านก่อนหน้า
                if (!string.IsNullOrEmpty(responseBodyForLogging))
                {
                    var contentType = (string)contextData.ContentType;
                    var isFileResponse = !contentType.StartsWith("application/json") && !contentType.StartsWith("text/html") && (
                        contentType.StartsWith("application/") ||
                        contentType.StartsWith("image/") ||
                        contentType.StartsWith("audio/")
                    );

                    if (isFileResponse)
                    {
                        responseBodyJson = "";
                        message = "success";
                    }
                    else
                    {
                        // ใช้ response body ที่มีอยู่แล้วโดยไม่ serialize ซ้ำ
                        responseBodyJson = responseBodyForLogging;
                        
                        try
                        {
                            var json = JsonSerializer.Deserialize<JsonElement>(responseBodyForLogging);
                            if (json.ValueKind == JsonValueKind.Array)
                            {
                                message = "success";
                            }
                            else if (json.TryGetProperty("message", out var messageElement))
                            {
                                message = messageElement.GetString();
                            }
                        }
                        catch
                        {
                            message = caughtException?.Message ?? "Unknown error";
                        }
                    }
                }

                if (caughtException != null)
                {
                    message = caughtException.Message;
                }

                var logData = new
                {
                    logType = logType,
                    ip = (string)contextData.RemoteIpAddress,
                    //rootId = pf?.RootId,
                    rootId = pf?.RootDnaId,
                    systemName = SystemName,
                    startTimeStamp = startTime.ToString("o"),
                    endTimeStamp = endTime.ToString("o"),
                    processTime = processTime,
                    host = (string)contextData.HostValue,
                    method = (string)contextData.Method,
                    endpoint = (string)contextData.Path + (string)contextData.QueryString,
                    responseCode = statusCode == 304 ? "200" : statusCode.ToString(),
                    responseDescription = message,
                    input = requestBodyJson,
                    output = responseBodyJson,
                    userId = keycloakId,
                    userName = $"{pf?.Prefix ?? ""}{pf?.FirstName ?? ""} {pf?.LastName ?? ""}",
                    user = pf?.CitizenId ?? "",
                    exception = caughtException?.ToString()
                };

                Console.WriteLine($"[DEBUG] Sending log to Elasticsearch: {logType} - {(string)contextData.Method} {(string)contextData.Path}");
                var response = await client.IndexDocumentAsync(logData);
                Console.WriteLine($"[DEBUG] Elasticsearch response: IsValid={response.IsValid}, Index={response.Index}");
                
                if (!response.IsValid)
                {
                    Console.WriteLine($"[ERROR] Elasticsearch error: {response.OriginalException?.Message ?? response.ServerError?.ToString()}");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[ERROR] Error logging request: {ex.Message}");
                Console.WriteLine($"[ERROR] Stack trace: {ex.StackTrace}");
            }
        }

        private static bool ShouldFormatResponse(int statusCode)
        {
            return statusCode == (int)HttpStatusCode.Unauthorized ||
                   statusCode == (int)HttpStatusCode.Forbidden ||
                   statusCode == (int)HttpStatusCode.BadRequest ||
                   statusCode == (int)HttpStatusCode.NotFound ||
                   statusCode == (int)HttpStatusCode.Conflict ||
                   statusCode == (int)HttpStatusCode.UnprocessableEntity ||
                   statusCode == (int)HttpStatusCode.InternalServerError;
        }

        private static ResponseObject CreateResponseModel(int statusCode, string? error)
        {
            var message = statusCode switch
            {
                (int)HttpStatusCode.Unauthorized => GlobalMessages.NotAuthorized,
                (int)HttpStatusCode.Forbidden => GlobalMessages.ForbiddenAccess,
                (int)HttpStatusCode.BadRequest => "Bad Request",
                (int)HttpStatusCode.NotFound => "Resource Not Found",
                (int)HttpStatusCode.Conflict => "Conflict",
                (int)HttpStatusCode.UnprocessableEntity => "Validation Error",
                (int)HttpStatusCode.InternalServerError => GlobalMessages.ExceptionOccured,
                _ => "Error"
            };

            return new ResponseObject
            {
                Status = statusCode,
                Message = error ?? message
            };
        }

        private static string GetErrorMessage(Exception error)
        {
            var msg = error.Message;
            var inner = error.InnerException;
            while (inner != null)
            {
                msg += $" {inner.Message}\r\n";
                inner = inner.InnerException;
            }
            return msg;
        }

        private async Task<string> ExtractKeycloakIdFromToken(string? authorizationHeader)
        {
            var tokenInfo = await ExtractTokenUserInfoAsync(authorizationHeader);
            return tokenInfo.KeycloakId;
        }

        private async Task<TokenUserInfo> ExtractTokenUserInfoAsync(string? authorizationHeader)
        {
            var defaultResult = new TokenUserInfo { KeycloakId = Guid.Empty.ToString("D") };
            
            try
            {
                if (string.IsNullOrEmpty(authorizationHeader) || !authorizationHeader.StartsWith("Bearer "))
                {
                    return defaultResult;
                }

                var token = authorizationHeader.Replace("Bearer ", "");

                // แยก JWT token เพื่อดึง payload (แบบง่าย โดยไม่ verify signature)
                var parts = token.Split('.');
                if (parts.Length != 3)
                {
                    return defaultResult;
                }

                // Decode Base64Url payload (JWT uses Base64Url encoding, not standard Base64)
                var payload = parts[1];

                // แปลง Base64Url เป็น Base64 ก่อน
                payload = payload.Replace('-', '+').Replace('_', '/');

                // เพิ่ม padding ถ้าจำเป็น
                var padLength = 4 - (payload.Length % 4);
                if (padLength < 4)
                {
                    payload += new string('=', padLength);
                }

                var payloadBytes = Convert.FromBase64String(payload);
                var payloadJson = System.Text.Encoding.UTF8.GetString(payloadBytes);

                Console.WriteLine($"JWT Payload: {payloadJson}");

                // Parse JSON และดึง claims ต่างๆ
                var jsonDoc = JsonDocument.Parse(payloadJson);
                var result = new TokenUserInfo();

                // ดึง keycloak ID
                if (jsonDoc.RootElement.TryGetProperty("sub", out var subElement))
                {
                    result.KeycloakId = subElement.GetString() ?? Guid.Empty.ToString("D");
                }
                else if (jsonDoc.RootElement.TryGetProperty("nameid", out var nameidElement))
                {
                    result.KeycloakId = nameidElement.GetString() ?? Guid.Empty.ToString("D");
                }
                else if (jsonDoc.RootElement.TryGetProperty("user_id", out var userIdElement))
                {
                    result.KeycloakId = userIdElement.GetString() ?? Guid.Empty.ToString("D");
                }
                else
                {
                    result.KeycloakId = Guid.Empty.ToString("D");
                }

                // ดึง preferred_username
                if (jsonDoc.RootElement.TryGetProperty("preferred_username", out var preferredUsernameElement))
                {
                    result.PreferredUsername = preferredUsernameElement.GetString();
                    Console.WriteLine($"Extracted preferred_username: {result.PreferredUsername}");
                }

                // ดึง given_name
                if (jsonDoc.RootElement.TryGetProperty("given_name", out var givenNameElement))
                {
                    result.GivenName = givenNameElement.GetString();
                    Console.WriteLine($"Extracted given_name: {result.GivenName}");
                }

                // ดึง family_name
                if (jsonDoc.RootElement.TryGetProperty("family_name", out var familyNameElement))
                {
                    result.FamilyName = familyNameElement.GetString();
                    Console.WriteLine($"Extracted family_name: {result.FamilyName}");
                }

                // ดึง empType
                if (jsonDoc.RootElement.TryGetProperty("empType", out var empTypeElement))
                {
                    result.EmpType = empTypeElement.GetString();
                    Console.WriteLine($"Extracted empType: {result.EmpType}");
                }

                // ดึง orgChild1DnaId
                if (jsonDoc.RootElement.TryGetProperty("orgChild1DnaId", out var orgChild1Element))
                {
                    if (Guid.TryParse(orgChild1Element.GetString(), out var orgChild1Guid))
                    {
                        result.OrgChild1DnaId = orgChild1Guid;
                        Console.WriteLine($"Extracted orgChild1DnaId: {result.OrgChild1DnaId}");
                    }
                }

                // ดึง orgChild2DnaId
                if (jsonDoc.RootElement.TryGetProperty("orgChild2DnaId", out var orgChild2Element))
                {
                    if (Guid.TryParse(orgChild2Element.GetString(), out var orgChild2Guid))
                    {
                        result.OrgChild2DnaId = orgChild2Guid;
                        Console.WriteLine($"Extracted orgChild2DnaId: {result.OrgChild2DnaId}");
                    }
                }

                // ดึง orgChild3DnaId
                if (jsonDoc.RootElement.TryGetProperty("orgChild3DnaId", out var orgChild3Element))
                {
                    if (Guid.TryParse(orgChild3Element.GetString(), out var orgChild3Guid))
                    {
                        result.OrgChild3DnaId = orgChild3Guid;
                        Console.WriteLine($"Extracted orgChild3DnaId: {result.OrgChild3DnaId}");
                    }
                }

                // ดึง orgChild4DnaId
                if (jsonDoc.RootElement.TryGetProperty("orgChild4DnaId", out var orgChild4Element))
                {
                    if (Guid.TryParse(orgChild4Element.GetString(), out var orgChild4Guid))
                    {
                        result.OrgChild4DnaId = orgChild4Guid;
                        Console.WriteLine($"Extracted orgChild4DnaId: {result.OrgChild4DnaId}");
                    }
                }

                // ดึง orgRootDnaId
                if (jsonDoc.RootElement.TryGetProperty("orgRootDnaId", out var orgRootElement))
                {
                    if (Guid.TryParse(orgRootElement.GetString(), out var orgRootGuid))
                    {
                        result.OrgRootDnaId = orgRootGuid;
                        Console.WriteLine($"Extracted orgRootDnaId: {result.OrgRootDnaId}");
                    }
                }

                // ดึง profileId
                if (jsonDoc.RootElement.TryGetProperty("profileId", out var profileIdElement))
                {
                    if (Guid.TryParse(profileIdElement.GetString(), out var profileIdGuid))
                    {
                        result.ProfileId = profileIdGuid;
                        Console.WriteLine($"Extracted profileId: {result.ProfileId}");
                    }
                }

                // ดึง prefix
                if (jsonDoc.RootElement.TryGetProperty("prefix", out var prefixElement))
                {
                    result.Prefix = prefixElement.GetString();
                    Console.WriteLine($"Extracted prefix: {result.Prefix}");
                }

                // ดึง name
                if (jsonDoc.RootElement.TryGetProperty("name", out var nameElement))
                {
                    result.Name = nameElement.GetString();
                    Console.WriteLine($"Extracted name: {result.Name}");
                }

                return result;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error extracting token user info: {ex.Message}");
                return defaultResult;
            }
        }

        protected async Task<string> GetExternalAPIAsync(string apiPath, string accessToken, string apiKey)
        {
            try
            {
                using (var client = new HttpClient())
                {
                    client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken.Replace("Bearer ", ""));
                    client.DefaultRequestHeaders.Add("api-key", apiKey);
                    var _res = await client.GetAsync(apiPath);
                    if (_res.IsSuccessStatusCode)
                    {
                        var _result = await _res.Content.ReadAsStringAsync();
                        return _result;
                    }
                    return string.Empty;
                }
            }
            catch
            {
                throw;
            }
        }

        public async Task<GetProfileByKeycloakIdLocal?> GetProfileByKeycloakIdAsync(Guid keycloakId, string? accessToken)
        {
            try
            {
                //var apiPath = $"{_configuration["API"]}/org/dotnet/by-keycloak/{keycloakId}";
                var apiPath = $"{_configuration["API"]}/org/dotnet/user-logs/{keycloakId}";
                var apiKey = _configuration["API_KEY"];

                var apiResult = await GetExternalAPIAsync(apiPath, accessToken ?? "", apiKey);
                if (apiResult != null)
                {
                    var raw = JsonConvert.DeserializeObject<GetProfileByKeycloakIdResultLocal>(apiResult);
                    if (raw != null)
                        return raw.Result;
                }

                return null;
            }
            catch
            {
                return null;
            }
        }

        private async Task<GetProfileByKeycloakIdLocal?> GetProfileWithCacheAsync(Guid keycloakId, string? accessToken)
        {
            var cacheKey = keycloakId.ToString();
            
            // ตรวจสอบ cache
            lock (_profileCache)
            {
                if (_profileCache.TryGetValue(cacheKey, out var cached))
                {
                    if (cached.ExpiryTime > DateTime.UtcNow)
                    {
                        return cached.Profile;
                    }
                    // ลบ cache ที่หมดอายุ
                    _profileCache.Remove(cacheKey);
                }
            }

            // ดึงข้อมูลจาก API
            try
            {
                var profile = await GetProfileByKeycloakIdAsync(keycloakId, accessToken);
                if (profile != null)
                {
                    // เก็บใน cache
                    lock (_profileCache)
                    {
                        _profileCache[cacheKey] = (profile, DateTime.UtcNow.Add(_cacheExpiry));
                        
                        // ลบ cache เก่าที่เกิน 1000 รายการ
                        if (_profileCache.Count > 1000)
                        {
                            var expiredKeys = _profileCache
                                .Where(x => x.Value.ExpiryTime < DateTime.UtcNow)
                                .Select(x => x.Key)
                                .ToList();
                            foreach (var key in expiredKeys)
                            {
                                _profileCache.Remove(key);
                            }
                        }
                    }
                }
                return profile;
            }
            catch
            {
                return null;
            }
        }

        private async Task<string> ReadRequestBodyAsync(HttpContext context)
        {
            context.Request.EnableBuffering();
            using var reader = new StreamReader(context.Request.Body, leaveOpen: true);
            var body = await reader.ReadToEndAsync();
            context.Request.Body.Position = 0;
            return body;
        }
    }

    // Model classes
    public class GetProfileByKeycloakIdLocal
    {
        public Guid Id { get; set; }
        public string? Prefix { get; set; }
        public string? FirstName { get; set; }
        public string? LastName { get; set; }
        public string? CitizenId { get; set; }
        public string? Root { get; set; }
        public string? Child1 { get; set; }
        public string? Child2 { get; set; }
        public string? Child3 { get; set; }
        public string? Child4 { get; set; }
        public Guid? RootId { get; set; }
        public Guid? Child1Id { get; set; }
        public Guid? Child2Id { get; set; }
        public Guid? Child3Id { get; set; }
        public Guid? Child4Id { get; set; }
        public Guid? RootDnaId { get; set; }
        public Guid? Child1DnaId { get; set; }
        public Guid? Child2DnaId { get; set; }
        public Guid? Child3DnaId { get; set; }
        public Guid? Child4DnaId { get; set; }
        public double? Amount { get; set; }
        public double? PositionSalaryAmount { get; set; }
        public string? Commander { get; set; }
        public Guid? CommanderId { get; set; }
        public Guid? CommanderKeycloak { get; set; }
    }

    public class GetProfileByKeycloakIdResultLocal
    {
        public string Message { get; set; } = string.Empty;
        public int Status { get; set; } = -1;
        public GetProfileByKeycloakIdLocal? Result { get; set; }
    }

}