lti-api/internal/modules/inventory/transfers/services/transfer.service.go

package service

import (
	"context"
	"errors"
	"fmt"
	"mime/multipart"
	"strings"

	"github.com/go-playground/validator/v10"
	"github.com/gofiber/fiber/v2"
	"github.com/sirupsen/logrus"
	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
	m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
	rProductWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
	rStockTransfer "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/transfers/repositories"
	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/transfers/validations"
	rSupplier "gitlab.com/mbugroup/lti-api.git/internal/modules/master/suppliers/repositories"
	warehouseRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/master/warehouses/repositories"
	projectFlockKandangRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
	rStockLogs "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
	"gitlab.com/mbugroup/lti-api.git/internal/utils"

	"gorm.io/gorm"
)

type TransferService interface {
	GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.StockTransfer, int64, error)
	GetOne(ctx *fiber.Ctx, id uint) (*entity.StockTransfer, error)
	CreateOne(ctx *fiber.Ctx, req *validation.TransferRequest, files []*multipart.FileHeader) (*entity.StockTransfer, error)
}

type transferService struct {
	Log                           *logrus.Logger
	Validate                      *validator.Validate
	StockTransferRepo             rStockTransfer.StockTransferRepository
	StockTransferDetailRepo       rStockTransfer.StockTransferDetailRepository
	StockTransferDeliveryRepo     rStockTransfer.StockTransferDeliveryRepository
	StockTransferDeliveryItemRepo rStockTransfer.StockTransferDeliveryItemRepository
	StockLogsRepository           rStockLogs.StockLogRepository
	ProductWarehouseRepo          rProductWarehouse.ProductWarehouseRepository
	SupplierRepo                  rSupplier.SupplierRepository
	WarehouseRepo                 warehouseRepo.WarehouseRepository
	ProjectFlockKandangRepo       projectFlockKandangRepo.ProjectFlockKandangRepository
	ProjectFlockPopulationRepo    projectFlockKandangRepo.ProjectFlockPopulationRepository
	DocumentSvc                   commonSvc.DocumentService
	FifoStockV2Svc                commonSvc.FifoStockV2Service
	ExpenseBridge                 TransferExpenseBridge
}

func NewTransferService(validate *validator.Validate, stockTransferRepo rStockTransfer.StockTransferRepository, stockTransferDetailRepo rStockTransfer.StockTransferDetailRepository, stockTransferDeliveryRepo rStockTransfer.StockTransferDeliveryRepository, stockTransferDeliveryItemRepo rStockTransfer.StockTransferDeliveryItemRepository, stockLogsRepo rStockLogs.StockLogRepository, productWarehouseRepo rProductWarehouse.ProductWarehouseRepository, supplierRepo rSupplier.SupplierRepository, warehouseRepo warehouseRepo.WarehouseRepository, projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository, projectFlockPopulationRepo projectFlockKandangRepo.ProjectFlockPopulationRepository, documentSvc commonSvc.DocumentService, fifoStockV2Svc commonSvc.FifoStockV2Service, expenseBridge TransferExpenseBridge) TransferService {
	return &transferService{
		Log:                           utils.Log,
		Validate:                      validate,
		StockTransferRepo:             stockTransferRepo,
		StockTransferDetailRepo:       stockTransferDetailRepo,
		StockTransferDeliveryRepo:     stockTransferDeliveryRepo,
		StockTransferDeliveryItemRepo: stockTransferDeliveryItemRepo,
		StockLogsRepository:           stockLogsRepo,
		ProductWarehouseRepo:          productWarehouseRepo,
		SupplierRepo:                  supplierRepo,
		WarehouseRepo:                 warehouseRepo,
		ProjectFlockKandangRepo:       projectFlockKandangRepo,
		ProjectFlockPopulationRepo:    projectFlockPopulationRepo,
		DocumentSvc:                   documentSvc,
		FifoStockV2Svc:                fifoStockV2Svc,
		ExpenseBridge:                 expenseBridge,
	}
}

func (s transferService) withRelations(db *gorm.DB) *gorm.DB {
	return db.
		Preload("CreatedUser").
		Preload("FromWarehouse").
		Preload("FromWarehouse.Location").
		Preload("FromWarehouse.Area").
		Preload("ToWarehouse").
		Preload("ToWarehouse.Location").
		Preload("ToWarehouse.Area").
		Preload("Details").
		Preload("Details.Product").
		Preload("Details.ExpenseNonstock").
		Preload("Details.ExpenseNonstock.Expense").
		Preload("Details.ExpenseNonstock.Expense.Supplier").
		Preload("Deliveries.Items").
		Preload("Deliveries.Supplier").
		Preload("Deliveries.Documents", func(db *gorm.DB) *gorm.DB {
			return db.Where("documentable_type = ?", string(utils.DocumentableTypeTransfer))
		})
}

func (s transferService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.StockTransfer, int64, error) {
	if err := s.Validate.Struct(params); err != nil {
		return nil, 0, err
	}

	scope, err := m.ResolveLocationScope(c, s.StockTransferRepo.DB())
	if err != nil {
		return nil, 0, err
	}

	offset := (params.Page - 1) * params.Limit

	transfers, total, err := s.StockTransferRepo.GetAll(c.Context(), offset, params.Limit, func(db *gorm.DB) *gorm.DB {
		db = s.withRelations(db)
		if scope.Restrict {
			if len(scope.IDs) == 0 {
				return db.Where("1 = 0")
			}
			db = db.
				Joins("JOIN warehouses w_from ON w_from.id = stock_transfers.from_warehouse_id").
				Joins("JOIN warehouses w_to ON w_to.id = stock_transfers.to_warehouse_id").
				Where("w_from.location_id IN ? OR w_to.location_id IN ?", scope.IDs, scope.IDs)
		}
		if params.Search != "" {
			searchTerm := "%" + strings.TrimSpace(params.Search) + "%"
			db = db.Joins("LEFT JOIN warehouses AS from_warehouses ON from_warehouses.id = stock_transfers.from_warehouse_id").
				Joins("LEFT JOIN warehouses AS to_warehouses ON to_warehouses.id = stock_transfers.to_warehouse_id").
				Where("movement_number ILIKE ? OR from_warehouses.name ILIKE ? OR to_warehouses.name ILIKE ?",
					searchTerm, searchTerm, searchTerm)
		}
		return db.Order("created_at DESC").Order("updated_at DESC")
	})

	if err != nil {
		return nil, 0, err
	}

	return transfers, total, nil
}

func (s transferService) GetOne(c *fiber.Ctx, id uint) (*entity.StockTransfer, error) {
	scope, err := m.ResolveLocationScope(c, s.StockTransferRepo.DB())
	if err != nil {
		return nil, err
	}
	if scope.Restrict {
		if len(scope.IDs) == 0 {
			return nil, fiber.NewError(fiber.StatusNotFound, "Transfer not found")
		}
		var count int64
		if err := s.StockTransferRepo.DB().WithContext(c.Context()).
			Table("stock_transfers").
			Joins("JOIN warehouses w_from ON w_from.id = stock_transfers.from_warehouse_id").
			Joins("JOIN warehouses w_to ON w_to.id = stock_transfers.to_warehouse_id").
			Where("stock_transfers.id = ?", id).
			Where("w_from.location_id IN ? OR w_to.location_id IN ?", scope.IDs, scope.IDs).
			Count(&count).Error; err != nil {
			return nil, err
		}
		if count == 0 {
			return nil, fiber.NewError(fiber.StatusNotFound, "Transfer not found")
		}
	}

	transferPtr, err := s.StockTransferRepo.GetByID(c.Context(), id, func(db *gorm.DB) *gorm.DB {
		return s.withRelations(db)
	})
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("Transfer dengan ID %d tidak ditemukan", id))
		}
		s.Log.Errorf("Failed to fetch transfer by ID %d: %+v", id, err)
		return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data transfer")
	}

	return transferPtr, nil
}

func (s *transferService) CreateOne(c *fiber.Ctx, req *validation.TransferRequest, files []*multipart.FileHeader) (*entity.StockTransfer, error) {

	pwIDs := make([]uint, 0, len(req.Products))

	for _, product := range req.Products {
		sourcePW, err := s.ProductWarehouseRepo.GetProductWarehouseByProductAndWarehouseID(
			c.Context(), uint(product.ProductID), uint(req.SourceWarehouseID),
		)
		if err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Produk dengan ID %d tidak ditemukan di gudang asal (ID: %d)", product.ProductID, req.SourceWarehouseID))
			}
			s.Log.Errorf("Failed to fetch product warehouse for product_id=%d, warehouse_id=%d: %+v", product.ProductID, req.SourceWarehouseID, err)
			return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengecek stok produk")
		}
		if sourcePW.Quantity < product.ProductQty {
			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Stok produk %d di gudang asal tidak mencukupi. Tersedia: %.2f, Diminta: %.2f", product.ProductID, sourcePW.Quantity, product.ProductQty))
		}
		pwIDs = append(pwIDs, sourcePW.Id)
	}

	if err := commonSvc.EnsureProjectFlockNotClosedForProductWarehouses(
		c.Context(),
		s.StockTransferRepo.DB(),
		pwIDs,
	); err != nil {
		return nil, err
	}

	destPfkID, err := s.getActiveProjectFlockKandangID(c.Context(), uint(req.DestinationWarehouseID))
	if err != nil {
		return nil, err
	}

	if destPfkID > 0 {
		projectFlockKandang, err := s.ProjectFlockKandangRepo.GetByID(c.Context(), destPfkID)
		if err != nil {
			s.Log.Errorf("Failed to fetch project flock kandang by ID %d: %+v", destPfkID, err)
			return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data project flock")
		}
		if projectFlockKandang.ClosedAt != nil {
			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Project flock untuk gudang tujuan sudah ditutup (closing) pada %s", projectFlockKandang.ClosedAt.Format("2006-01-02")))
		}
	}

	actorID, err := m.ActorIDFromContext(c)
	if err != nil {
		return nil, err
	}

	deliveryQtyMap := make(map[uint]float64)
	for _, delivery := range req.Deliveries {
		for _, prod := range delivery.Products {
			deliveryQtyMap[prod.ProductID] += prod.ProductQty
		}
	}

	for _, product := range req.Products {
		if deliveryQtyMap[product.ProductID] > product.ProductQty {
			return nil, fiber.NewError(fiber.StatusBadRequest,
				fmt.Sprintf("Total qty delivery untuk produk %d (%v) melebihi qty transfer (%v)", product.ProductID, deliveryQtyMap[product.ProductID], product.ProductQty))
		}
	}

	for _, delivery := range req.Deliveries {

		if delivery.SupplierID == 0 {
			continue
		}

		if delivery.VehiclePlate == "" {
			return nil, fiber.NewError(fiber.StatusBadRequest, "Vehicle plate wajib diisi ketika supplier dipilih")
		}
		if delivery.DriverName == "" {
			return nil, fiber.NewError(fiber.StatusBadRequest, "Driver name wajib diisi ketika supplier dipilih")
		}
		if delivery.DeliveryCost <= 0 {
			return nil, fiber.NewError(fiber.StatusBadRequest, "Delivery cost harus lebih dari 0 ketika supplier dipilih")
		}
		if delivery.DeliveryCostPerItem <= 0 {
			return nil, fiber.NewError(fiber.StatusBadRequest, "Delivery cost per item harus lebih dari 0 ketika supplier dipilih")
		}

		supplier, err := s.SupplierRepo.GetByID(c.Context(), uint(delivery.SupplierID), nil)
		if err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Supplier dengan ID %d tidak ditemukan", delivery.SupplierID))
			}
			s.Log.Errorf("Failed to fetch supplier by ID %d: %+v", delivery.SupplierID, err)
			return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data supplier")
		}
		if supplier.Category != string(utils.SupplierCategoryBOP) {
			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Supplier '%s' (ID: %d) bukan kategori BOP. Kategori saat ini: %s", supplier.Name, delivery.SupplierID, supplier.Category))
		}
	}

	movementNumber, err := s.StockTransferRepo.GenerateMovementNumber(c.Context())
	if err != nil {
		s.Log.Errorf("Failed to generate movement number: %+v", err)
		return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat nomor transfer")
	}

	transferDate, _ := utils.ParseDateString(req.TransferDate)

	entityTransfer := &entity.StockTransfer{
		FromWarehouseId: uint64(req.SourceWarehouseID),
		ToWarehouseId:   uint64(req.DestinationWarehouseID),
		Reason:          req.TransferReason,
		TransferDate:    transferDate,
		MovementNumber:  movementNumber,
		CreatedBy:       uint64(actorID),
	}

	expensePayloads := make([]TransferExpenseReceivingPayload, 0)

	err = s.StockTransferRepo.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {

		stockTransferRepoTX := s.StockTransferRepo.WithTx(tx)
		stockTransferDetailRepoTX := s.StockTransferDetailRepo.WithTx(tx)
		stockTransferDeliveryRepoTX := s.StockTransferDeliveryRepo.WithTx(tx)
		stockTransferDeliveryItemRepoTX := s.StockTransferDeliveryItemRepo.WithTx(tx)
		productWarehouseRepoTX := rProductWarehouse.NewProductWarehouseRepository(tx)
		stocklogsRepoTx := s.StockLogsRepository.WithTx(tx)

		if err := stockTransferRepoTX.CreateOne(c.Context(), entityTransfer, nil); err != nil {
			return err
		}

		details := make([]*entity.StockTransferDetail, 0, len(req.Products))
		detailMap := make(map[uint64]*entity.StockTransferDetail)

		for _, product := range req.Products {

			sourcePW, err := productWarehouseRepoTX.GetProductWarehouseByProductAndWarehouseID(
				c.Context(), uint(product.ProductID), uint(req.SourceWarehouseID),
			)
			if err != nil {
				if errors.Is(err, gorm.ErrRecordNotFound) {
					return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Produk %d tidak ditemukan di gudang asal (ID: %d)", product.ProductID, req.SourceWarehouseID))
				}
				s.Log.Errorf("Failed to fetch source product warehouse for product_id=%d, warehouse_id=%d: %+v", product.ProductID, req.SourceWarehouseID, err)
				return fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data stok gudang asal")
			}

			destPW, err := productWarehouseRepoTX.GetProductWarehouseByProductAndWarehouseID(
				c.Context(), uint(product.ProductID), uint(req.DestinationWarehouseID),
			)
			if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
				s.Log.Errorf("Failed to fetch dest product warehouse for product_id=%d, warehouse_id=%d: %+v", product.ProductID, req.DestinationWarehouseID, err)
				return fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data stok gudang tujuan")
			}
			if errors.Is(err, gorm.ErrRecordNotFound) {
				ctx := c.Context()
				projectFlockKandangID, err := s.getActiveProjectFlockKandangID(ctx, uint(req.DestinationWarehouseID))
				if err != nil {
					return err
				}

				var pfkID *uint
				if projectFlockKandangID > 0 {
					pfkID = &projectFlockKandangID
				}

				destPW = &entity.ProductWarehouse{
					ProductId:             uint(product.ProductID),
					WarehouseId:           uint(req.DestinationWarehouseID),
					Quantity:              0,
					ProjectFlockKandangId: pfkID,
				}
				if err := productWarehouseRepoTX.CreateOne(c.Context(), destPW, nil); err != nil {
					s.Log.Errorf("Failed to create product warehouse for product_id=%d, warehouse_id=%d: %+v", product.ProductID, req.DestinationWarehouseID, err)
					return fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat data stok gudang tujuan")
				}
			}

			detail := &entity.StockTransferDetail{
				StockTransferId: entityTransfer.Id,
				ProductId:       uint64(product.ProductID),

				SourceProductWarehouseID: func() *uint64 { id := uint64(sourcePW.Id); return &id }(),
				UsageQty:                 0,
				PendingQty:               0,

				DestProductWarehouseID: func() *uint64 { id := uint64(destPW.Id); return &id }(),
				TotalQty:               0,
				TotalUsed:              0,
			}
			details = append(details, detail)
			detailMap[uint64(product.ProductID)] = detail
		}

		if err := stockTransferDetailRepoTX.CreateMany(c.Context(), details, nil); err != nil {
			return err
		}

		var deliveries []*entity.StockTransferDelivery
		for _, delivery := range req.Deliveries {
			supplierId := func() *uint64 {
				if delivery.SupplierID > 0 {
					id := uint64(delivery.SupplierID)
					return &id
				}
				return nil
			}()
			deliveries = append(deliveries, &entity.StockTransferDelivery{
				StockTransferId:   entityTransfer.Id,
				SupplierId:        supplierId,
				VehiclePlate:      delivery.VehiclePlate,
				DriverName:        delivery.DriverName,
				ShippingCostItem:  delivery.DeliveryCostPerItem,
				ShippingCostTotal: delivery.DeliveryCost,
			})
		}
		if err := stockTransferDeliveryRepoTX.CreateMany(c.Context(), deliveries, nil); err != nil {
			return err
		}

		var deliveryItems []*entity.StockTransferDeliveryItem

		for i, delivery := range deliveries {
			item := req.Deliveries[i]
			for _, prod := range item.Products {
				detail, ok := detailMap[uint64(prod.ProductID)]
				if !ok {
					return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Produk %d tidak ditemukan dalam daftar transfer untuk delivery #%d", prod.ProductID, i+1))
				}
				deliveryItems = append(deliveryItems, &entity.StockTransferDeliveryItem{
					StockTransferDeliveryId: delivery.Id,
					StockTransferDetailId:   detail.Id,
					Quantity:                prod.ProductQty,
				})
			}
		}
		if err := stockTransferDeliveryItemRepoTX.CreateMany(c.Context(), deliveryItems, nil); err != nil {
			return err
		}

		if s.DocumentSvc != nil && len(files) > 0 {

			for deliveryIdx, delivery := range deliveries {
				reqDelivery := req.Deliveries[deliveryIdx]

				if reqDelivery.DocumentIndex < 0 {
					continue
				}

				if reqDelivery.DocumentIndex >= len(files) {
					return fiber.NewError(fiber.StatusBadRequest,
						fmt.Sprintf("DocumentIndex %d untuk delivery %d melebihi jumlah file yang diupload (%d)",
							reqDelivery.DocumentIndex, deliveryIdx+1, len(files)))
				}

				file := files[reqDelivery.DocumentIndex]

				documentFiles := []commonSvc.DocumentFile{
					{
						File:  file,
						Type:  string(utils.DocumentTypeTransfer),
						Index: &reqDelivery.DocumentIndex,
					},
				}
				_, err := s.DocumentSvc.UploadDocuments(c.Context(), commonSvc.DocumentUploadRequest{
					DocumentableType: string(utils.DocumentableTypeTransfer),
					DocumentableID:   delivery.Id,
					CreatedBy:        &actorID,
					Files:            documentFiles,
				})
				if err != nil {
					s.Log.Errorf("Failed to upload document for delivery %d (delivery_id=%d, filename=%s): %+v",
						deliveryIdx+1, delivery.Id, file.Filename, err)
					return fiber.NewError(fiber.StatusInternalServerError, "Gagal mengunggah dokumen")
				}
			}
		}

		if s.FifoStockV2Svc == nil {
			return fiber.NewError(fiber.StatusInternalServerError, "FIFO v2 service is not available")
		}
		flagGroupByProduct := make(map[uint]string, len(req.Products))

		for _, product := range req.Products {
			detail := detailMap[uint64(product.ProductID)]
			if detail == nil || detail.SourceProductWarehouseID == nil || detail.DestProductWarehouseID == nil {
				return fiber.NewError(fiber.StatusInternalServerError, "Data transfer detail tidak valid")
			}

			flagGroupCode, ok := flagGroupByProduct[uint(product.ProductID)]
			if !ok {
				flagGroupCode, err = s.resolveTransferFlagGroup(c.Context(), tx, uint(product.ProductID))
				if err != nil {
					return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("FIFO v2 route tidak ditemukan untuk produk %d: %v", product.ProductID, err))
				}
				flagGroupByProduct[uint(product.ProductID)] = flagGroupCode
			}

			if err := tx.Model(&entity.StockTransferDetail{}).
				Where("id = ?", detail.Id).
				Updates(map[string]interface{}{
					"usage_qty":   product.ProductQty,
					"pending_qty": 0,
					"total_qty":   product.ProductQty,
				}).Error; err != nil {
				s.Log.Errorf("Failed to update transfer detail seed fields for detail_id=%d, product_id=%d: %+v", detail.Id, product.ProductID, err)
				return fiber.NewError(fiber.StatusInternalServerError, "Gagal memperbarui data tracking")
			}

			asOf := transferDate
			if _, err := s.FifoStockV2Svc.Reflow(c.Context(), commonSvc.FifoStockV2ReflowRequest{
				FlagGroupCode:      flagGroupCode,
				ProductWarehouseID: uint(*detail.SourceProductWarehouseID),
				AsOf:               &asOf,
				Tx:                 tx,
			}); err != nil {
				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Stok tidak mencukupi untuk produk %d di gudang asal. Error: %v", product.ProductID, err))
			}
			if _, err := s.FifoStockV2Svc.Reflow(c.Context(), commonSvc.FifoStockV2ReflowRequest{
				FlagGroupCode:      flagGroupCode,
				ProductWarehouseID: uint(*detail.DestProductWarehouseID),
				AsOf:               &asOf,
				Tx:                 tx,
			}); err != nil {
				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Gagal reflow stok tujuan untuk produk %d. Error: %v", product.ProductID, err))
			}

			type usageSnapshot struct {
				UsageQty   float64 `gorm:"column:usage_qty"`
				PendingQty float64 `gorm:"column:pending_qty"`
			}
			var usage usageSnapshot
			if err := tx.WithContext(c.Context()).
				Table("stock_transfer_details").
				Select("usage_qty, pending_qty").
				Where("id = ?", detail.Id).
				Take(&usage).Error; err != nil {
				s.Log.Errorf("Failed to read transfer usage snapshot detail_id=%d, product_id=%d: %+v", detail.Id, product.ProductID, err)
				return fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data tracking")
			}
			outUsageQty := usage.UsageQty
			outPendingQty := usage.PendingQty
			if outPendingQty > 1e-6 {
				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Stok tidak mencukupi untuk produk %d di gudang asal", product.ProductID))
			}

			stockLogDecrease := &entity.StockLog{
				ProductWarehouseId: uint(*detail.SourceProductWarehouseID),
				CreatedBy:          uint(actorID),
				Increase:           0,
				Decrease:           outUsageQty,
				LoggableType:       string(utils.StockLogTypeTransfer),
				LoggableId:         uint(detail.Id),
				Notes:              "",
			}
			stockLogs, err := s.StockLogsRepository.GetByProductWarehouse(c.Context(), uint(*detail.SourceProductWarehouseID), 1)
			if err != nil {
				s.Log.Errorf("Failed to get stock logs: %+v", err)
				return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
			}
			if len(stockLogs) > 0 {
				latestStockLog := stockLogs[0]
				stockLogDecrease.Stock = latestStockLog.Stock - stockLogDecrease.Decrease
			} else {
				stockLogDecrease.Stock -= stockLogDecrease.Decrease
			}

			if err := stocklogsRepoTx.CreateOne(c.Context(), stockLogDecrease, nil); err != nil {
				return fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat log stok keluar")
			}

			inAddedQty := outUsageQty

			stockLogIncrease := &entity.StockLog{
				ProductWarehouseId: uint(*detail.DestProductWarehouseID),
				CreatedBy:          uint(actorID),
				Increase:           inAddedQty,
				Decrease:           0,
				LoggableType:       string(utils.StockLogTypeTransfer),
				LoggableId:         uint(detail.Id),
				Notes:              "",
			}
			stockLogs, err = s.StockLogsRepository.GetByProductWarehouse(c.Context(), uint(*detail.DestProductWarehouseID), 1)
			if err != nil {
				s.Log.Errorf("Failed to get stock logs: %+v", err)
				return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
			}
			if len(stockLogs) > 0 {
				latestStockLog := stockLogs[0]
				stockLogIncrease.Stock = latestStockLog.Stock + stockLogIncrease.Increase
			} else {
				stockLogIncrease.Stock += stockLogIncrease.Increase
			}
			if err := stocklogsRepoTx.CreateOne(c.Context(), stockLogIncrease, nil); err != nil {
				return fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat log stok masuk")
			}
		}

		if len(req.Deliveries) > 0 {
			for _, delivery := range req.Deliveries {
				// Skip adding to expensePayloads if SupplierID is 0 (optional)
				if delivery.SupplierID == 0 {
					continue
				}

				for _, prod := range delivery.Products {
					detail := detailMap[uint64(prod.ProductID)]
					if detail == nil {
						continue
					}

					warehouseID := uint(req.DestinationWarehouseID)
					supplierID := uint(delivery.SupplierID)
					deliveredDate := transferDate
					deliveredQty := prod.ProductQty

					payload := TransferExpenseReceivingPayload{
						TransferDetailID: detail.Id,
						ProductID:        uint64(prod.ProductID),
						WarehouseID:      uint64(warehouseID),
						SupplierID:       uint64(supplierID),
						DeliveredQty:     deliveredQty,
						DeliveredDate:    &deliveredDate,
					}
					expensePayloads = append(expensePayloads, payload)
				}
			}
		}

		return nil
	})

	if err != nil {
		if fiberErr, ok := err.(*fiber.Error); ok {
			return nil, fiberErr
		}
		return nil, fiber.NewError(fiber.StatusInternalServerError, "Internal server error")
	}

	result, err := s.GetOne(c, uint(entityTransfer.Id))
	if err != nil {
		return nil, err
	}

	if len(expensePayloads) > 0 {
		if err := s.notifyExpenseItemsDelivered(c, entityTransfer.Id, expensePayloads); err != nil {
			s.Log.Errorf("Failed to sync expense for transfer_id=%d, movement_number=%s: %+v", entityTransfer.Id, entityTransfer.MovementNumber, err)
			return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal sinkronisasi data expense. Silakan cek manual di module expense")
		}
	}

	return result, nil
}

func (s *transferService) resolveTransferFlagGroup(
	ctx context.Context,
	tx *gorm.DB,
	productID uint,
) (string, error) {
	if productID == 0 {
		return "", fmt.Errorf("product id is required")
	}

	type row struct {
		FlagGroupCode string `gorm:"column:flag_group_code"`
	}
	var selected row
	err := tx.WithContext(ctx).
		Table("fifo_stock_v2_route_rules rr").
		Select("rr.flag_group_code").
		Joins("JOIN fifo_stock_v2_flag_groups fg ON fg.code = rr.flag_group_code AND fg.is_active = TRUE").
		Where("rr.is_active = TRUE").
		Where("rr.lane = ?", "USABLE").
		Where("rr.function_code = ?", "STOCK_TRANSFER_OUT").
		Where("rr.source_table = ?", "stock_transfer_details").
		Where(`
			EXISTS (
				SELECT 1
				FROM flags f
				JOIN fifo_stock_v2_flag_members fm ON fm.flag_name = f.name AND fm.is_active = TRUE
				WHERE f.flagable_type = ?
				  AND f.flagable_id = ?
				  AND fm.flag_group_code = rr.flag_group_code
			)
		`, entity.FlagableTypeProduct, productID).
		Order("rr.id ASC").
		Limit(1).
		Take(&selected).Error
	if err != nil {
		return "", err
	}

	return strings.TrimSpace(selected.FlagGroupCode), nil
}

func (s *transferService) notifyExpenseItemsDelivered(c *fiber.Ctx, transferID uint64, payloads []TransferExpenseReceivingPayload) error {
	if s.ExpenseBridge == nil || transferID == 0 || len(payloads) == 0 {
		return nil
	}
	return s.ExpenseBridge.OnItemsDelivered(c, transferID, payloads)
}

func (s *transferService) getActiveProjectFlockKandangID(ctx context.Context, warehouseID uint) (uint, error) {
	warehouse, err := s.WarehouseRepo.GetByID(ctx, warehouseID, nil)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return 0, fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("Gudang dengan ID %d tidak ditemukan", warehouseID))
		}
		s.Log.Errorf("Failed to fetch warehouse by ID %d: %+v", warehouseID, err)
		return 0, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data gudang")
	}

	if warehouse.KandangId == nil || *warehouse.KandangId == 0 {
		return 0, nil
	}

	projectFlockKandang, err := s.ProjectFlockKandangRepo.GetActiveByKandangID(ctx, uint(*warehouse.KandangId))
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return 0, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Tidak ada project flock aktif untuk kandang %d", *warehouse.KandangId))
		}
		s.Log.Errorf("Failed to fetch active project flock kandang for kandang_id=%d: %+v", *warehouse.KandangId, err)
		return 0, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data project flock")
	}

	return uint(projectFlockKandang.Id), nil
}