package handlers

import (
	"api-service/internal/config"
	"api-service/internal/database"
	models "api-service/internal/models"
	pasienModels "api-service/internal/models/pasien"
	queryUtils "api-service/internal/utils/query"
	"api-service/internal/utils/validation"
	"api-service/pkg/logger"
	"context"
	"database/sql"
	"fmt"
	"net/http"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10"
	"github.com/jmoiron/sqlx"
	"github.com/lib/pq"
)

// =============================================================================
// GLOBAL INITIALIZATION & VALIDATION
// =============================================================================

var (
	db       database.Service
	once     sync.Once
	validate *validator.Validate
)

// Initialize the database connection and validator once
func init() {
	once.Do(func() {
		db = database.New(config.LoadConfig())
		validate = validator.New()
		validate.RegisterValidation("pasien_status", validatePasienStatus)
		if db == nil {
			logger.Fatal("Failed to initialize database connection")
		}
	})
}

// Custom validation for pasien status
func validatePasienStatus(fl validator.FieldLevel) bool {
	return models.IsValidStatus(fl.Field().String())
}

// =============================================================================
// CACHE IMPLEMENTATION
// =============================================================================

// CacheEntry represents an entry in the cache
type CacheEntry struct {
	Data      interface{}
	ExpiresAt time.Time
}

// IsExpired checks if the cache entry has expired
func (e *CacheEntry) IsExpired() bool {
	return time.Now().After(e.ExpiresAt)
}

// InMemoryCache implements a simple in-memory cache with TTL
type InMemoryCache struct {
	items sync.Map
	mu    sync.RWMutex
}

// NewInMemoryCache creates a new in-memory cache
func NewInMemoryCache() *InMemoryCache {
	return &InMemoryCache{}
}

// Get retrieves an item from the cache
func (c *InMemoryCache) Get(key string) (interface{}, bool) {
	val, ok := c.items.Load(key)
	if !ok {
		return nil, false
	}

	entry, ok := val.(*CacheEntry)
	if !ok || entry.IsExpired() {
		c.items.Delete(key)
		return nil, false
	}

	return entry.Data, true
}

// Set stores an item in the cache with a TTL
func (c *InMemoryCache) Set(key string, value interface{}, ttl time.Duration) {
	entry := &CacheEntry{
		Data:      value,
		ExpiresAt: time.Now().Add(ttl),
	}
	c.items.Store(key, entry)
}

// Delete removes an item from the cache
func (c *InMemoryCache) Delete(key string) {
	c.items.Delete(key)
}

// DeleteByPrefix removes all items with a specific prefix
func (c *InMemoryCache) DeleteByPrefix(prefix string) {
	c.items.Range(func(key, value interface{}) bool {
		if keyStr, ok := key.(string); ok && strings.HasPrefix(keyStr, prefix) {
			c.items.Delete(key)
		}
		return true
	})
}

// =============================================================================
// Pasien HANDLER STRUCT
// =============================================================================

// PasienHandler handles pasien services
type PasienHandler struct {
	db           database.Service
	queryBuilder *queryUtils.QueryBuilder
	validator    *validation.DynamicValidator
	cache        *InMemoryCache
}

// NewPasienHandler creates a new PasienHandler with a pre-configured QueryBuilder
func NewPasienHandler() *PasienHandler {
	// Initialize QueryBuilder with allowed columns list for security.
	queryBuilder := queryUtils.NewQueryBuilder(queryUtils.DBTypePostgreSQL).
		SetAllowedColumns([]string{
			"id",
			"nomr",
			"status",
			"title",
			"nama",
			"tempat",
			"tgllahir",
			"jeniskelamin",
			"alamat",
			"kelurahan",
			"kdkecamatan",
			"kota",
			"kdprovinsi",
			"agama",
			"no_kartu",
			"noktp_baru",
			"created_at",
			"updated_at",
			"idprovinsi",
			"namaprovinsi",
			"idkota",
			"namakota",
			"idkecamatan",
			"namakecamatan",
			"idkelurahan",
			"namakelurahan",
		})

	return &PasienHandler{
		db:           db,
		queryBuilder: queryBuilder,
		validator:    validation.NewDynamicValidator(queryBuilder),
		cache:        NewInMemoryCache(),
	}
}

// =============================================================================
// HANDLER ENDPOINTS
// =============================================================================

// GetPasienByAge godoc
// @Summary Get Pasien by Age Group
// @Description Get pasien statistics by age group
// @Tags Pasien
// @Accept json
// @Produce json
// @Param age_group query string false "Age group (child, teen, adult, senior)"
// @Success 200 {object} pasienModels.PasienAgeStatsResponse "Statistics data"
// @Failure 400 {object} models.ErrorResponse "Bad request"
// @Failure 500 {object} models.ErrorResponse "Internal server error"
// @Router /api/v1/pasien/by-age [get]
func (h *PasienHandler) GetPasienByAge(c *gin.Context) {
	// Parse age group
	ageGroup := c.Query("age_group")
	validAgeGroups := map[string]bool{
		"child":  true, // 0-12 years
		"teen":   true, // 13-17 years
		"adult":  true, // 18-59 years
		"senior": true, // 60+ years
	}

	if ageGroup == "" || !validAgeGroups[ageGroup] {
		h.respondError(c, "Invalid age group", fmt.Errorf("age group must be one of: child, teen, adult, senior"), http.StatusBadRequest)
		return
	}

	// Use GetSQLXDB to get database connection
	dbConn, err := h.db.GetSQLXDB("postgres_simrs")
	if err != nil {
		h.logAndRespondError(c, "Database connection failed", err, http.StatusInternalServerError)
		return
	}
	ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
	defer cancel()

	// Build query
	query := queryUtils.DynamicQuery{
		From: "m_pasien",
		Fields: []queryUtils.SelectField{
			{Expression: "COUNT(*)", Alias: "count"},
		},
		Filters: []queryUtils.FilterGroup{{
			Filters: []queryUtils.DynamicFilter{
				{Column: "status", Operator: queryUtils.OpNotEqual, Value: "deleted"},
			},
			LogicOp: "AND",
		}},
	}

	// Execute query
	var result struct {
		Count int `db:"count"`
	}
	err = h.queryBuilder.ExecuteQueryRow(ctx, dbConn, query, &result)
	if err != nil {
		h.logAndRespondError(c, "Failed to get age statistics", err, http.StatusInternalServerError)
		return
	}

	// Build response
	response := pasienModels.PasienAgeStatsResponse{
		Message: fmt.Sprintf("Age group '%s' statistics retrieved successfully", ageGroup),
		Data: map[string]interface{}{
			"age_group": ageGroup,
			"count":     result.Count,
		},
	}
	c.JSON(http.StatusOK, response)
}

// GetPasienDynamic godoc
// @Summary Get Pasien Dynamic
// @Description Get pasien with dynamic filtering
// @Tags Pasien
// @Accept json
// @Produce json
// @Param fields query string false "Fields to select (e.g., fields=*.*)"
// @Param filter[column][operator] query string false "Dynamic filters (e.g., filter[name][_eq]=value)"
// @Param sort query string false "Sort fields (e.g., sort=date_created,-name)"
// @Param limit query int false "Limit" default(10)
// @Param offset query int false "Offset" default(0)
// @Success 200 {object} pasienModels.PasienGetResponse "Success response"
// @Failure 400 {object} models.ErrorResponse "Bad request"
// @Failure 500 {object} models.ErrorResponse "Internal server error"
// @Router /api/v1/pasien/dynamic [get]
func (h *PasienHandler) GetPasienDynamic(c *gin.Context) {
	parser := queryUtils.NewQueryParser().SetLimits(10, 100)
	dynamicQuery, err := parser.ParseQueryWithDefaultFields(c.Request.URL.Query(), "m_pasien", []string{
		"id",
		"nomr",
		"status",
		"title",
		"nama",
		"tempat",
		"tgllahir",
		"jeniskelamin",
		"alamat",
		"kelurahan",
		"kdkecamatan",
		"kota",
		"kdprovinsi",
		"agama",
		"no_kartu",
		"noktp_baru",
		"namakelurahan",
		"namakecamatan",
		"namakota",
		"namaprovinsi",
	})
	if err != nil {
		h.respondError(c, "Invalid query parameters", err, http.StatusBadRequest)
		return
	}

	// Add joins for relationships using the correct structure
	dynamicQuery.Joins = []queryUtils.Join{
		{
			Type:  "LEFT",
			Table: "m_provinsi",
			Alias: "m_provinsi",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kdprovinsi", Operator: queryUtils.OpEqual, Value: "m_provinsi.idprovinsi"},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "m_kota",
			Alias: "m_kota",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kota", Operator: queryUtils.OpEqual, Value: "m_kota.idkota"},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "m_kecamatan",
			Alias: "m_kecamatan",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kdkecamatan", Operator: queryUtils.OpEqual, Value: "m_kecamatan.idkecamatan"},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "m_kelurahan",
			Alias: "m_kelurahan",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kelurahan", Operator: queryUtils.OpEqual, Value: "m_kelurahan.idkelurahan"},
				},
			},
		},
	}

	// Add default filter to exclude deleted records
	dynamicQuery.Filters = append([]queryUtils.FilterGroup{{
		Filters: []queryUtils.DynamicFilter{{Column: "status", Operator: queryUtils.OpNotEqual, Value: "deleted"}},
		LogicOp: "AND",
	}}, dynamicQuery.Filters...)

	// Try to get from cache first
	// Create cache key from query string
	cacheKey := fmt.Sprintf("pasien:dynamic:%s", c.Request.URL.RawQuery)
	if cachedData, found := h.cache.Get(cacheKey); found {
		logger.Info("Cache hit for dynamic query", map[string]interface{}{"cache_key": cacheKey})

		// Convert from interface{} to expected type
		if pasiens, ok := cachedData.([]pasienModels.Pasien); ok {
			meta := h.calculateMeta(dynamicQuery.Limit, dynamicQuery.Offset, len(pasiens))
			response := pasienModels.PasienGetResponse{
				Message: "Data pasien berhasil diambil (dari cache)",
				Data:    pasiens,
				Meta:    meta,
			}
			c.JSON(http.StatusOK, response)
			return
		}
	}

	// Use GetSQLXDB to get database connection
	dbConn, err := h.db.GetSQLXDB("postgres_simrs")
	if err != nil {
		h.logAndRespondError(c, "Database connection failed", err, http.StatusInternalServerError)
		return
	}
	ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
	defer cancel()

	pasiens, total, err := h.fetchPasiensDynamic(ctx, dbConn, dynamicQuery)
	if err != nil {
		h.logAndRespondError(c, "Failed to fetch data", err, http.StatusInternalServerError)
		return
	}

	// Save to cache
	h.cache.Set(cacheKey, pasiens, 10*time.Minute) // Cache for 10 minutes

	meta := h.calculateMeta(dynamicQuery.Limit, dynamicQuery.Offset, total)
	response := pasienModels.PasienGetResponse{
		Message: "Data pasien berhasil diambil",
		Data:    pasiens,
		Meta:    meta,
	}
	c.JSON(http.StatusOK, response)
}

// GetPasienByLocation godoc
// @Summary Get Pasien by Location
// @Description Get pasien by location (provinsi, kota, kecamatan, kelurahan)
// @Tags Pasien
// @Accept json
// @Produce json
// @Param kelurahan query int false "Filter by kelurahan ID"
// @Param kdkecamatan query int false "Filter by kdkecamatan ID"
// @Param kota query int false "Filter by kota ID"
// @Param kdprovinsi query int false "Filter by kdprovinsi ID"
// @Param limit query int false "Limit (max 100)" default(10)
// @Param offset query int false "Offset" default(0)
// @Success 200 {object} pasienModels.PasienGetResponse "Success response"
// @Failure 400 {object} models.ErrorResponse "Bad request"
// @Failure 500 {object} models.ErrorResponse "Internal server error"
// @Router /api/v1/pasien/by-location [get]
func (h *PasienHandler) GetPasienByLocation(c *gin.Context) {
	// Parse location filters
	var filters []queryUtils.DynamicFilter

	if kelurahan := c.Query("kelurahan"); kelurahan != "" {
		if kelurahanID, err := strconv.Atoi(kelurahan); err == nil {
			filters = append(filters, queryUtils.DynamicFilter{Column: "kelurahan", Operator: queryUtils.OpEqual, Value: kelurahanID})
		}
	}

	if kdkecamatan := c.Query("kdkecamatan"); kdkecamatan != "" {
		if kdkecamatanID, err := strconv.Atoi(kdkecamatan); err == nil {
			filters = append(filters, queryUtils.DynamicFilter{Column: "kdkecamatan", Operator: queryUtils.OpEqual, Value: kdkecamatanID})
		}
	}

	if kota := c.Query("kota"); kota != "" {
		if kotaID, err := strconv.Atoi(kota); err == nil {
			filters = append(filters, queryUtils.DynamicFilter{Column: "kota", Operator: queryUtils.OpEqual, Value: kotaID})
		}
	}

	if kdprovinsi := c.Query("kdprovinsi"); kdprovinsi != "" {
		if kdprovinsiID, err := strconv.Atoi(kdprovinsi); err == nil {
			filters = append(filters, queryUtils.DynamicFilter{Column: "kdprovinsi", Operator: queryUtils.OpEqual, Value: kdprovinsiID})
		}
	}

	// Parse pagination
	limit, offset := 10, 0
	if limitStr := c.Query("limit"); limitStr != "" {
		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 100 {
			limit = l
		}
	}
	if offsetStr := c.Query("offset"); offsetStr != "" {
		if o, err := strconv.Atoi(offsetStr); err == nil && o >= 0 {
			offset = o
		}
	}

	// Use GetSQLXDB to get database connection
	dbConn, err := h.db.GetSQLXDB("postgres_simrs")
	if err != nil {
		h.logAndRespondError(c, "Database connection failed", err, http.StatusInternalServerError)
		return
	}
	ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
	defer cancel()

	// Build query
	query := queryUtils.DynamicQuery{
		From: "m_pasien",
		Fields: []queryUtils.SelectField{
			{Expression: "id"},
			{Expression: "nomr"},
			{Expression: "status"},
			{Expression: "title"},
			{Expression: "nama"},
			{Expression: "tempat"},
			{Expression: "tgllahir"},
			{Expression: "jeniskelamin"},
			{Expression: "alamat"},
			{Expression: "kelurahan"},
			{Expression: "kdkecamatan"},
			{Expression: "kota"},
			{Expression: "kdprovinsi"},
			{Expression: "agama"},
			{Expression: "no_kartu"},
			{Expression: "noktp_baru"},
			{Expression: "namakelurahan"},
			{Expression: "namakecamatan"},
			{Expression: "namakota"},
			{Expression: "namaprovinsi"},
		},
		Sort:   []queryUtils.SortField{{Column: "date_created", Order: "DESC"}},
		Limit:  limit,
		Offset: offset,
	}

	// Add joins for relationships using the correct structure
	query.Joins = []queryUtils.Join{
		{
			Type:  "LEFT",
			Table: "m_provinsi",
			Alias: "m_provinsi",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kdprovinsi", Operator: queryUtils.OpEqual, Value: "m_provinsi.idprovinsi"},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "m_kota",
			Alias: "m_kota",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kota", Operator: queryUtils.OpEqual, Value: "m_kota.idkota"},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "m_kecamatan",
			Alias: "m_kecamatan",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kdkecamatan", Operator: queryUtils.OpEqual, Value: "m_kecamatan.idkecamatan"},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "m_kelurahan",
			Alias: "m_kelurahan",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kelurahan", Operator: queryUtils.OpEqual, Value: "m_kelurahan.idkelurahan"},
				},
			},
		},
	}

	// Add filters if any
	if len(filters) > 0 {
		query.Filters = append(query.Filters, queryUtils.FilterGroup{
			Filters: filters,
			LogicOp: "AND",
		})
	}

	// Execute query
	pasiens, total, err := h.fetchPasiensDynamic(ctx, dbConn, query)
	if err != nil {
		h.logAndRespondError(c, "Failed to fetch data", err, http.StatusInternalServerError)
		return
	}

	// Build response
	meta := h.calculateMeta(limit, offset, total)
	response := pasienModels.PasienGetResponse{
		Message: "Data pasien by location retrieved successfully",
		Data:    pasiens,
		Meta:    meta,
	}
	c.JSON(http.StatusOK, response)
}

// CreatePasien godoc
// @Summary Create Pasien
// @Description Create a new pasien
// @Tags Pasien
// @Accept json
// @Produce json
// @Param request body pasienModels.PasienCreateRequest true "Pasien creation request"
// @Success 201 {object} pasienModels.PasienCreateResponse "Pasien created successfully"
// @Failure 400 {object} models.ErrorResponse "Bad request or validation error"
// @Failure 500 {object} models.ErrorResponse "Internal server error"
// @Router /api/v1/pasien/ [post]
func (h *PasienHandler) CreatePasien(c *gin.Context) {
	var req pasienModels.PasienCreateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.respondError(c, "Invalid request body", err, http.StatusBadRequest)
		return
	}
	if err := validate.Struct(&req); err != nil {
		h.respondError(c, "Validation failed", err, http.StatusBadRequest)
		return
	}

	// Use GetSQLXDB to get database connection
	dbConn, err := h.db.GetSQLXDB("postgres_simrs")
	if err != nil {
		h.logAndRespondError(c, "Database connection failed", err, http.StatusInternalServerError)
		return
	}
	ctx, cancel := context.WithTimeout(c.Request.Context(), 15*time.Second)
	defer cancel()

	// Validate id must be unique
	if req.ID != nil {
		rule := validation.NewUniqueFieldRule(
			"m_pasien", // Table name
			"id",       // Column that must be unique
			queryUtils.DynamicFilter{ // Additional condition
				Column:   "status",
				Operator: queryUtils.OpNotEqual,
				Value:    "deleted",
			},
		)

		// Prepare data from request for validation
		dataToValidate := map[string]interface{}{
			"id": *req.ID,
		}

		// Execute validation
		isDuplicate, err := h.validator.Validate(ctx, dbConn, rule, dataToValidate)
		if err != nil {
			h.logAndRespondError(c, "Failed to validate id", err, http.StatusInternalServerError)
			return
		}

		if isDuplicate {
			h.respondError(c, "id already exists", fmt.Errorf("duplicate id: %d", *req.ID), http.StatusConflict)
			return
		}
	}

	// Validate nomr must be unique
	if req.Nomr != nil && *req.Nomr != "" {
		rule := validation.NewUniqueFieldRule(
			"m_pasien", // Table name
			"nomr",     // Column that must be unique
			queryUtils.DynamicFilter{ // Additional condition
				Column:   "status",
				Operator: queryUtils.OpNotEqual,
				Value:    "deleted",
			},
		)

		// Prepare data from request for validation
		dataToValidate := map[string]interface{}{
			"nomr": *req.Nomr,
		}

		// Execute validation
		isDuplicate, err := h.validator.Validate(ctx, dbConn, rule, dataToValidate)
		if err != nil {
			h.logAndRespondError(c, "Failed to validate nomr", err, http.StatusInternalServerError)
			return
		}

		if isDuplicate {
			h.respondError(c, "nomr already exists", fmt.Errorf("duplicate nomr: %s", *req.Nomr), http.StatusConflict)
			return
		}
	}

	// Validate no_kartu must be unique
	if req.NoKartu != nil && *req.NoKartu != "" {
		rule := validation.NewUniqueFieldRule(
			"m_pasien", // Table name
			"no_kartu", // Column that must be unique
			queryUtils.DynamicFilter{ // Additional condition
				Column:   "status",
				Operator: queryUtils.OpNotEqual,
				Value:    "deleted",
			},
		)

		// Prepare data from request for validation
		dataToValidate := map[string]interface{}{
			"no_kartu": *req.NoKartu,
		}

		// Execute validation
		isDuplicate, err := h.validator.Validate(ctx, dbConn, rule, dataToValidate)
		if err != nil {
			h.logAndRespondError(c, "Failed to validate no_kartu", err, http.StatusInternalServerError)
			return
		}

		if isDuplicate {
			h.respondError(c, "no_kartu already exists", fmt.Errorf("duplicate no_kartu: %s", *req.NoKartu), http.StatusConflict)
			return
		}
	}

	data := queryUtils.InsertData{
		Columns: []string{
			"status",
			"date_created", "date_updated",
			"id",
			"nomr",
			"status",
			"title",
			"nama",
			"tempat",
			"tgllahir",
			"jeniskelamin",
			"alamat",
			"kelurahan",
			"kdkecamatan",
			"kota",
			"kdprovinsi",
			"agama",
			"no_kartu",
			"noktp_baru",
		},
		Values: []interface{}{
			req.Status,
			time.Now(), time.Now(),
			req.ID,
			req.Nomr,
			req.Status,
			req.Title,
			req.Nama,
			req.Tempat,
			req.Tgllahir,
			req.Jeniskelamin,
			req.Alamat,
			req.Kelurahan,
			req.Kdkecamatan,
			req.Kota,
			req.Kdprovinsi,
			req.Agama,
			req.NoKartu,
			req.NoktpBaru,
		},
	}
	returningCols := []string{
		"status",
		"sort", "user_created", "date_created", "user_updated", "date_updated",
		"id",
		"nomr",
		"status",
		"title",
		"nama",
		"tempat",
		"tgllahir",
		"jeniskelamin",
		"alamat",
		"kelurahan",
		"kdkecamatan",
		"kota",
		"kdprovinsi",
		"agama",
		"no_kartu",
		"noktp_baru",
	}

	sql, args, err := h.queryBuilder.BuildInsertQuery("m_pasien", data, returningCols...)
	if err != nil {
		h.logAndRespondError(c, "Failed to build insert query", err, http.StatusInternalServerError)
		return
	}

	var dataPasien pasienModels.Pasien
	err = dbConn.GetContext(ctx, &dataPasien, sql, args...)
	if err != nil {
		h.logAndRespondError(c, "Failed to create pasien", err, http.StatusInternalServerError)
		return
	}

	// Invalidate cache that might be affected
	h.invalidateRelatedCache()

	response := pasienModels.PasienCreateResponse{Message: "Pasien berhasil dibuat", Data: &dataPasien}
	c.JSON(http.StatusCreated, response)
}

// GetPasien godoc
// @Summary Get Pasien List
// @Description Get list of pasien with pagination and filters
// @Tags Pasien
// @Accept json
// @Produce json
// @Param limit query int false "Limit (max 100)" default(10)
// @Param offset query int false "Offset" default(0)
// @Param status query string false "Filter by status"
// @Param search query string false "Search in multiple fields"
// @Success 200 {object} pasienModels.PasienGetResponse "Success response"
// @Failure 400 {object} models.ErrorResponse "Bad request"
// @Failure 500 {object} models.ErrorResponse "Internal server error"
// @Router /api/v1/pasien/ [get]
func (h *PasienHandler) GetPasien(c *gin.Context) {
	// Increase timeout for complex queries
	ctx, cancel := context.WithTimeout(c.Request.Context(), 120*time.Second)
	defer cancel()

	// Use the core fetchPasiensDynamic function for all data retrieval logic.
	query := queryUtils.DynamicQuery{
		From: "m_pasien",
		Fields: []queryUtils.SelectField{
			{Expression: "id"},
			{Expression: "nomr"},
			{Expression: "status"},
			{Expression: "title"},
			{Expression: "nama"},
			{Expression: "tempat"},
			{Expression: "tgllahir"},
			{Expression: "jeniskelamin"},
			{Expression: "alamat"},
			{Expression: "kelurahan"},
			{Expression: "kdkecamatan"},
			{Expression: "kota"},
			{Expression: "kdprovinsi"},
			{Expression: "agama"},
			{Expression: "no_kartu"},
			{Expression: "noktp_baru"},
			{Expression: "namakelurahan"},
			{Expression: "namakecamatan"},
			{Expression: "namakota"},
			{Expression: "namaprovinsi"},
		},
		Sort: []queryUtils.SortField{{Column: "date_created", Order: "DESC"}},
	}

	// Add joins for relationships using the correct structure
	query.Joins = []queryUtils.Join{
		{
			Type:  "LEFT",
			Table: "m_provinsi",
			Alias: "m_provinsi",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kdprovinsi", Operator: queryUtils.OpEqual, Value: "m_provinsi.idprovinsi"},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "m_kota",
			Alias: "m_kota",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kota", Operator: queryUtils.OpEqual, Value: "m_kota.idkota"},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "m_kecamatan",
			Alias: "m_kecamatan",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kdkecamatan", Operator: queryUtils.OpEqual, Value: "m_kecamatan.idkecamatan"},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "m_kelurahan",
			Alias: "m_kelurahan",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kelurahan", Operator: queryUtils.OpEqual, Value: "m_kelurahan.idkelurahan"},
				},
			},
		},
	}

	// Parse pagination
	if limit, err := strconv.Atoi(c.DefaultQuery("limit", "10")); err == nil && limit > 0 && limit <= 100 {
		query.Limit = limit
	}
	if offset, err := strconv.Atoi(c.DefaultQuery("offset", "0")); err == nil && offset >= 0 {
		query.Offset = offset
	}

	// Use GetSQLXDB to get database connection
	dbConn, err := h.db.GetSQLXDB("postgres_simrs")
	if err != nil {
		h.logAndRespondError(c, "Database connection failed", err, http.StatusInternalServerError)
		return
	}

	// Parse simple filters
	var filters []queryUtils.DynamicFilter
	if status := c.Query("status"); status != "" && models.IsValidStatus(status) {
		filters = append(filters, queryUtils.DynamicFilter{Column: "status", Operator: queryUtils.OpEqual, Value: status})
	}

	// Optimize query search with caching
	search := c.Query("search")
	var searchFilters []queryUtils.DynamicFilter
	var cacheKey string
	var useCache bool

	// Initialize searchFilters before using it in the cache hit section
	if search != "" {
		// Limit search length to prevent slow queries
		if len(search) > 50 {
			search = search[:50]
		}

		// Generate cache key for search
		cacheKey = fmt.Sprintf("pasien:search:%s:%d:%d", search, query.Limit, query.Offset)

		// Initialize searchFilters here
		searchFilters = []queryUtils.DynamicFilter{
			{Column: "nomr", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
			{Column: "title", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
			{Column: "nama", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
			{Column: "no_kartu", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
		}

		// Try to get from cache first
		if cachedData, found := h.cache.Get(cacheKey); found {
			logger.Info("Cache hit for search", map[string]interface{}{"search": search, "cache_key": cacheKey})

			// Convert from interface{} to expected type
			pasiens, ok := cachedData.([]pasienModels.Pasien)
			if !ok {
				logger.Error("Failed to convert cached data", map[string]interface{}{"cache_key": cacheKey})
			} else {
				// If requested, get aggregation data
				var aggregateData *models.AggregateData
				if c.Query("include_summary") == "true" {
					// Build full filter groups for aggregate data (including search filters)
					fullFilterGroups := []queryUtils.FilterGroup{
						{Filters: searchFilters, LogicOp: "OR"},
					}
					if len(filters) > 0 {
						fullFilterGroups = append(fullFilterGroups, queryUtils.FilterGroup{Filters: filters, LogicOp: "AND"})
					}
					aggregateData, err = h.getAggregateData(ctx, dbConn, fullFilterGroups)
					if err != nil {
						h.logAndRespondError(c, "Failed to get aggregate data", err, http.StatusInternalServerError)
						return
					}
				}

				// Build response
				meta := h.calculateMeta(query.Limit, query.Offset, len(pasiens))
				response := pasienModels.PasienGetResponse{
					Message: "Data pasien berhasil diambil (dari cache)",
					Data:    pasiens,
					Meta:    meta,
				}

				if aggregateData != nil {
					response.Summary = aggregateData
				}

				c.JSON(http.StatusOK, response)
				return
			}
		}

		// If not in cache, mark for saving after query
		useCache = true

		// If there's search, create OR filter group
		query.Filters = append(query.Filters, queryUtils.FilterGroup{Filters: searchFilters, LogicOp: "OR"})
	}

	// Add other filters (if any) as AND group
	if len(filters) > 0 {
		query.Filters = append(query.Filters, queryUtils.FilterGroup{Filters: filters, LogicOp: "AND"})
	}

	pasiens, total, err := h.fetchPasiensDynamic(ctx, dbConn, query)
	if err != nil {
		h.logAndRespondError(c, "Failed to fetch data", err, http.StatusInternalServerError)
		return
	}

	// Save search results to cache if there's a search parameter
	if useCache && len(pasiens) > 0 {
		h.cache.Set(cacheKey, pasiens, 15*time.Minute) // Cache for 15 minutes
		logger.Info("Cached search results", map[string]interface{}{"search": search, "cache_key": cacheKey, "count": len(pasiens)})
	}

	// If requested, get aggregation data
	var aggregateData *models.AggregateData
	if c.Query("include_summary") == "true" {
		aggregateData, err = h.getAggregateData(ctx, dbConn, query.Filters)
		if err != nil {
			h.logAndRespondError(c, "Failed to get aggregate data", err, http.StatusInternalServerError)
			return
		}
	}

	// Build response
	meta := h.calculateMeta(query.Limit, query.Offset, total)
	response := pasienModels.PasienGetResponse{
		Message: "Data pasien berhasil diambil",
		Data:    pasiens,
		Meta:    meta,
	}

	if aggregateData != nil {
		response.Summary = aggregateData
	}

	c.JSON(http.StatusOK, response)
}

// GetPasienByID godoc
// @Summary Get Pasien by ID
// @Description Get pasien by ID
// @Tags Pasien
// @Accept json
// @Produce json
// @Param id path string true "Pasien ID"
// @Success 200 {object} pasienModels.PasienGetByIDResponse "Success response"
// @Failure 400 {object} models.ErrorResponse "Invalid ID format"
// @Failure 404 {object} models.ErrorResponse "Pasien not found"
// @Failure 500 {object} models.ErrorResponse "Internal server error"
// @Router /api/v1/pasien/:id [get]
func (h *PasienHandler) GetPasienByID(c *gin.Context) {
	id := c.Param("id")
	if id == "" {
		h.respondError(c, "Invalid ID format", fmt.Errorf("id cannot be empty"), http.StatusBadRequest)
		return
	}

	// Try to get from cache first
	cacheKey := fmt.Sprintf("pasien:id:%s", id)
	if cachedData, found := h.cache.Get(cacheKey); found {
		logger.Info("Cache hit for id", map[string]interface{}{"id": id, "cache_key": cacheKey})

		// Convert from interface{} to expected type
		if cachedPasien, ok := cachedData.(pasienModels.Pasien); ok {
			response := pasienModels.PasienGetByIDResponse{
				Message: "Pasien details retrieved successfully (dari cache)",
				Data:    &cachedPasien,
			}
			c.JSON(http.StatusOK, response)
			return
		}
	}

	// Use GetSQLXDB to get database connection
	dbConn, err := h.db.GetSQLXDB("postgres_simrs")
	if err != nil {
		h.logAndRespondError(c, "Database connection failed", err, http.StatusInternalServerError)
		return
	}
	ctx, cancel := context.WithTimeout(c.Request.Context(), 15*time.Second)
	defer cancel()

	dynamicQuery := queryUtils.DynamicQuery{
		From: "m_pasien",
		Fields: []queryUtils.SelectField{
			{Expression: "id"},
			{Expression: "nomr"},
			{Expression: "status"},
			{Expression: "title"},
			{Expression: "nama"},
			{Expression: "tempat"},
			{Expression: "tgllahir"},
			{Expression: "jeniskelamin"},
			{Expression: "alamat"},
			{Expression: "kelurahan"},
			{Expression: "kdkecamatan"},
			{Expression: "kota"},
			{Expression: "kdprovinsi"},
			{Expression: "agama"},
			{Expression: "no_kartu"},
			{Expression: "noktp_baru"},
			{Expression: "namakelurahan"},
			{Expression: "namakecamatan"},
			{Expression: "namakota"},
			{Expression: "namaprovinsi"},
		},
		Filters: []queryUtils.FilterGroup{{
			Filters: []queryUtils.DynamicFilter{
				{Column: "id", Operator: queryUtils.OpEqual, Value: id},
				{Column: "status", Operator: queryUtils.OpNotEqual, Value: "deleted"},
			},
			LogicOp: "AND",
		}},
		Limit: 1,
	}

	// Add joins for relationships using the correct structure
	dynamicQuery.Joins = []queryUtils.Join{
		{
			Type:  "LEFT",
			Table: "m_provinsi",
			Alias: "m_provinsi",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kdprovinsi", Operator: queryUtils.OpEqual, Value: "m_provinsi.idprovinsi"},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "m_kota",
			Alias: "m_kota",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kota", Operator: queryUtils.OpEqual, Value: "m_kota.idkota"},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "m_kecamatan",
			Alias: "m_kecamatan",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kdkecamatan", Operator: queryUtils.OpEqual, Value: "m_kecamatan.idkecamatan"},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "m_kelurahan",
			Alias: "m_kelurahan",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kelurahan", Operator: queryUtils.OpEqual, Value: "m_kelurahan.idkelurahan"},
				},
			},
		},
	}

	var dataPasien pasienModels.Pasien
	err = h.queryBuilder.ExecuteQueryRow(ctx, dbConn, dynamicQuery, &dataPasien)
	if err != nil {
		if err == sql.ErrNoRows {
			h.respondError(c, "Pasien not found", err, http.StatusNotFound)
		} else {
			h.logAndRespondError(c, "Failed to get pasien", err, http.StatusInternalServerError)
		}
		return
	}

	// Save to cache
	h.cache.Set(cacheKey, dataPasien, 30*time.Minute) // Cache for 30 minutes

	response := pasienModels.PasienGetByIDResponse{
		Message: "Pasien details retrieved successfully",
		Data:    &dataPasien,
	}
	c.JSON(http.StatusOK, response)
}

// GetPasienByNomr godoc
// @Summary Get Pasien by Nomr
// @Description Get pasien by Nomr
// @Tags Pasien
// @Accept json
// @Produce json
// @Success 200 {object} pasienModels.PasienGetByNomrResponse "Success response"
// @Failure 400 {object} models.ErrorResponse "Bad request"
// @Failure 500 {object} models.ErrorResponse "Internal server error"
// @Router /api/v1/pasien/nomr/:nomr [get]
func (h *PasienHandler) GetPasienByNomr(c *gin.Context) {
	// Increase timeout for complex queries
	ctx, cancel := context.WithTimeout(c.Request.Context(), 120*time.Second)
	defer cancel()

	// Use the core fetchPasiensDynamic function for all data retrieval logic.
	query := queryUtils.DynamicQuery{
		From: "m_pasien",
		Fields: []queryUtils.SelectField{
			{Expression: "id"},
			{Expression: "nomr"},
			{Expression: "status"},
			{Expression: "title"},
			{Expression: "nama"},
			{Expression: "tempat"},
			{Expression: "tgllahir"},
			{Expression: "jeniskelamin"},
			{Expression: "alamat"},
			{Expression: "kelurahan"},
			{Expression: "kdkecamatan"},
			{Expression: "kota"},
			{Expression: "kdprovinsi"},
			{Expression: "agama"},
			{Expression: "no_kartu"},
			{Expression: "noktp_baru"},
			{Expression: "namakelurahan"},
			{Expression: "namakecamatan"},
			{Expression: "namakota"},
			{Expression: "namaprovinsi"},
		},
		Sort: []queryUtils.SortField{{Column: "date_created", Order: "DESC"}},
	}

	// Add joins for relationships using the correct structure
	query.Joins = []queryUtils.Join{
		{
			Type:  "LEFT",
			Table: "m_provinsi",
			Alias: "m_provinsi",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kdprovinsi", Operator: queryUtils.OpEqual, Value: "m_provinsi.idprovinsi"},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "m_kota",
			Alias: "m_kota",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kota", Operator: queryUtils.OpEqual, Value: "m_kota.idkota"},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "m_kecamatan",
			Alias: "m_kecamatan",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kdkecamatan", Operator: queryUtils.OpEqual, Value: "m_kecamatan.idkecamatan"},
				},
			},
		},
		{
			Type:  "LEFT",
			Table: "m_kelurahan",
			Alias: "m_kelurahan",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "m_pasien.kelurahan", Operator: queryUtils.OpEqual, Value: "m_kelurahan.idkelurahan"},
				},
			},
		},
	}

	// Parse pagination
	if limit, err := strconv.Atoi(c.DefaultQuery("limit", "10")); err == nil && limit > 0 && limit <= 100 {
		query.Limit = limit
	}
	if offset, err := strconv.Atoi(c.DefaultQuery("offset", "0")); err == nil && offset >= 0 {
		query.Offset = offset
	}

	// Use GetSQLXDB to get database connection
	dbConn, err := h.db.GetSQLXDB("postgres_simrs")
	if err != nil {
		h.logAndRespondError(c, "Database connection failed", err, http.StatusInternalServerError)
		return
	}

	// Parse simple filters
	var filters []queryUtils.DynamicFilter
	if status := c.Query("status"); status != "" && models.IsValidStatus(status) {
		filters = append(filters, queryUtils.DynamicFilter{Column: "status", Operator: queryUtils.OpEqual, Value: status})
	}

	// Optimize query search with caching
	search := c.Query("search")
	var searchFilters []queryUtils.DynamicFilter
	var cacheKey string
	var useCache bool

	// Initialize searchFilters before using it in the cache hit section
	if search != "" {
		// Limit search length to prevent slow queries
		if len(search) > 50 {
			search = search[:50]
		}

		// Generate cache key for search
		cacheKey = fmt.Sprintf("pasien:search:%s:%d:%d", search, query.Limit, query.Offset)

		// Initialize searchFilters here
		searchFilters = []queryUtils.DynamicFilter{
			{Column: "nomr", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
			{Column: "title", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
			{Column: "nama", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
			{Column: "no_kartu", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
		}

		// Try to get from cache first
		if cachedData, found := h.cache.Get(cacheKey); found {
			logger.Info("Cache hit for search", map[string]interface{}{"search": search, "cache_key": cacheKey})

			// Convert from interface{} to expected type
			pasiens, ok := cachedData.([]pasienModels.Pasien)
			if !ok {
				logger.Error("Failed to convert cached data", map[string]interface{}{"cache_key": cacheKey})
			} else {
				// If requested, get aggregation data
				var aggregateData *models.AggregateData
				if c.Query("include_summary") == "true" {
					// Build full filter groups for aggregate data (including search filters)
					fullFilterGroups := []queryUtils.FilterGroup{
						{Filters: searchFilters, LogicOp: "OR"},
					}
					if len(filters) > 0 {
						fullFilterGroups = append(fullFilterGroups, queryUtils.FilterGroup{Filters: filters, LogicOp: "AND"})
					}
					aggregateData, err = h.getAggregateData(ctx, dbConn, fullFilterGroups)
					if err != nil {
						h.logAndRespondError(c, "Failed to get aggregate data", err, http.StatusInternalServerError)
						return
					}
				}

				// Build response
				meta := h.calculateMeta(query.Limit, query.Offset, len(pasiens))
				response := pasienModels.PasienGetByNomrResponse{
					Message: "Data pasien berhasil diambil (dari cache)",
					Data:    pasiens,
					Meta:    meta,
				}

				if aggregateData != nil {
					response.Summary = aggregateData
				}

				c.JSON(http.StatusOK, response)
				return
			}
		}

		// If not in cache, mark for saving after query
		useCache = true

		// If there's search, create OR filter group
		query.Filters = append(query.Filters, queryUtils.FilterGroup{Filters: searchFilters, LogicOp: "OR"})
	}

	// Add other filters (if any) as AND group
	if len(filters) > 0 {
		query.Filters = append(query.Filters, queryUtils.FilterGroup{Filters: filters, LogicOp: "AND"})
	}

	pasiens, total, err := h.fetchPasiensDynamic(ctx, dbConn, query)
	if err != nil {
		h.logAndRespondError(c, "Failed to fetch data", err, http.StatusInternalServerError)
		return
	}

	// Save search results to cache if there's a search parameter
	if useCache && len(pasiens) > 0 {
		h.cache.Set(cacheKey, pasiens, 15*time.Minute) // Cache for 15 minutes
		logger.Info("Cached search results", map[string]interface{}{"search": search, "cache_key": cacheKey, "count": len(pasiens)})
	}

	// If requested, get aggregation data
	var aggregateData *models.AggregateData
	if c.Query("include_summary") == "true" {
		aggregateData, err = h.getAggregateData(ctx, dbConn, query.Filters)
		if err != nil {
			h.logAndRespondError(c, "Failed to get aggregate data", err, http.StatusInternalServerError)
			return
		}
	}

	// Build response
	meta := h.calculateMeta(query.Limit, query.Offset, total)
	response := pasienModels.PasienGetByNomrResponse{
		Message: "Data pasien berhasil diambil",
		Data:    pasiens,
		Meta:    meta,
	}

	if aggregateData != nil {
		response.Summary = aggregateData
	}

	c.JSON(http.StatusOK, response)
}

// UpdatePasien godoc
// @Summary Update Pasien
// @Description Update an existing pasien
// @Tags Pasien
// @Accept json
// @Produce json
// @Param id path string true "Pasien ID"
// @Param request body pasienModels.PasienUpdateRequest true "Pasien update request"
// @Success 200 {object} pasienModels.PasienUpdateResponse "Pasien updated successfully"
// @Failure 400 {object} models.ErrorResponse "Bad request or validation error"
// @Failure 404 {object} models.ErrorResponse "Pasien not found"
// @Failure 500 {object} models.ErrorResponse "Internal server error"
// @Router /api/v1/pasien/:nomr [put]
func (h *PasienHandler) UpdatePasien(c *gin.Context) {
	id := c.Param("id")
	if id == "" {
		h.respondError(c, "Invalid ID format", fmt.Errorf("id cannot be empty"), http.StatusBadRequest)
		return
	}
	var req pasienModels.PasienUpdateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.respondError(c, "Invalid request body", err, http.StatusBadRequest)
		return
	}
	// Set the ID from path parameter to request
	idInt, err := strconv.Atoi(id)
	if err != nil {
		h.respondError(c, "Invalid ID format", err, http.StatusBadRequest)
		return
	}
	idInt32 := int32(idInt)
	req.ID = &idInt32
	if err := validate.Struct(&req); err != nil {
		h.respondError(c, "Validation failed", err, http.StatusBadRequest)
		return
	}

	// Try to get old data for cache invalidation
	var oldData pasienModels.Pasien
	dbConn, err := h.db.GetSQLXDB("postgres_simrs")
	if err == nil {
		ctx, cancel := context.WithTimeout(c.Request.Context(), 5*time.Second)
		defer cancel()

		dynamicQuery := queryUtils.DynamicQuery{
			From:   "m_pasien",
			Fields: []queryUtils.SelectField{{Expression: "*"}},
			Filters: []queryUtils.FilterGroup{{
				Filters: []queryUtils.DynamicFilter{
					{Column: "id", Operator: queryUtils.OpEqual, Value: id},
				},
				LogicOp: "AND",
			}},
			Limit: 1,
		}

		// Add joins for relationships using the correct structure
		dynamicQuery.Joins = []queryUtils.Join{
			{
				Type:  "LEFT",
				Table: "m_provinsi",
				Alias: "m_provinsi",
				OnConditions: queryUtils.FilterGroup{
					Filters: []queryUtils.DynamicFilter{
						{Column: "m_pasien.kdprovinsi", Operator: queryUtils.OpEqual, Value: "m_provinsi.idprovinsi"},
					},
				},
			},
			{
				Type:  "LEFT",
				Table: "m_kota",
				Alias: "m_kota",
				OnConditions: queryUtils.FilterGroup{
					Filters: []queryUtils.DynamicFilter{
						{Column: "m_pasien.kota", Operator: queryUtils.OpEqual, Value: "m_kota.idkota"},
					},
				},
			},
			{
				Type:  "LEFT",
				Table: "m_kecamatan",
				Alias: "m_kecamatan",
				OnConditions: queryUtils.FilterGroup{
					Filters: []queryUtils.DynamicFilter{
						{Column: "m_pasien.kdkecamatan", Operator: queryUtils.OpEqual, Value: "m_kecamatan.idkecamatan"},
					},
				},
			},
			{
				Type:  "LEFT",
				Table: "m_kelurahan",
				Alias: "m_kelurahan",
				OnConditions: queryUtils.FilterGroup{
					Filters: []queryUtils.DynamicFilter{
						{Column: "m_pasien.kelurahan", Operator: queryUtils.OpEqual, Value: "m_kelurahan.idkelurahan"},
					},
				},
			},
		}

		err = h.queryBuilder.ExecuteQueryRow(ctx, dbConn, dynamicQuery, &oldData)
		if err != nil {
			logger.Error("Failed to fetch old data for cache invalidation", map[string]interface{}{"error": err.Error(), "id": id})
		}
	}

	// Use GetSQLXDB to get database connection
	dbConn, err = h.db.GetSQLXDB("postgres_simrs")
	if err != nil {
		h.logAndRespondError(c, "Database connection failed", err, http.StatusInternalServerError)
		return
	}
	ctx, cancel := context.WithTimeout(c.Request.Context(), 15*time.Second)
	defer cancel()

	// Validate id must be unique, except for record with this id
	if req.ID != nil {
		rule := validation.ValidationRule{
			TableName:     "m_pasien",
			UniqueColumns: []string{"id"},
			Conditions: []queryUtils.DynamicFilter{
				{Column: "status", Operator: queryUtils.OpNotEqual, Value: "deleted"},
			},
			ExcludeIDColumn: "id", // Exclude based on 'id' column
			ExcludeIDValue:  id,   // ...with id value from parameter
		}

		dataToValidate := map[string]interface{}{
			"id": *req.ID,
		}

		isDuplicate, err := h.validator.Validate(ctx, dbConn, rule, dataToValidate)
		if err != nil {
			h.logAndRespondError(c, "Failed to validate id", err, http.StatusInternalServerError)
			return
		}

		if isDuplicate {
			h.respondError(c, "id already exists", fmt.Errorf("duplicate id: %d", *req.ID), http.StatusConflict)
			return
		}
	}

	// Validate nomr must be unique, except for record with this id
	if req.Nomr != nil && *req.Nomr != "" {
		rule := validation.ValidationRule{
			TableName:     "m_pasien",
			UniqueColumns: []string{"nomr"},
			Conditions: []queryUtils.DynamicFilter{
				{Column: "status", Operator: queryUtils.OpNotEqual, Value: "deleted"},
			},
			ExcludeIDColumn: "id", // Exclude based on 'id' column
			ExcludeIDValue:  id,   // ...with id value from parameter
		}

		dataToValidate := map[string]interface{}{
			"nomr": *req.Nomr,
		}

		isDuplicate, err := h.validator.Validate(ctx, dbConn, rule, dataToValidate)
		if err != nil {
			h.logAndRespondError(c, "Failed to validate nomr", err, http.StatusInternalServerError)
			return
		}

		if isDuplicate {
			h.respondError(c, "nomr already exists", fmt.Errorf("duplicate nomr: %s", *req.Nomr), http.StatusConflict)
			return
		}
	}

	// Validate no_kartu must be unique, except for record with this id
	if req.NoKartu != nil && *req.NoKartu != "" {
		rule := validation.ValidationRule{
			TableName:     "m_pasien",
			UniqueColumns: []string{"no_kartu"},
			Conditions: []queryUtils.DynamicFilter{
				{Column: "status", Operator: queryUtils.OpNotEqual, Value: "deleted"},
			},
			ExcludeIDColumn: "id", // Exclude based on 'id' column
			ExcludeIDValue:  id,   // ...with id value from parameter
		}

		dataToValidate := map[string]interface{}{
			"no_kartu": *req.NoKartu,
		}

		isDuplicate, err := h.validator.Validate(ctx, dbConn, rule, dataToValidate)
		if err != nil {
			h.logAndRespondError(c, "Failed to validate no_kartu", err, http.StatusInternalServerError)
			return
		}

		if isDuplicate {
			h.respondError(c, "no_kartu already exists", fmt.Errorf("duplicate no_kartu: %s", *req.NoKartu), http.StatusConflict)
			return
		}
	}

	updateData := queryUtils.UpdateData{
		Columns: []string{
			"status",
			"date_updated",
			"id",
			"nomr",
			"status",
			"title",
			"nama",
			"tempat",
			"tgllahir",
			"jeniskelamin",
			"alamat",
			"kelurahan",
			"kdkecamatan",
			"kota",
			"kdprovinsi",
			"agama",
			"no_kartu",
			"noktp_baru",
		},
		Values: []interface{}{
			req.Status,
			time.Now(),
			req.ID,
			req.Nomr,
			req.Status,
			req.Title,
			req.Nama,
			req.Tempat,
			req.Tgllahir,
			req.Jeniskelamin,
			req.Alamat,
			req.Kelurahan,
			req.Kdkecamatan,
			req.Kota,
			req.Kdprovinsi,
			req.Agama,
			req.NoKartu,
			req.NoktpBaru,
		},
	}
	filters := []queryUtils.FilterGroup{{
		Filters: []queryUtils.DynamicFilter{
			{Column: "id", Operator: queryUtils.OpEqual, Value: req.ID},
			{Column: "status", Operator: queryUtils.OpNotEqual, Value: "deleted"},
		},
		LogicOp: "AND",
	}}
	returningCols := []string{
		"status",
		"sort", "user_created", "date_created", "user_updated", "date_updated",
		"id",
		"nomr",
		"status",
		"title",
		"nama",
		"tempat",
		"tgllahir",
		"jeniskelamin",
		"alamat",
		"kelurahan",
		"kdkecamatan",
		"kota",
		"kdprovinsi",
		"agama",
		"no_kartu",
		"noktp_baru",
	}

	sql, args, err := h.queryBuilder.BuildUpdateQuery("m_pasien", updateData, filters, returningCols...)
	if err != nil {
		h.logAndRespondError(c, "Failed to build update query", err, http.StatusInternalServerError)
		return
	}

	var dataPasien pasienModels.Pasien
	err = dbConn.GetContext(ctx, &dataPasien, sql, args...)
	if err != nil {
		if err.Error() == "sql: no rows in result set" {
			h.respondError(c, "Pasien not found", err, http.StatusNotFound)
		} else {
			h.logAndRespondError(c, "Failed to update pasien", err, http.StatusInternalServerError)
		}
		return
	}

	// Invalidate cache that might be affected
	// Invalidate cache for id that was updated
	cacheKey := fmt.Sprintf("pasien:id:%s", id)
	h.cache.Delete(cacheKey)

	// Invalidate cache for old and new data
	if oldData.ID != 0 {
		h.invalidateRelatedCache()
	}
	h.invalidateRelatedCache()

	response := pasienModels.PasienUpdateResponse{Message: "Pasien berhasil diperbarui", Data: &dataPasien}
	c.JSON(http.StatusOK, response)
}

// DeletePasien godoc
// @Summary Delete Pasien
// @Description Delete a pasien
// @Tags Pasien
// @Accept json
// @Produce json
// @Param id path string true "Pasien ID"
// @Success 200 {object} pasienModels.PasienDeleteResponse "Pasien deleted successfully"
// @Failure 400 {object} models.ErrorResponse "Invalid ID format"
// @Failure 404 {object} models.ErrorResponse "Pasien not found"
// @Failure 500 {object} models.ErrorResponse "Internal server error"
// @Router /api/v1/pasien/:nomr [delete]
func (h *PasienHandler) DeletePasien(c *gin.Context) {
	id := c.Param("id")
	if id == "" {
		h.respondError(c, "Invalid ID format", fmt.Errorf("id cannot be empty"), http.StatusBadRequest)
		return
	}

	// Try to get data for cache invalidation
	var dataToDelete pasienModels.Pasien
	dbConn, err := h.db.GetSQLXDB("postgres_simrs")
	if err == nil {
		ctx, cancel := context.WithTimeout(c.Request.Context(), 5*time.Second)
		defer cancel()

		dynamicQuery := queryUtils.DynamicQuery{
			From:   "m_pasien",
			Fields: []queryUtils.SelectField{{Expression: "*"}},
			Filters: []queryUtils.FilterGroup{{
				Filters: []queryUtils.DynamicFilter{
					{Column: "id", Operator: queryUtils.OpEqual, Value: id},
				},
				LogicOp: "AND",
			}},
			Limit: 1,
		}

		// Add joins for relationships using the correct structure
		dynamicQuery.Joins = []queryUtils.Join{
			{
				Type:  "LEFT",
				Table: "m_provinsi",
				Alias: "m_provinsi",
				OnConditions: queryUtils.FilterGroup{
					Filters: []queryUtils.DynamicFilter{
						{Column: "m_pasien.kdprovinsi", Operator: queryUtils.OpEqual, Value: "m_provinsi.idprovinsi"},
					},
				},
			},
			{
				Type:  "LEFT",
				Table: "m_kota",
				Alias: "m_kota",
				OnConditions: queryUtils.FilterGroup{
					Filters: []queryUtils.DynamicFilter{
						{Column: "m_pasien.kota", Operator: queryUtils.OpEqual, Value: "m_kota.idkota"},
					},
				},
			},
			{
				Type:  "LEFT",
				Table: "m_kecamatan",
				Alias: "m_kecamatan",
				OnConditions: queryUtils.FilterGroup{
					Filters: []queryUtils.DynamicFilter{
						{Column: "m_pasien.kdkecamatan", Operator: queryUtils.OpEqual, Value: "m_kecamatan.idkecamatan"},
					},
				},
			},
			{
				Type:  "LEFT",
				Table: "m_kelurahan",
				Alias: "m_kelurahan",
				OnConditions: queryUtils.FilterGroup{
					Filters: []queryUtils.DynamicFilter{
						{Column: "m_pasien.kelurahan", Operator: queryUtils.OpEqual, Value: "m_kelurahan.idkelurahan"},
					},
				},
			},
		}

		err = h.queryBuilder.ExecuteQueryRow(ctx, dbConn, dynamicQuery, &dataToDelete)
		if err != nil {
			logger.Error("Failed to fetch data for cache invalidation", map[string]interface{}{"error": err.Error(), "id": id})
		}
	}

	// Use GetSQLXDB to get database connection
	dbConn, err = h.db.GetSQLXDB("postgres_simrs")
	if err != nil {
		h.logAndRespondError(c, "Database connection failed", err, http.StatusInternalServerError)
		return
	}
	ctx, cancel := context.WithTimeout(c.Request.Context(), 15*time.Second)
	defer cancel()

	// Use ExecuteUpdate for soft delete by changing status
	updateData := queryUtils.UpdateData{
		Columns: []string{"status", "date_updated"},
		Values:  []interface{}{"deleted", time.Now()},
	}
	filters := []queryUtils.FilterGroup{{
		Filters: []queryUtils.DynamicFilter{
			{Column: "id", Operator: queryUtils.OpEqual, Value: id},
			{Column: "status", Operator: queryUtils.OpNotEqual, Value: "deleted"},
		},
		LogicOp: "AND",
	}}

	// Use ExecuteUpdate instead of ExecuteDelete
	result, err := h.queryBuilder.ExecuteUpdate(ctx, dbConn, "m_pasien", updateData, filters)
	if err != nil {
		h.logAndRespondError(c, "Failed to delete pasien", err, http.StatusInternalServerError)
		return
	}

	rowsAffected, err := result.RowsAffected()
	if err != nil {
		h.logAndRespondError(c, "Failed to get affected rows", err, http.StatusInternalServerError)
		return
	}
	if rowsAffected == 0 {
		h.respondError(c, "Pasien not found", sql.ErrNoRows, http.StatusNotFound)
		return
	}

	// Invalidate cache that might be affected
	// Invalidate cache for id that was deleted
	cacheKey := fmt.Sprintf("pasien:id:%s", id)
	h.cache.Delete(cacheKey)

	// Invalidate cache for data that was deleted
	if dataToDelete.ID != 0 {
		h.invalidateRelatedCache()
	}

	response := pasienModels.PasienDeleteResponse{Message: "Pasien berhasil dihapus", ID: id}
	c.JSON(http.StatusOK, response)
}

// =============================================================================
// HELPER FUNCTIONS
// =============================================================================

// invalidateRelatedCache invalidates cache that might be affected by data changes
func (h *PasienHandler) invalidateRelatedCache() {
	// Invalidate cache for search that might be affected
	h.cache.DeleteByPrefix("pasien:search:")
	h.cache.DeleteByPrefix("pasien:dynamic:")
	h.cache.DeleteByPrefix("pasien:stats:")
	h.cache.DeleteByPrefix("pasien:id:")
}

// fetchPasiensDynamic executes dynamic query with timeout handling
func (h *PasienHandler) fetchPasiensDynamic(ctx context.Context, dbConn *sqlx.DB, query queryUtils.DynamicQuery) ([]pasienModels.Pasien, int, error) {
	logger.Info("Starting fetchPasiensDynamic", map[string]interface{}{
		"limit":  query.Limit,
		"offset": query.Offset,
		"from":   query.From,
	})

	var total int
	var pasiens []pasienModels.Pasien

	// Check if query has search
	hasSearch := false
	for _, filterGroup := range query.Filters {
		for _, filter := range filterGroup.Filters {
			if filter.Operator == queryUtils.OpILike {
				hasSearch = true
				break
			}
		}
		if hasSearch {
			break
		}
	}

	logger.Info("Query analysis", map[string]interface{}{
		"hasSearch":    hasSearch,
		"totalFilters": len(query.Filters),
	})

	// Optimize to prevent timeout on search queries
	// Use shorter context for search and count queries
	queryCtx, queryCancel := context.WithTimeout(ctx, 30*time.Second)
	defer queryCancel()

	// For search queries, limit maximum to prevent timeout
	if hasSearch {
		search := getSearchTerm(query)
		logger.Info("Executing search query with timeout context", map[string]interface{}{"search_term": search})

		// Limit maximum search limit to prevent timeout
		maxSearchLimit := 50
		if query.Limit > maxSearchLimit {
			query.Limit = maxSearchLimit
			logger.Info("Reduced search limit to prevent timeout", map[string]interface{}{
				"original_limit": query.Limit,
				"new_limit":      maxSearchLimit,
			})
		}

		// Execute search query
		err := h.queryBuilder.ExecuteQuery(queryCtx, dbConn, query, &pasiens)
		if err != nil {
			// Check if it's a PostgreSQL statement timeout error
			if pqErr, ok := err.(*pq.Error); ok && pqErr.Code == "57014" {
				logger.Warn("Search query timed out, trying fallback strategy", map[string]interface{}{
					"search_term": search,
				})

				// Fallback: Search only in the most relevant column
				// We need to rebuild the filters for the fallback
				var fallbackFilters []queryUtils.FilterGroup
				// Add other non-search filters back (e.g., status)
				for _, fg := range query.Filters {
					if fg.LogicOp == "AND" {
						fallbackFilters = append(fallbackFilters, fg)
					}
				}
				// Add the single, more specific search filter
				searchableColumns := []string{
					"nomr",
					"title",
					"nama",
					"no_kartu",
				}
				if len(searchableColumns) > 0 {
					fallbackFilters = append([]queryUtils.FilterGroup{{
						Filters: []queryUtils.DynamicFilter{
							{Column: searchableColumns[0], Operator: queryUtils.OpILike, Value: "%" + search + "%"},
						},
						LogicOp: "AND",
					}}, fallbackFilters...)

					fallbackQuery := query
					fallbackQuery.Filters = fallbackFilters

					// Execute the fallback query with a shorter timeout
					fallbackCtx, fallbackCancel := context.WithTimeout(ctx, 10*time.Second)
					defer fallbackCancel()

					err = h.queryBuilder.ExecuteQuery(fallbackCtx, dbConn, fallbackQuery, &pasiens)
					if err != nil {
						logger.Error("Fallback search query also failed", map[string]interface{}{
							"error": err.Error(),
							"query": fallbackQuery,
						})
						// Return a more user-friendly error
						return nil, 0, fmt.Errorf("search timed out. The search term '%s' is too general. Please try a more specific term", search)
					}
					logger.Info("Fallback search query successful", map[string]interface{}{
						"recordsFetched": len(pasiens),
					})
				}
			} else {
				// It's a different error, handle it as before
				logger.Error("Failed to execute search query", map[string]interface{}{
					"error": err.Error(),
					"query": query,
				})
				return nil, 0, fmt.Errorf("failed to execute search query: %w", err)
			}
		}

		// Estimate total for search query (don't count exact for performance)
		total = len(pasiens)
		if len(pasiens) == query.Limit {
			// If reached limit, estimate there are more data
			total = query.Offset + query.Limit + 100
		} else {
			total = query.Offset + len(pasiens)
		}
	} else {
		logger.Info("Executing regular query without search")

		// For queries without search, count total with shorter timeout
		countCtx, countCancel := context.WithTimeout(ctx, 15*time.Second)
		defer countCancel()

		count, err := h.queryBuilder.ExecuteCount(countCtx, dbConn, query)
		if err != nil {
			// If count failed, fallback to estimation or return error
			logger.Warn("Failed to get exact count, using estimation", map[string]interface{}{"error": err.Error()})
			// For queries without search, we can estimate based on limit
			total = query.Offset + query.Limit + 100 // Conservative estimation
		} else {
			total = int(count)
		}

		logger.Info("Count query successful", map[string]interface{}{
			"count": total,
		})

		// Execute main data query
		err = h.queryBuilder.ExecuteQuery(queryCtx, dbConn, query, &pasiens)
		if err != nil {
			logger.Error("Failed to execute main query", map[string]interface{}{
				"error": err.Error(),
				"query": query,
			})
			return nil, 0, fmt.Errorf("failed to execute main query: %w", err)
		}

		logger.Info("Data query successful", map[string]interface{}{
			"recordsFetched": len(pasiens),
		})
	}

	logger.Info("Query execution completed", map[string]interface{}{
		"totalRecords":    total,
		"returnedRecords": len(pasiens),
		"hasSearch":       hasSearch,
	})

	return pasiens, total, nil
}

// getSearchTerm extracts the search term from a DynamicQuery object.
// It assumes the search is the first filter group with an "OR" logic operator.
func getSearchTerm(query queryUtils.DynamicQuery) string {
	for _, filterGroup := range query.Filters {
		if filterGroup.LogicOp == "OR" && len(filterGroup.Filters) > 0 {
			if valueStr, ok := filterGroup.Filters[0].Value.(string); ok {
				return strings.Trim(valueStr, "%")
			}
		}
	}
	return ""
}

// getAggregateData gets comprehensive statistics about pasien data
func (h *PasienHandler) getAggregateData(ctx context.Context, dbConn *sqlx.DB, filterGroups []queryUtils.FilterGroup) (*models.AggregateData, error) {
	aggregate := &models.AggregateData{
		ByStatus: make(map[string]int),
	}

	var wg sync.WaitGroup
	var mu sync.Mutex
	errChan := make(chan error, 4)

	// 1. Count by status
	wg.Add(1)
	go func() {
		defer wg.Done()
		// Use context with shorter timeout
		queryCtx, queryCancel := context.WithTimeout(ctx, 20*time.Second)
		defer queryCancel()

		query := queryUtils.DynamicQuery{
			From: "m_pasien",
			Fields: []queryUtils.SelectField{
				{Expression: "status"},
				{Expression: "COUNT(*)", Alias: "count"},
			},
			Filters: filterGroups,
			GroupBy: []string{"status"},
		}
		var results []struct {
			Status string `db:"status"`
			Count  int    `db:"count"`
		}
		err := h.queryBuilder.ExecuteQuery(queryCtx, dbConn, query, &results)
		if err != nil {
			errChan <- fmt.Errorf("status query failed: %w", err)
			return
		}
		mu.Lock()
		for _, result := range results {
			aggregate.ByStatus[result.Status] = result.Count
			switch result.Status {
			case "active":
				aggregate.TotalActive = result.Count
			case "draft":
				aggregate.TotalDraft = result.Count
			case "inactive":
				aggregate.TotalInactive = result.Count
			}
		}
		mu.Unlock()
	}()

	// 4. Get last updated and today's stats
	wg.Add(1)
	go func() {
		defer wg.Done()
		// Use context with shorter timeout
		queryCtx, queryCancel := context.WithTimeout(ctx, 20*time.Second)
		defer queryCancel()

		// Last updated
		query1 := queryUtils.DynamicQuery{
			From:    "m_pasien",
			Fields:  []queryUtils.SelectField{{Expression: "MAX(date_updated)"}},
			Filters: filterGroups,
		}
		var lastUpdated sql.NullTime
		err := h.queryBuilder.ExecuteQueryRow(queryCtx, dbConn, query1, &lastUpdated)
		if err != nil {
			errChan <- fmt.Errorf("last updated query failed: %w", err)
			return
		}

		// Using QueryBuilder for today's statistics
		today := time.Now().Format("2006-01-02")

		// Query for created_today
		createdTodayQuery := queryUtils.DynamicQuery{
			From: "m_pasien",
			Fields: []queryUtils.SelectField{
				{Expression: "COUNT(*)", Alias: "count"},
			},
			Filters: append(filterGroups, queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "DATE(date_created)", Operator: queryUtils.OpEqual, Value: today},
				},
				LogicOp: "AND",
			}),
		}

		var createdToday int
		err = h.queryBuilder.ExecuteQueryRow(queryCtx, dbConn, createdTodayQuery, &createdToday)
		if err != nil {
			errChan <- fmt.Errorf("created today query failed: %w", err)
			return
		}

		// Query for updated_today (updated today but not created today)
		updatedTodayQuery := queryUtils.DynamicQuery{
			From: "m_pasien",
			Fields: []queryUtils.SelectField{
				{Expression: "COUNT(*)", Alias: "count"},
			},
			Filters: append(filterGroups, queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{Column: "DATE(date_updated)", Operator: queryUtils.OpEqual, Value: today},
					{Column: "DATE(date_created)", Operator: queryUtils.OpNotEqual, Value: today},
				},
				LogicOp: "AND",
			}),
		}

		var updatedToday int
		err = h.queryBuilder.ExecuteQueryRow(queryCtx, dbConn, updatedTodayQuery, &updatedToday)
		if err != nil {
			errChan <- fmt.Errorf("updated today query failed: %w", err)
			return
		}

		mu.Lock()
		if lastUpdated.Valid {
			aggregate.LastUpdated = &lastUpdated.Time
		}
		aggregate.CreatedToday = createdToday
		aggregate.UpdatedToday = updatedToday
		mu.Unlock()
	}()

	wg.Wait()
	close(errChan)

	for err := range errChan {
		if err != nil {
			return nil, err
		}
	}

	return aggregate, nil
}

// logAndRespondError logs an error and sends a JSON response
func (h *PasienHandler) logAndRespondError(c *gin.Context, message string, err error, statusCode int) {
	logger.Error(message, map[string]interface{}{"error": err.Error(), "status_code": statusCode})
	h.respondError(c, message, err, statusCode)
}

// respondError sends a standardized JSON error response
func (h *PasienHandler) respondError(c *gin.Context, message string, err error, statusCode int) {
	errorMessage := message
	if gin.Mode() == gin.ReleaseMode {
		errorMessage = "Internal server error"
	}
	c.JSON(statusCode, models.ErrorResponse{Error: errorMessage, Code: statusCode, Message: err.Error(), Timestamp: time.Now()})
}

// calculateMeta creates pagination metadata
func (h *PasienHandler) calculateMeta(limit, offset, total int) models.MetaResponse {
	totalPages, currentPage := 0, 1
	if limit > 0 {
		totalPages = (total + limit - 1) / limit
		currentPage = (offset / limit) + 1
	}
	return models.MetaResponse{
		Limit: limit, Offset: offset, Total: total, TotalPages: totalPages,
		CurrentPage: currentPage, HasNext: offset+limit < total, HasPrev: offset > 0,
	}
}

func (h *PasienHandler) GetPasienByNOMR(c *gin.Context) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	Nomr := c.Param("nomr")
	dbConn, err := h.db.GetSQLXDB("postgres_simrs")
	if err != nil {
		logger.Error("Database connection failed", map[string]interface{}{"error": err.Error()})
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Database connection failed"})
		return
	}
	if err != nil {
		logger.Error("Database connection failed", map[string]interface{}{"error": err.Error()})
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Database connection failed"})
		return
	}

	Pasien, err := h.Getpasien(ctx, dbConn, Nomr)
	if err != nil {
		if err == sql.ErrNoRows {
			c.JSON(http.StatusNotFound, gin.H{
				"error": "Pasien tidak ditemukan",
				"nomr":  Nomr,
			})
			return
		}

		logger.Error("Failed to get pasien", map[string]interface{}{
			"error": err.Error(),
			"nomr":  Nomr,
		})
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to retrieve pasien data"})
		return
	}

	logger.Info("Pasien data retrieved successfully", map[string]interface{}{
		"nomr": Nomr,
		"nama": Pasien.NamaLengkap,
	})

	c.JSON(http.StatusOK, gin.H{
		"message": "Data pasien berhasil diambil",
		"data":    Pasien,
	})

}

func (h *PasienHandler) Getpasien(ctx context.Context, dbConn *sqlx.DB, nomr string) (*pasienModels.PasienData, error) {
	query := `
		SELECT 
			mp.nomr,
			mp.nama,
			mp.notelp,
			mp.jeniskelamin,
			mp.tgllahir,
			mp.alamat,
			COALESCE(mp2.idprovinsi, 0) as idprovinsi,
			COALESCE(mp2.namaprovinsi, '') as namaprovinsi,
			COALESCE(mk2.idkota, 0) as idkota,
			COALESCE(mk2.namakota, '') as namakota,
			COALESCE(mk.idkecamatan, 0) as idkecamatan,
			COALESCE(mk.namakecamatan, '') as namakecamatan,
			COALESCE(mk3.idkelurahan, 0) as idkelurahan,
			COALESCE(mk3.namakelurahan, '') as namakelurahan
		FROM m_pasien mp 
		LEFT JOIN m_provinsi mp2 ON mp.kdprovinsi = mp2.idprovinsi 
		LEFT JOIN m_kecamatan mk ON mp.kdkecamatan = mk.idkecamatan 
		LEFT JOIN m_kota mk2 ON mk.idkota = mk2.idkota 
		LEFT JOIN m_kelurahan mk3 ON mp.kelurahan = mk3.idkelurahan 
		WHERE mp.nomr = $1
	`

	var pasien pasienModels.PasienData

	err := dbConn.QueryRowContext(ctx, query, nomr).Scan(
		&pasien.Nomr,
		&pasien.NamaLengkap,
		&pasien.NoTelp,
		&pasien.JenisKelamin,
		&pasien.TTL,
		&pasien.Alamat,
		&pasien.IdProvinsi,
		&pasien.NamaProvinsi,
		&pasien.IdKota,
		&pasien.NamaKota,
		&pasien.IdKecamatan,
		&pasien.NamaKecamatan,
		&pasien.IdKelurahan,
		&pasien.NamaKelurahan,
	)

	if err != nil {
		if err == sql.ErrNoRows {
			return nil, sql.ErrNoRows
		}
		return nil, fmt.Errorf("failed to query pasien: %w", err)
	}

	logger.Info("Pasien query executed successfully", map[string]interface{}{
		"nomr": nomr,
		"nama": pasien.NamaLengkap,
	})

	return &pasien, nil
}

func (h *PasienHandler) SearchPasienByNama(c *gin.Context) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	// Get query parameter
	nama := c.Query("nama")

	// Validasi minimal 2 karakter untuk search
	if len(nama) < 2 {
		c.JSON(http.StatusBadRequest, gin.H{
			"error":   "Minimal 2 karakter untuk pencarian",
			"message": "Silahkan ketik minimal 2 huruf",
		})
		return
	}

	dbConn, err := h.db.GetSQLXDB("postgres_simrs")
	if err != nil {
		logger.Error("Database connection failed", map[string]interface{}{"error": err.Error()})
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Database connection failed"})
		return
	}

	// Search pasien by nama
	pasienList, err := h.GetPasienByNamaPattern(ctx, dbConn, nama)
	if err != nil {
		if err == sql.ErrNoRows {
			c.JSON(http.StatusOK, gin.H{
				"message": "Tidak ada pasien ditemukan",
				"data":    []pasienModels.PasienData{},
				"meta": map[string]interface{}{
					"total":        0,
					"search_query": nama,
				},
			})
			return
		}

		logger.Error("Failed to search pasien", map[string]interface{}{
			"error": err.Error(),
			"nama":  nama,
		})
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to search pasien"})
		return
	}

	logger.Info("Pasien search completed", map[string]interface{}{
		"search_query": nama,
		"total_found":  len(pasienList),
	})

	c.JSON(http.StatusOK, gin.H{
		"message": "Data pasien berhasil ditemukan",
		"data":    pasienList,
		"meta": map[string]interface{}{
			"total":        len(pasienList),
			"search_query": nama,
		},
	})
}

func (h *PasienHandler) GetPasienByNamaPattern(ctx context.Context, dbConn *sqlx.DB, namaPattern string) ([]*pasienModels.PasienData, error) {
	searchPattern := "%" + namaPattern + "%"

	query := `
		SELECT 
			mp.nomr,
			mp.nama,
			mp.notelp,
			mp.jeniskelamin,
			mp.tgllahir,
			mp.alamat,
			mp2.idprovinsi,
			mp2.namaprovinsi,
			mk2.idkota,
			mk2.namakota,
			mk.idkecamatan,
			mk.namakecamatan,
			mk3.idkelurahan,
			mk3.namakelurahan
		FROM m_pasien mp 
		LEFT JOIN m_provinsi mp2 ON mp.kdprovinsi = mp2.idprovinsi 
		LEFT JOIN m_kecamatan mk ON mp.kdkecamatan = mk.idkecamatan 
		LEFT JOIN m_kota mk2 ON mk.idkota = mk2.idkota 
		LEFT JOIN m_kelurahan mk3 ON mp.kelurahan = mk3.idkelurahan 
		WHERE mp.nama ILIKE $1
		ORDER BY mp.nama ASC
		LIMIT 1
	`

	rows, err := dbConn.QueryContext(ctx, query, searchPattern)
	if err != nil {
		return nil, fmt.Errorf("failed to execute search query: %w", err)
	}
	defer rows.Close()

	var pasienList []*pasienModels.PasienData

	for rows.Next() {
		var pasien pasienModels.PasienData

		err := rows.Scan(
			&pasien.Nomr,
			&pasien.NamaLengkap,
			&pasien.NoTelp,
			&pasien.JenisKelamin,
			&pasien.TTL,
			&pasien.Alamat,
			&pasien.IdProvinsi,
			&pasien.NamaProvinsi,
			&pasien.IdKota,
			&pasien.NamaKota,
			&pasien.IdKecamatan,
			&pasien.NamaKecamatan,
			&pasien.IdKelurahan,
			&pasien.NamaKelurahan,
		)

		if err != nil {
			return nil, fmt.Errorf("failed to scan row: %w", err)
		}

		// Clean strings
		pasien.Nomr = cleanString(pasien.Nomr)
		pasien.NamaLengkap = cleanString(pasien.NamaLengkap)
		pasien.NoTelp = cleanString(pasien.NoTelp)
		pasien.JenisKelamin = cleanString(pasien.JenisKelamin)
		pasien.Alamat = cleanString(pasien.Alamat)
		pasien.NamaProvinsi = cleanString(pasien.NamaProvinsi)
		pasien.NamaKota = cleanString(pasien.NamaKota)
		pasien.NamaKecamatan = cleanString(pasien.NamaKecamatan)
		pasien.NamaKelurahan = cleanString(pasien.NamaKelurahan)

		pasienList = append(pasienList, &pasien)
	}

	if err = rows.Err(); err != nil {
		return nil, fmt.Errorf("rows iteration error: %w", err)
	}

	if len(pasienList) == 0 {
		return nil, sql.ErrNoRows
	}

	logger.Info("Search query executed successfully", map[string]interface{}{
		"pattern": namaPattern,
		"found":   len(pasienList),
	})

	return pasienList, nil
}

func cleanString(s string) string {
	// Trim leading dan trailing whitespace
	s = strings.TrimSpace(s)

	// Replace newline, carriage return, dan tab di tengah string dengan single space
	s = strings.ReplaceAll(s, "\n", " ")
	s = strings.ReplaceAll(s, "\r", " ")
	s = strings.ReplaceAll(s, "\t", " ")

	// Replace multiple spaces dengan single space
	s = strings.Join(strings.Fields(s), " ")

	return s
}