package repository

import (
	"context"
	"fmt"
	"time"

	"eslogad-be/internal/entities"

	"github.com/google/uuid"
	"gorm.io/gorm"
)

type LetterOutgoingRepository struct{ db *gorm.DB }

func NewLetterOutgoingRepository(db *gorm.DB) *LetterOutgoingRepository {
	return &LetterOutgoingRepository{db: db}
}

func (r *LetterOutgoingRepository) Create(ctx context.Context, e *entities.LetterOutgoing) error {
	db := DBFromContext(ctx, r.db)
	return db.WithContext(ctx).Create(e).Error
}

func (r *LetterOutgoingRepository) Get(ctx context.Context, id uuid.UUID) (*entities.LetterOutgoing, error) {
	db := DBFromContext(ctx, r.db)
	var e entities.LetterOutgoing
	if err := db.WithContext(ctx).
		Preload("Priority").
		Preload("ReceiverInstitution").
		Preload("Creator").
		Preload("ApprovalFlow").
		Preload("Recipients").
		Preload("Attachments").
		Preload("Approvals.Step").
		Preload("Approvals.Approver").
		Where("id = ? AND deleted_at IS NULL", id).
		First(&e).Error; err != nil {
		return nil, err
	}
	return &e, nil
}

func (r *LetterOutgoingRepository) GetByReferenceNumber(ctx context.Context, refNumber *string) (*entities.LetterOutgoing, error) {
	db := DBFromContext(ctx, r.db)
	var e entities.LetterOutgoing
	if err := db.WithContext(ctx).
		Preload("Priority").
		Preload("ReceiverInstitution").
		Preload("Creator").
		Preload("ApprovalFlow").
		Preload("Recipients").
		Preload("Attachments").
		Preload("Approvals.Step").
		Preload("Approvals.Approver").
		Where("reference_number = ? AND deleted_at IS NULL", refNumber).
		First(&e).Error; err != nil {
		return nil, err
	}
	return &e, nil
}

func (r *LetterOutgoingRepository) Update(ctx context.Context, e *entities.LetterOutgoing) error {
	db := DBFromContext(ctx, r.db)
	return db.WithContext(ctx).Model(&entities.LetterOutgoing{}).Where("id = ? AND deleted_at IS NULL", e.ID).Updates(e).Error
}

func (r *LetterOutgoingRepository) SoftDelete(ctx context.Context, id uuid.UUID) error {
	db := DBFromContext(ctx, r.db)
	now := time.Now()
	return db.WithContext(ctx).Model(&entities.LetterOutgoing{}).Where("id = ? AND deleted_at IS NULL", id).Update("deleted_at", now).Error
}

func (r *LetterOutgoingRepository) BulkSoftDelete(ctx context.Context, ids []uuid.UUID) error {
	if len(ids) == 0 {
		return nil
	}

	db := DBFromContext(ctx, r.db)
	now := time.Now()
	return db.WithContext(ctx).Model(&entities.LetterOutgoing{}).Where("id IN ? AND deleted_at IS NULL", ids).Update("deleted_at", now).Error
}

func (r *LetterOutgoingRepository) BulkArchive(ctx context.Context, letterIDs []uuid.UUID) (int64, error) {
	db := DBFromContext(ctx, r.db)
	now := time.Now()
	result := db.WithContext(ctx).
		Model(&entities.LetterOutgoing{}).
		Where("id IN ? AND deleted_at IS NULL", letterIDs).
		Updates(map[string]interface{}{
			"is_archived": true,
			"archived_at": now,
		})
	return result.RowsAffected, result.Error
}

func (r *LetterOutgoingRepository) Archive(ctx context.Context, letterID uuid.UUID) error {
	db := DBFromContext(ctx, r.db)
	now := time.Now()
	return db.WithContext(ctx).
		Model(&entities.LetterOutgoing{}).
		Where("id = ? AND deleted_at IS NULL", letterID).
		Updates(map[string]interface{}{
			"is_archived": true,
			"archived_at": now,
		}).Error
}

func (r *LetterOutgoingRepository) BulkArchiveForUser(ctx context.Context, letterIDs []uuid.UUID, userID uuid.UUID) (int64, error) {
	db := DBFromContext(ctx, r.db)
	// Archive only the recipient records for the specific user
	// Note: letter_incoming_recipients uses recipient_user_id column
	result := db.WithContext(ctx).
		Model(&entities.LetterOutgoingRecipient{}).
		Where("letter_id IN ? AND user_id = ?", letterIDs, userID).
		Update("is_archived", true)
	return result.RowsAffected, result.Error
}

func (r *LetterOutgoingRepository) GetWithRelations(ctx context.Context, id uuid.UUID, relations []string) (*entities.LetterOutgoing, error) {
	db := DBFromContext(ctx, r.db)
	query := db.WithContext(ctx).Where("id = ? AND deleted_at IS NULL", id)

	// Preload all specified relations
	for _, relation := range relations {
		query = query.Preload(relation)
	}

	var e entities.LetterOutgoing
	if err := query.First(&e).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, gorm.ErrRecordNotFound
		}
		return nil, err
	}

	return &e, nil
}

type ListOutgoingLettersFilter struct {
	Status                *string
	Query                 *string
	CreatedBy             *uuid.UUID
	DepartmentID          *uuid.UUID
	UserID                *uuid.UUID
	ReceiverInstitutionID *uuid.UUID
	FromDate              *time.Time
	ToDate                *time.Time
	PriorityID            *uuid.UUID
	PriorityIDs           []uuid.UUID
	SortBy                *string
	SortOrder             *string
	IsArchived            *bool
	IsRead                *bool
}

func (r *LetterOutgoingRepository) List(ctx context.Context, filter ListOutgoingLettersFilter, limit, offset int) ([]entities.LetterOutgoing, int64, error) {
	db := DBFromContext(ctx, r.db)
	query := db.WithContext(ctx).Model(&entities.LetterOutgoing{}).Where("deleted_at IS NULL")

	// Apply is_archived filter
	if filter.IsArchived != nil {
		if *filter.IsArchived {
			query = query.Where("letter_outgoing_recipients.is_archived = ?", true)
		} else {
			query = query.Where("letter_outgoing_recipients.is_archived = ? OR letter_outgoing_recipients.is_archived IS NULL", false)
		}
	}

	if filter.Query != nil {
		q := "%" + *filter.Query + "%"
		query = query.Where("subject ILIKE ? OR reference_number ILIKE ? OR letter_number ILIKE ?", q, q, q)
	}
	if filter.CreatedBy != nil {
		query = query.Where("created_by = ?", *filter.CreatedBy)
	}
	// Filter by UserID through recipients
	if filter.UserID != nil {
		query = query.Joins("LEFT JOIN letter_outgoing_recipients ON letter_outgoing_recipients.letter_id = letters_outgoing.id")
		query = query.Where("letter_outgoing_recipients.user_id = ?", *filter.UserID)

		fmt.Printf("[DEBUG] filter.UserID: %v\n", filter.UserID)
		fmt.Printf("[DEBUG] filter.isRead: %v\n", filter.IsRead)

		// Tambahkan filter IsRead
		if filter.IsRead != nil {
			if *filter.IsRead {
				query = query.Where("letter_outgoing_recipients.read_at IS NOT NULL")
			} else {
				query = query.Where("letter_outgoing_recipients.read_at IS NULL")
			}
		}

	}

	if filter.Status != nil {
		query = query.Joins("LEFT JOIN letter_outgoing_approvals ON letter_outgoing_approvals.letter_id = letters_outgoing.id")
		query = query.Where("letter_outgoing_approvals.approver_id = ?", *filter.UserID)

		query = query.Where("letter_outgoing_approvals.status = ?", *filter.Status)

		query = query.Distinct()
	}

	if filter.ReceiverInstitutionID != nil {
		query = query.Where("receiver_institution_id = ?", *filter.ReceiverInstitutionID)
	}
	if filter.PriorityID != nil {
		query = query.Where("priority_id = ?", *filter.PriorityID)
	}
	if len(filter.PriorityIDs) > 0 {
		query = query.Where("priority_id IN ?", filter.PriorityIDs)
	}
	fmt.Printf("Priority %s", filter.PriorityIDs)
	if filter.FromDate != nil {
		query = query.Where("issue_date >= ?", *filter.FromDate)
	}
	if filter.ToDate != nil {
		query = query.Where("issue_date <= ?", *filter.ToDate)
	}

	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, err
	}

	orderBy := "created_at DESC" // default
	if filter.SortBy != nil {
		sortField := *filter.SortBy
		sortDirection := "ASC"
		if filter.SortOrder != nil && (*filter.SortOrder == "desc" || *filter.SortOrder == "DESC") {
			sortDirection = "DESC"
		}

		switch sortField {
		case "letter_number":
			orderBy = "letter_number " + sortDirection
		case "subject":
			orderBy = "subject " + sortDirection
		case "issue_date":
			orderBy = "issue_date " + sortDirection
		case "status":
			orderBy = "status " + sortDirection
		case "created_at":
			orderBy = "created_at " + sortDirection
		default:
			orderBy = "created_at " + sortDirection
		}
	}

	var list []entities.LetterOutgoing
	if err := query.
		Preload("Priority").
		Preload("ReceiverInstitution").
		Preload("Creator").
		Preload("Creator.Profile").
		Preload("Creator.Departments").
		Preload("Recipients").
		Preload("Recipients.User").
		Preload("Recipients.Department").
		Preload("Attachments").
		Preload("Approvals.Step").
		Preload("Approvals.Approver").
		Order(orderBy).
		Limit(limit).
		Offset(offset).
		Find(&list).Error; err != nil {
		return nil, 0, err
	}
	return list, total, nil
}

func (r *LetterOutgoingRepository) ListAll(ctx context.Context, filter ListOutgoingLettersFilter, limit, offset int) ([]entities.LetterOutgoing, int64, error) {
	db := DBFromContext(ctx, r.db)
	query := db.WithContext(ctx).Model(&entities.LetterOutgoing{}).Where("deleted_at IS NULL")

	// Apply search query filter
	if filter.Query != nil {
		q := "%" + *filter.Query + "%"
		query = query.Where("subject ILIKE ? OR reference_number ILIKE ? OR letter_number ILIKE ?", q, q, q)
	}

	// Filter by creator (if admin wants to see letters from specific creator)
	if filter.CreatedBy != nil {
		query = query.Where("created_by = ?", *filter.CreatedBy)
	}

	// Filter by receiver institution
	if filter.ReceiverInstitutionID != nil {
		query = query.Where("receiver_institution_id = ?", *filter.ReceiverInstitutionID)
	}

	// Filter by priority
	if filter.PriorityID != nil {
		query = query.Where("priority_id = ?", *filter.PriorityID)
	}

	// Filter by multiple priorities
	if len(filter.PriorityIDs) > 0 {
		query = query.Where("priority_id IN ?", filter.PriorityIDs)
	}

	// Date range filters
	if filter.FromDate != nil {
		query = query.Where("issue_date >= ?", *filter.FromDate)
	}
	if filter.ToDate != nil {
		query = query.Where("issue_date <= ?", *filter.ToDate)
	}

	// Filter by approval status (if admin wants to see letters with specific approval status)
	// Note: This is different from user-specific approval status
	if filter.Status != nil {
		query = query.Joins("LEFT JOIN letter_outgoing_approvals ON letter_outgoing_approvals.letter_id = letters_outgoing.id").
			Where("letter_outgoing_approvals.status = ?", *filter.Status).
			Distinct()
	}

	// Get total count
	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, err
	}

	// Prepare sorting
	orderBy := "created_at DESC" // default
	if filter.SortBy != nil {
		sortField := *filter.SortBy
		sortDirection := "ASC"
		if filter.SortOrder != nil && (*filter.SortOrder == "desc" || *filter.SortOrder == "DESC") {
			sortDirection = "DESC"
		}

		switch sortField {
		case "letter_number":
			orderBy = "letter_number " + sortDirection
		case "subject":
			orderBy = "subject " + sortDirection
		case "issue_date":
			orderBy = "issue_date " + sortDirection
		case "status":
			orderBy = "status " + sortDirection
		case "created_at":
			orderBy = "created_at " + sortDirection
		default:
			orderBy = "created_at " + sortDirection
		}
	}

	// Get paginated data with all relations
	var list []entities.LetterOutgoing
	if err := query.
		Preload("Priority").
		Preload("ReceiverInstitution").
		Preload("Creator").
		Preload("Creator.Profile").
		Preload("Creator.Departments").
		Preload("Recipients").
		Preload("Recipients.User").
		Preload("Recipients.Department").
		Preload("Attachments").
		Preload("Approvals").
		Preload("Approvals.Step").
		Preload("Approvals.Approver").
		Order(orderBy).
		Limit(limit).
		Offset(offset).
		Find(&list).Error; err != nil {
		return nil, 0, err
	}

	return list, total, nil
}

func (r *LetterOutgoingRepository) Search(ctx context.Context, filters map[string]interface{}, limit, offset int, sortBy, sortOrder string) ([]entities.LetterOutgoing, int64, error) {
	db := DBFromContext(ctx, r.db)
	query := db.WithContext(ctx).Model(&entities.LetterOutgoing{}).Where("deleted_at IS NULL")

	// Apply search filters
	if q, ok := filters["query"]; ok && q != "" {
		searchTerm := "%" + q.(string) + "%"
		query = query.Where("subject ILIKE ? OR reference_number ILIKE ? OR letter_number ILIKE ? OR description ILIKE ? OR receiver_name ILIKE ?", searchTerm, searchTerm, searchTerm, searchTerm, searchTerm)
	}

	if letterNumber, ok := filters["letter_number"]; ok && letterNumber != "" {
		query = query.Where("letter_number ILIKE ?", "%"+letterNumber.(string)+"%")
	}

	if subject, ok := filters["subject"]; ok && subject != "" {
		query = query.Where("subject ILIKE ?", "%"+subject.(string)+"%")
	}

	if status, ok := filters["status"]; ok && status != "" {
		query = query.Where("status = ?", status)
	}

	if priorityID, ok := filters["priority_id"]; ok {
		query = query.Where("priority_id = ?", priorityID)
	}

	if institutionID, ok := filters["receiver_institution_id"]; ok {
		query = query.Where("receiver_institution_id = ?", institutionID)
	}

	if createdBy, ok := filters["created_by"]; ok {
		query = query.Where("created_by = ?", createdBy)
	}

	if dateFrom, ok := filters["date_from"]; ok {
		query = query.Where("issue_date >= ?", dateFrom)
	}

	if dateTo, ok := filters["date_to"]; ok {
		query = query.Where("issue_date <= ?", dateTo)
	}

	// Apply user context filters if present
	if userContext, ok := filters["user_context"]; ok {
		if ctx, ok := userContext.(map[string]interface{}); ok {
			if userID, ok := ctx["user_id"]; ok {
				// User can see: letters created by them OR letters where they are recipients
				subQuery := db.Model(&entities.LetterOutgoingRecipient{}).Select("letter_id").Where("user_id = ?", userID)
				query = query.Where("created_by = ? OR id IN (?)", userID, subQuery)
			}
		}
	}

	// Count total results
	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, err
	}

	// Apply sorting
	if sortBy == "" {
		sortBy = "created_at"
	}
	if sortOrder == "" {
		sortOrder = "desc"
	}

	validSortFields := map[string]bool{
		"letter_number": true,
		"subject":       true,
		"issue_date":    true,
		"status":        true,
		"created_at":    true,
		"updated_at":    true,
	}

	if !validSortFields[sortBy] {
		sortBy = "created_at"
	}

	if sortOrder != "asc" && sortOrder != "desc" {
		sortOrder = "desc"
	}

	orderBy := sortBy + " " + sortOrder

	// Execute query with preloads
	var letters []entities.LetterOutgoing
	if err := query.
		Preload("Priority").
		Preload("ReceiverInstitution").
		Preload("Creator").
		Preload("Creator.Profile").
		Order(orderBy).
		Limit(limit).
		Offset(offset).
		Find(&letters).Error; err != nil {
		return nil, 0, err
	}

	return letters, total, nil
}

func (r *LetterOutgoingRepository) UpdateStatus(ctx context.Context, id uuid.UUID, status entities.LetterOutgoingStatus) error {
	db := DBFromContext(ctx, r.db)
	return db.WithContext(ctx).Model(&entities.LetterOutgoing{}).Where("id = ? AND deleted_at IS NULL", id).Update("status", status).Error
}

type LetterOutgoingAttachmentRepository struct{ db *gorm.DB }

func NewLetterOutgoingAttachmentRepository(db *gorm.DB) *LetterOutgoingAttachmentRepository {
	return &LetterOutgoingAttachmentRepository{db: db}
}

func (r *LetterOutgoingAttachmentRepository) Create(ctx context.Context, e *entities.LetterOutgoingAttachment) error {
	db := DBFromContext(ctx, r.db)
	return db.WithContext(ctx).Create(e).Error
}

func (r *LetterOutgoingAttachmentRepository) CreateBulk(ctx context.Context, list []entities.LetterOutgoingAttachment) error {
	db := DBFromContext(ctx, r.db)
	if len(list) == 0 {
		return nil
	}
	return db.WithContext(ctx).Create(&list).Error
}

func (r *LetterOutgoingAttachmentRepository) ListByLetter(ctx context.Context, letterID uuid.UUID) ([]entities.LetterOutgoingAttachment, error) {
	db := DBFromContext(ctx, r.db)
	var list []entities.LetterOutgoingAttachment
	if err := db.WithContext(ctx).Where("letter_id = ?", letterID).Order("uploaded_at ASC").Find(&list).Error; err != nil {
		return nil, err
	}
	return list, nil
}

func (r *LetterOutgoingAttachmentRepository) Delete(ctx context.Context, id uuid.UUID) error {
	db := DBFromContext(ctx, r.db)
	return db.WithContext(ctx).Where("id = ?", id).Delete(&entities.LetterOutgoingAttachment{}).Error
}

// ListByLetterIDs fetches attachments for multiple letters in a single query
func (r *LetterOutgoingAttachmentRepository) ListByLetterIDs(ctx context.Context, letterIDs []uuid.UUID) (map[uuid.UUID][]entities.LetterOutgoingAttachment, error) {
	if len(letterIDs) == 0 {
		return make(map[uuid.UUID][]entities.LetterOutgoingAttachment), nil
	}

	db := DBFromContext(ctx, r.db)
	var attachments []entities.LetterOutgoingAttachment
	if err := db.WithContext(ctx).Where("letter_id IN ?", letterIDs).Order("uploaded_at ASC").Find(&attachments).Error; err != nil {
		return nil, err
	}

	// Group attachments by letter ID
	result := make(map[uuid.UUID][]entities.LetterOutgoingAttachment)
	for _, att := range attachments {
		result[att.LetterID] = append(result[att.LetterID], att)
	}

	return result, nil
}

type LetterOutgoingFinalAttachmentRepository struct{ db *gorm.DB }

func NewLetterOutgoingFinalAttachmentRepository(db *gorm.DB) *LetterOutgoingFinalAttachmentRepository {
	return &LetterOutgoingFinalAttachmentRepository{db: db}
}

func (r *LetterOutgoingFinalAttachmentRepository) Create(ctx context.Context, e *entities.LetterOutgoingFinalAttachment) error {
	db := DBFromContext(ctx, r.db)
	return db.WithContext(ctx).Create(e).Error
}

func (r *LetterOutgoingFinalAttachmentRepository) CreateBulk(ctx context.Context, list []entities.LetterOutgoingFinalAttachment) error {
	db := DBFromContext(ctx, r.db)
	if len(list) == 0 {
		return nil
	}
	return db.WithContext(ctx).Create(&list).Error
}

func (r *LetterOutgoingFinalAttachmentRepository) ListByLetter(ctx context.Context, letterID uuid.UUID) ([]entities.LetterOutgoingFinalAttachment, error) {
	db := DBFromContext(ctx, r.db)
	var list []entities.LetterOutgoingFinalAttachment
	if err := db.WithContext(ctx).Where("letter_id = ?", letterID).Order("uploaded_at ASC").Find(&list).Error; err != nil {
		return nil, err
	}
	return list, nil
}

func (r *LetterOutgoingFinalAttachmentRepository) Delete(ctx context.Context, id uuid.UUID) error {
	db := DBFromContext(ctx, r.db)
	return db.WithContext(ctx).Where("id = ?", id).Delete(&entities.LetterOutgoingAttachment{}).Error
}

// ListByLetterIDs fetches attachments for multiple letters in a single query
func (r *LetterOutgoingFinalAttachmentRepository) ListByLetterIDs(ctx context.Context, letterIDs []uuid.UUID) (map[uuid.UUID][]entities.LetterOutgoingFinalAttachment, error) {
	if len(letterIDs) == 0 {
		return make(map[uuid.UUID][]entities.LetterOutgoingFinalAttachment), nil
	}

	db := DBFromContext(ctx, r.db)
	var attachments []entities.LetterOutgoingFinalAttachment
	if err := db.WithContext(ctx).Where("letter_id IN ?", letterIDs).Order("uploaded_at ASC").Find(&attachments).Error; err != nil {
		return nil, err
	}

	// Group attachments by letter ID
	result := make(map[uuid.UUID][]entities.LetterOutgoingFinalAttachment)
	for _, att := range attachments {
		result[att.LetterID] = append(result[att.LetterID], att)
	}

	return result, nil
}

type LetterOutgoingRecipientRepository struct{ db *gorm.DB }

func NewLetterOutgoingRecipientRepository(db *gorm.DB) *LetterOutgoingRecipientRepository {
	return &LetterOutgoingRecipientRepository{db: db}
}

func (r *LetterOutgoingRecipientRepository) Create(ctx context.Context, e *entities.LetterOutgoingRecipient) error {
	db := DBFromContext(ctx, r.db)
	return db.WithContext(ctx).Create(e).Error
}

func (r *LetterOutgoingRecipientRepository) CreateBulk(ctx context.Context, list []entities.LetterOutgoingRecipient) error {
	db := DBFromContext(ctx, r.db)
	if len(list) == 0 {
		return nil
	}
	return db.WithContext(ctx).Create(&list).Error
}

func (r *LetterOutgoingRecipientRepository) CountUnreadByUser(ctx context.Context, userID uuid.UUID) (int, error) {
	db := DBFromContext(ctx, r.db)
	var count int64

	sql := `
    WITH valid_recipients AS (
        SELECT lor.id, lor.letter_id, lor.read_at, lor.created_at,
               ROW_NUMBER() OVER (PARTITION BY lor.letter_id ORDER BY lor.created_at DESC) as rn
        FROM letter_outgoing_recipients lor
        INNER JOIN letters_outgoing l ON l.id = lor.letter_id AND l.deleted_at IS NULL
        WHERE lor.user_id = ?
    )
    SELECT COUNT(*) 
    FROM valid_recipients
    WHERE rn = 1 AND read_at IS NULL
    `

	if err := db.WithContext(ctx).Raw(sql, userID).Scan(&count).Error; err != nil {
		return 0, err
	}
	return int(count), nil
}

func (r *LetterOutgoingRecipientRepository) MarkAsRead(ctx context.Context, letterID, userID uuid.UUID) error {
	db := DBFromContext(ctx, r.db)
	now := time.Now()
	return db.WithContext(ctx).
		Model(&entities.LetterOutgoingRecipient{}).
		Where("letter_id = ? AND user_id = ?", letterID, userID).
		Update("read_at", now).Error
}

func (r *LetterOutgoingRecipientRepository) ListByLetter(ctx context.Context, letterID uuid.UUID) ([]entities.LetterOutgoingRecipient, error) {
	db := DBFromContext(ctx, r.db)
	var list []entities.LetterOutgoingRecipient
	if err := db.WithContext(ctx).
		Preload("User").
		Preload("Department").
		Where("letter_id = ?", letterID).
		Order("is_primary DESC, created_at ASC").
		Find(&list).Error; err != nil {
		return nil, err
	}
	return list, nil
}

func (r *LetterOutgoingRecipientRepository) Update(ctx context.Context, e *entities.LetterOutgoingRecipient) error {
	db := DBFromContext(ctx, r.db)
	return db.WithContext(ctx).Model(&entities.LetterOutgoingRecipient{}).Where("id = ?", e.ID).Updates(e).Error
}

func (r *LetterOutgoingRecipientRepository) Delete(ctx context.Context, id uuid.UUID) error {
	db := DBFromContext(ctx, r.db)
	return db.WithContext(ctx).Where("id = ?", id).Delete(&entities.LetterOutgoingRecipient{}).Error
}

func (r *LetterOutgoingRecipientRepository) DeleteByLetter(ctx context.Context, letterID uuid.UUID) error {
	db := DBFromContext(ctx, r.db)
	return db.WithContext(ctx).Where("letter_id = ?", letterID).Delete(&entities.LetterOutgoingRecipient{}).Error
}

// ListByLetterIDs fetches recipients for multiple letters in a single query
func (r *LetterOutgoingRecipientRepository) ListByLetterIDs(ctx context.Context, letterIDs []uuid.UUID) (map[uuid.UUID][]entities.LetterOutgoingRecipient, error) {
	if len(letterIDs) == 0 {
		return make(map[uuid.UUID][]entities.LetterOutgoingRecipient), nil
	}

	db := DBFromContext(ctx, r.db)
	var recipients []entities.LetterOutgoingRecipient
	if err := db.WithContext(ctx).
		Preload("User").
		Preload("User.Profile").
		Preload("Department").
		Where("letter_id IN ?", letterIDs).
		Order("is_primary DESC, created_at ASC").
		Find(&recipients).Error; err != nil {
		return nil, err
	}

	// Group recipients by letter ID
	result := make(map[uuid.UUID][]entities.LetterOutgoingRecipient)
	for _, rec := range recipients {
		result[rec.LetterID] = append(result[rec.LetterID], rec)
	}

	return result, nil
}

type LetterOutgoingDiscussionRepository struct{ db *gorm.DB }

func NewLetterOutgoingDiscussionRepository(db *gorm.DB) *LetterOutgoingDiscussionRepository {
	return &LetterOutgoingDiscussionRepository{db: db}
}

func (r *LetterOutgoingDiscussionRepository) Create(ctx context.Context, e *entities.LetterOutgoingDiscussion) error {
	db := DBFromContext(ctx, r.db)
	return db.WithContext(ctx).Create(e).Error
}

func (r *LetterOutgoingDiscussionRepository) Get(ctx context.Context, id uuid.UUID) (*entities.LetterOutgoingDiscussion, error) {
	db := DBFromContext(ctx, r.db)
	var e entities.LetterOutgoingDiscussion
	if err := db.WithContext(ctx).
		Preload("User").
		Preload("Attachments").
		Where("id = ?", id).
		First(&e).Error; err != nil {
		return nil, err
	}
	return &e, nil
}

func (r *LetterOutgoingDiscussionRepository) ListByLetter(ctx context.Context, letterID uuid.UUID) ([]entities.LetterOutgoingDiscussion, error) {
	db := DBFromContext(ctx, r.db)
	var list []entities.LetterOutgoingDiscussion
	if err := db.WithContext(ctx).
		Preload("User").
		Preload("Attachments").
		Preload("Replies.User").
		Where("letter_id = ? AND parent_id IS NULL", letterID).
		Order("created_at DESC").
		Find(&list).Error; err != nil {
		return nil, err
	}
	return list, nil
}

func (r *LetterOutgoingRecipientRepository) GetByLetterIDsAndUser(ctx context.Context, letterIDs []uuid.UUID, userID uuid.UUID) (map[uuid.UUID]*entities.LetterOutgoingRecipient, error) {
	if len(letterIDs) == 0 {
		return make(map[uuid.UUID]*entities.LetterOutgoingRecipient), nil
	}

	db := DBFromContext(ctx, r.db)
	var recipients []entities.LetterOutgoingRecipient

	if err := db.WithContext(ctx).
		Where(`id IN (
           SELECT id FROM (
               SELECT id, ROW_NUMBER() OVER (PARTITION BY letter_id ORDER BY created_at DESC) as rn
               FROM letter_outgoing_recipients 
               WHERE letter_id IN ? AND user_id = ?
           ) t WHERE rn = 1
       )`, letterIDs, userID).
		Find(&recipients).Error; err != nil {
		return nil, err
	}

	result := make(map[uuid.UUID]*entities.LetterOutgoingRecipient)
	for i := range recipients {
		result[recipients[i].LetterID] = &recipients[i]
	}

	return result, nil
}

func (r *LetterOutgoingDiscussionRepository) Update(ctx context.Context, e *entities.LetterOutgoingDiscussion) error {
	db := DBFromContext(ctx, r.db)
	now := time.Now()
	e.EditedAt = &now
	return db.WithContext(ctx).Model(&entities.LetterOutgoingDiscussion{}).Where("id = ?", e.ID).Updates(e).Error
}

func (r *LetterOutgoingDiscussionRepository) Delete(ctx context.Context, id uuid.UUID) error {
	db := DBFromContext(ctx, r.db)
	return db.WithContext(ctx).Where("id = ?", id).Delete(&entities.LetterOutgoingDiscussion{}).Error
}

type LetterOutgoingDiscussionAttachmentRepository struct{ db *gorm.DB }

func NewLetterOutgoingDiscussionAttachmentRepository(db *gorm.DB) *LetterOutgoingDiscussionAttachmentRepository {
	return &LetterOutgoingDiscussionAttachmentRepository{db: db}
}

func (r *LetterOutgoingDiscussionAttachmentRepository) CreateBulk(ctx context.Context, list []entities.LetterOutgoingDiscussionAttachment) error {
	db := DBFromContext(ctx, r.db)
	if len(list) == 0 {
		return nil
	}
	return db.WithContext(ctx).Create(&list).Error
}

type LetterOutgoingActivityLogRepository struct{ db *gorm.DB }

func NewLetterOutgoingActivityLogRepository(db *gorm.DB) *LetterOutgoingActivityLogRepository {
	return &LetterOutgoingActivityLogRepository{db: db}
}

func (r *LetterOutgoingActivityLogRepository) Create(ctx context.Context, e *entities.LetterOutgoingActivityLog) error {
	db := DBFromContext(ctx, r.db)
	return db.WithContext(ctx).Create(e).Error
}

func (r *LetterOutgoingActivityLogRepository) ListByLetter(ctx context.Context, letterID uuid.UUID) ([]entities.LetterOutgoingActivityLog, error) {
	db := DBFromContext(ctx, r.db)
	var list []entities.LetterOutgoingActivityLog
	if err := db.WithContext(ctx).
		Preload("ActorUser").
		Preload("ActorDepartment").
		Where("letter_id = ?", letterID).
		Order("occurred_at DESC").
		Find(&list).Error; err != nil {
		return nil, err
	}
	return list, nil
}