lti-api/internal/modules/production/chickins/services/chickin.service.go

package service

import (
	"errors"
	"fmt"
	"strings"

	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
	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"
	KandangRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/master/kandangs/repositories"
	rWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/master/warehouses/repositories"
	repository "gitlab.com/mbugroup/lti-api.git/internal/modules/production/chickins/repositories"
	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/production/chickins/validations"
	rProjectFlock "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
	"gitlab.com/mbugroup/lti-api.git/internal/utils"

	"github.com/go-playground/validator/v10"
	"github.com/gofiber/fiber/v2"
	"github.com/sirupsen/logrus"
	"gorm.io/gorm"
)

type ChickinService interface {
	GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.ProjectChickin, int64, error)
	GetOne(ctx *fiber.Ctx, id uint) (*entity.ProjectChickin, error)
	CreateOne(ctx *fiber.Ctx, req *validation.Create) ([]entity.ProjectChickin, error)
	UpdateOne(ctx *fiber.Ctx, req *validation.Update, id uint) (*entity.ProjectChickin, error)
	DeleteOne(ctx *fiber.Ctx, id uint) error
	Approval(ctx *fiber.Ctx, req *validation.Approve) ([]entity.ProjectChickin, error)
}

type chickinService struct {
	Log                        *logrus.Logger
	Validate                   *validator.Validate
	Repository                 repository.ProjectChickinRepository
	KandangRepo                KandangRepo.KandangRepository
	WarehouseRepo              rWarehouse.WarehouseRepository
	ProductWarehouseRepo       rProductWarehouse.ProductWarehouseRepository
	ProjectFlockRepo           rProjectFlock.ProjectflockRepository
	ProjectflockKandangRepo    rProjectFlock.ProjectFlockKandangRepository
	ProjectflockPopulationRepo rProjectFlock.ProjectFlockPopulationRepository
	ProjectChickinDetailRepo   repository.ProjectChickinDetailRepository
}

func NewChickinService(repo repository.ProjectChickinRepository, kandangRepo KandangRepo.KandangRepository, warehouseRepo rWarehouse.WarehouseRepository, productWarehouseRepo rProductWarehouse.ProductWarehouseRepository, projectFlockRepo rProjectFlock.ProjectflockRepository, projectflockkandangRepo rProjectFlock.ProjectFlockKandangRepository, projectflockpopulationRepo rProjectFlock.ProjectFlockPopulationRepository, projectChickinDetailRepo repository.ProjectChickinDetailRepository, validate *validator.Validate) ChickinService {
	return &chickinService{
		Log:                        utils.Log,
		Validate:                   validate,
		Repository:                 repo,
		KandangRepo:                kandangRepo,
		WarehouseRepo:              warehouseRepo,
		ProductWarehouseRepo:       productWarehouseRepo,
		ProjectFlockRepo:           projectFlockRepo,
		ProjectflockKandangRepo:    projectflockkandangRepo,
		ProjectflockPopulationRepo: projectflockpopulationRepo,
		ProjectChickinDetailRepo:   projectChickinDetailRepo,
	}
}

func (s chickinService) withRelations(db *gorm.DB) *gorm.DB {
	return db.
		Preload("CreatedUser").
		Preload("ProjectFlockKandang.Kandang").
		Preload("ProjectFlockKandang.Kandang.Location").
		Preload("ProjectFlockKandang.Kandang.Location.Area").
		Preload("ProjectFlockKandang.Kandang.Pic").
		Preload("ProjectFlockKandang.ProjectFlock").
		Preload("ProjectFlockKandang.ProjectFlock.Area").
		Preload("ProjectFlockKandang.ProjectFlock.Fcr").
		Preload("ProjectFlockKandang.ProjectFlock.Location").
		Preload("ProjectFlockKandang.ProjectFlock.Location.Area")

}

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

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

	chickins, total, err := s.Repository.GetAll(c.Context(), offset, params.Limit, func(db *gorm.DB) *gorm.DB {
		db = s.withRelations(db)
		if params.ProjectFlockKandangId != 0 {
			return db.Where("project_flock_kandang_id = ?", params.ProjectFlockKandangId)
		}
		return db.Order("created_at DESC").Order("updated_at DESC")
	})
	if err != nil {
		s.Log.Errorf("Failed to get chickins: %+v", err)
		return nil, 0, err
	}
	return chickins, total, nil
}

func (s chickinService) GetOne(c *fiber.Ctx, id uint) (*entity.ProjectChickin, error) {

	chickin, err := s.Repository.GetByID(c.Context(), id, s.withRelations)
	if errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, fiber.NewError(fiber.StatusNotFound, "Chickin not found")
	}
	if err != nil {
		s.Log.Errorf("Failed get chickin by id: %+v", err)
		return nil, err
	}
	return chickin, nil
}

func (s *chickinService) CreateOne(c *fiber.Ctx, req *validation.Create) ([]entity.ProjectChickin, error) {
	if err := s.Validate.Struct(req); err != nil {
		return nil, err
	}

	projectFlockKandang, err := s.ProjectflockKandangRepo.GetByID(c.Context(), req.ProjectFlockKandangId)
	if err != nil {
		return nil, fiber.NewError(fiber.StatusNotFound, "Project Flock Kandang not found")
	}

	warehouse, err := s.WarehouseRepo.GetByKandangID(c.Context(), projectFlockKandang.KandangId)
	if err != nil {
		return nil, fiber.NewError(fiber.StatusNotFound, "Warehouse for Kandang not found")
	}

	category := strings.ToUpper(strings.TrimSpace(projectFlockKandang.ProjectFlock.Category))

	actorID, err := m.ActorIDFromContext(c)
	if err != nil {
		return nil, err
	}
	newChikins := make([]*entity.ProjectChickin, 0)

	for _, chickinReq := range req.ChickinRequests {

		productWarehouse, err := s.ProductWarehouseRepo.GetByID(c.Context(), chickinReq.ProductWarehouseId, nil)
		if err != nil {
			return nil, fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("Product warehouse %d not found", chickinReq.ProductWarehouseId))
		}

		if productWarehouse.WarehouseId != warehouse.Id {
			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Product warehouse %d is not bound to kandang's warehouse", chickinReq.ProductWarehouseId))
		}

		if productWarehouse.ProjectFlockKandangId == nil || *productWarehouse.ProjectFlockKandangId != req.ProjectFlockKandangId {
			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Product warehouse %d is not attached to project_flock_kandang %d. Only product warehouses with matching project_flock_kandang_id can be chickin-ed", chickinReq.ProductWarehouseId, req.ProjectFlockKandangId))
		}

		chickinDate, err := utils.ParseDateString(chickinReq.ChickInDate)
		if err != nil {
			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Invalid ChickInDate format for product warehouse %d", chickinReq.ProductWarehouseId))
		}

		availableQty, err := s.calculateAvailableQuantity(c, req.ProjectFlockKandangId, productWarehouse, category)
		if err != nil {
			return nil, fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to calculate available quantity for product warehouse %d", chickinReq.ProductWarehouseId))
		}

		if availableQty <= 0 {
			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("No available quantity for product warehouse %d", chickinReq.ProductWarehouseId))
		}

		newChickin := &entity.ProjectChickin{
			ProjectFlockKandangId: req.ProjectFlockKandangId,
			ChickInDate:           chickinDate,
			UsageQty:              0,
			PendingUsageQty:       availableQty,
			ProductWarehouseId:    chickinReq.ProductWarehouseId,
			Notes:                 chickinReq.Note,
			CreatedBy:             actorID,
		}

		newChikins = append(newChikins, newChickin)
	}

	if len(newChikins) == 0 {
		return nil, fiber.NewError(fiber.StatusBadRequest, "No chickins to create")
	}

	existingChikins, err := s.Repository.GetByProjectFlockKandangID(c.Context(), req.ProjectFlockKandangId)
	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to check existing chickins")
	}

	isFirstTime := len(existingChikins) == 0

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

		approvalSvcTx := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))
		productWarehouseTx := s.ProductWarehouseRepo.WithTx(dbTransaction)

		if err := s.Repository.WithTx(dbTransaction).CreateMany(c.Context(), newChikins, nil); err != nil {
			return fiber.NewError(fiber.StatusInternalServerError, "Failed to create chickins")
		}

		latest, err := approvalSvcTx.LatestByTarget(c.Context(), utils.ApprovalWorkflowChickin, projectFlockKandang.Id, nil)
		if err != nil {
			return fiber.NewError(fiber.StatusInternalServerError, "Failed to get latest approval")
		}

		if category == string(utils.ProjectFlockCategoryLaying) {
			for _, chickin := range newChikins {
				updates := map[string]any{"qty": gorm.Expr("qty - ?", chickin.PendingUsageQty)}

				if err := productWarehouseTx.PatchOne(c.Context(), chickin.ProductWarehouseId, updates, nil); err != nil {
					if errors.Is(err, gorm.ErrRecordNotFound) {
						return fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("Product warehouse %d not found", chickin.ProductWarehouseId))
					}
					return fiber.NewError(fiber.StatusInternalServerError, "Failed to update product warehouse quantity")
				}
			}
		}

		var approvalAction entity.ApprovalAction
		if isFirstTime {
			approvalAction = entity.ApprovalActionCreated
		} else {
			approvalAction = entity.ApprovalActionUpdated
		}

		if latest == nil {
			if _, err := approvalSvcTx.CreateApproval(
				c.Context(),
				utils.ApprovalWorkflowChickin,
				projectFlockKandang.Id,
				utils.ChickinStepPengajuan,
				&approvalAction,
				actorID,
				nil); err != nil {
				if !errors.Is(err, gorm.ErrDuplicatedKey) {
					return fiber.NewError(fiber.StatusInternalServerError, "Failed to create approval")
				}
			}
		} else if latest.StepNumber != uint16(utils.ChickinStepPengajuan) {
			if _, err := approvalSvcTx.CreateApproval(
				c.Context(),
				utils.ApprovalWorkflowChickin,
				projectFlockKandang.Id,
				utils.ChickinStepPengajuan,
				&approvalAction,
				actorID,
				nil); err != nil {
				if !errors.Is(err, gorm.ErrDuplicatedKey) {
					return fiber.NewError(fiber.StatusInternalServerError, "Failed to create approval")
				}
			}
		}

		return nil
	})
	if err != nil {
		if fiberErr, ok := err.(*fiber.Error); ok {
			return nil, fiberErr
		}
		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to create chickins")
	}

	result := make([]entity.ProjectChickin, 0, len(newChikins))
	for _, chickin := range newChikins {
		loaded, err := s.GetOne(c, chickin.Id)
		if err != nil {
			return nil, fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to reload chickin %d with relations: %v", chickin.Id, err))
		}
		result = append(result, *loaded)
	}
	if len(result) == 0 {
		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to load created chickins")
	}

	return result, nil
}

func (s chickinService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint) (*entity.ProjectChickin, error) {
	if err := s.Validate.Struct(req); err != nil {
		return nil, err
	}

	updateBody := make(map[string]any)

	if req.ChickInDate != "" {
		updateBody["chick_in_date"] = req.ChickInDate
	}
	if req.Note != "" {
		updateBody["notes"] = req.Note
	}
	if len(updateBody) == 0 {
		return s.GetOne(c, id)
	}

	if err := s.Repository.PatchOne(c.Context(), id, updateBody, nil); err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, fiber.NewError(fiber.StatusNotFound, "Chickin not found")
		}
		s.Log.Errorf("Failed to update chickin: %+v", err)
		return nil, err
	}

	return s.GetOne(c, id)
}

func (s chickinService) DeleteOne(c *fiber.Ctx, id uint) error {

	if err := s.Repository.DeleteOne(c.Context(), id); err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return fiber.NewError(fiber.StatusNotFound, "Chickin not found")
		}
		return err
	}

	return nil
}

func (s chickinService) calculateAvailableQuantity(ctx *fiber.Ctx, projectFlockKandangID uint, productWarehouse *entity.ProductWarehouse, category string) (float64, error) {
	availableQty := productWarehouse.Quantity

	if category == string(utils.ProjectFlockCategoryGrowing) {
		var totalPendingQty float64

		chickins, err := s.Repository.GetByProjectFlockKandangID(ctx.Context(), projectFlockKandangID)
		if err == nil {
			for _, chickin := range chickins {

				if chickin.ProductWarehouseId == productWarehouse.Id && chickin.DeletedAt.Time.IsZero() && chickin.PendingUsageQty > 0 {
					totalPendingQty += chickin.PendingUsageQty
				}
			}
		}

		availableQty = productWarehouse.Quantity - totalPendingQty
		if availableQty < 0 {
			availableQty = 0
		}
	} else if category == string(utils.ProjectFlockCategoryLaying) {
		var totalPopulation float64
		var totalPendingQty float64

		populations, err := s.ProjectflockPopulationRepo.GetByProjectFlockKandangIDAndProductWarehouseID(ctx.Context(), projectFlockKandangID, productWarehouse.Id)
		if err == nil {
			for _, pop := range populations {
				totalPopulation += pop.TotalQty
			}
		}
		chickins, err := s.Repository.GetByProjectFlockKandangID(ctx.Context(), projectFlockKandangID)
		if err == nil {
			for _, chickin := range chickins {

				if chickin.ProductWarehouseId == productWarehouse.Id && chickin.DeletedAt.Time.IsZero() && chickin.PendingUsageQty > 0 {
					totalPendingQty += chickin.PendingUsageQty
				}
			}
		}
		availableQty = productWarehouse.Quantity - totalPopulation - totalPendingQty
		if availableQty < 0 {
			availableQty = 0
		}
	}

	return availableQty, nil
}

func (s chickinService) Approval(c *fiber.Ctx, req *validation.Approve) ([]entity.ProjectChickin, error) {
	if err := s.Validate.Struct(req); err != nil {
		return nil, err
	}

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

	approvalSvc := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(s.Repository.DB()))

	var action entity.ApprovalAction
	switch strings.ToUpper(strings.TrimSpace(req.Action)) {
	case string(entity.ApprovalActionRejected):
		action = entity.ApprovalActionRejected
	case string(entity.ApprovalActionApproved):
		action = entity.ApprovalActionApproved
	default:
		return nil, fiber.NewError(fiber.StatusBadRequest, "action must be APPROVED or REJECTED")
	}

	approvableIDs := utils.UniqueUintSlice(req.ApprovableIds)
	if len(approvableIDs) == 0 {
		return nil, fiber.NewError(fiber.StatusBadRequest, "approvable_ids must contain at least one id")
	}

	for _, id := range approvableIDs {
		idCopy := id
		if err := commonSvc.EnsureRelations(c.Context(), commonSvc.RelationCheck{Name: "ProjectFlockKandang", ID: &idCopy, Exists: s.ProjectflockKandangRepo.IdExists}); err != nil {
			return nil, err
		}

		latestApproval, err := approvalSvc.LatestByTarget(c.Context(), utils.ApprovalWorkflowChickin, id, nil)

		if err != nil {
			return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to check approval status")
		}
		if latestApproval == nil {
			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("No approval found for ProjectFlockKandang %d - chickins must be created first", id))
		}
		if latestApproval.StepNumber != uint16(utils.ChickinStepPengajuan) {
			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("ProjectFlockKandang %d cannot be approved - current status is not in PENGAJUAN stage", id))
		}
	}

	step := utils.ChickinStepPengajuan
	if action == entity.ApprovalActionApproved {
		step = utils.ChickinStepDisetujui
	}

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

		approvalSvc := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))
		chickinRepoTx := repository.NewChickinRepository(dbTransaction)
		productWarehouseTx := s.ProductWarehouseRepo.WithTx(dbTransaction)

		for _, approvableID := range approvableIDs {
			if _, err := approvalSvc.CreateApproval(
				c.Context(),
				utils.ApprovalWorkflowChickin,
				approvableID,
				step,
				&action,
				actorID,
				req.Notes,
			); err != nil {
				return fiber.NewError(fiber.StatusInternalServerError, "Failed to create approval")
			}

			if action == entity.ApprovalActionApproved {
				chickins, err := chickinRepoTx.GetByProjectFlockKandangID(c.Context(), approvableID)
				if err != nil {
					return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to get chickins for approval %d", approvableID))
				}

				kandangForApproval, err := s.ProjectflockKandangRepo.GetByID(c.Context(), approvableID)
				if err != nil {
					if errors.Is(err, gorm.ErrRecordNotFound) {
						return fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("ProjectFlockKandang %d not found", approvableID))
					}
					return fiber.NewError(fiber.StatusInternalServerError, "Failed to get ProjectFlockKandang")
				}

				category := strings.ToUpper(strings.TrimSpace(kandangForApproval.ProjectFlock.Category))

				if category == string(utils.ProjectFlockCategoryGrowing) {
					warehouse, err := s.WarehouseRepo.GetByKandangID(c.Context(), kandangForApproval.KandangId)
					if err != nil {
						if errors.Is(err, gorm.ErrRecordNotFound) {
							return fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("Warehouse for kandang %d not found", kandangForApproval.KandangId))
						}
						return fiber.NewError(fiber.StatusInternalServerError, "Failed to get warehouse")
					}

					pfkID := approvableID
					targetPW, err := s.getOrCreateProductWarehouse(c, warehouse.Id, "PULLET", dbTransaction, actorID, &pfkID)
					if err != nil {
						return fiber.NewError(fiber.StatusInternalServerError, "Failed to get/create PULLET product warehouse")
					}
					if err := s.convertChickinsToTarget(c, chickins, targetPW, dbTransaction, actorID); err != nil {
						return fiber.NewError(fiber.StatusInternalServerError, "Failed to convert chickins to target")
					}
				} else if category == string(utils.ProjectFlockCategoryLaying) {
					warehouse, err := s.WarehouseRepo.GetByKandangID(c.Context(), kandangForApproval.KandangId)
					if err != nil {
						if errors.Is(err, gorm.ErrRecordNotFound) {
							return fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("Warehouse for kandang %d not found", kandangForApproval.KandangId))
						}
						return fiber.NewError(fiber.StatusInternalServerError, "Failed to get warehouse")
					}

					pfkID := approvableID
					targetPW, err := s.getOrCreateProductWarehouse(c, warehouse.Id, "PULLET", dbTransaction, actorID, &pfkID)
					if err != nil {
						return fiber.NewError(fiber.StatusInternalServerError, "Failed to get/create PULLET product warehouse")
					}
					if err := s.convertChickinsToTarget(c, chickins, targetPW, dbTransaction, actorID); err != nil {
						return fiber.NewError(fiber.StatusInternalServerError, "Failed to convert chickins to target")
					}
				}
			}
			if action == entity.ApprovalActionRejected {
				chickins, err := chickinRepoTx.GetPendingByProjectFlockKandangID(c.Context(), approvableID)
				if err != nil {
					return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to get pending chickins for rejection %d", approvableID))
				}

				if len(chickins) == 0 {
					continue
				}

				kandangForRejection, err := s.ProjectflockKandangRepo.GetByID(c.Context(), approvableID)
				if err != nil {
					if errors.Is(err, gorm.ErrRecordNotFound) {
						return fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("ProjectFlockKandang %d not found", approvableID))
					}
					return fiber.NewError(fiber.StatusInternalServerError, "Failed to get ProjectFlockKandang")
				}

				categoryForRejection := strings.ToUpper(strings.TrimSpace(kandangForRejection.ProjectFlock.Category))

				for _, chickin := range chickins {

					if categoryForRejection == string(utils.ProjectFlockCategoryGrowing) {
						updates := map[string]any{"qty": gorm.Expr("qty + ?", chickin.PendingUsageQty)}

						if err := productWarehouseTx.PatchOne(c.Context(), chickin.ProductWarehouseId, updates, nil); err != nil {
							if errors.Is(err, gorm.ErrRecordNotFound) {
								return fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("Product warehouse %d not found during rejection", chickin.ProductWarehouseId))
							}
							return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to restore product warehouse quantity for chickin %d", chickin.Id))
						}
					}

					if err := chickinRepoTx.DeleteOne(c.Context(), chickin.Id); err != nil {
						if !errors.Is(err, gorm.ErrRecordNotFound) {
							return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to delete rejected chickin %d", chickin.Id))
						}
					}
				}
			}
		}
		return nil
	})

	if err != nil {
		if fiberErr, ok := err.(*fiber.Error); ok {
			return nil, fiberErr
		}
		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to record approval")
	}

	updated := make([]entity.ProjectChickin, 0)
	for _, kandangID := range approvableIDs {
		var chickins []entity.ProjectChickin
		if err := s.Repository.DB().WithContext(c.Context()).Where("project_flock_kandang_id = ?", kandangID).Find(&chickins).Error; err != nil {
			return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to load approved chickins")
		}
		updated = append(updated, chickins...)
	}

	return updated, nil
}

func (s *chickinService) getOrCreateProductWarehouse(ctx *fiber.Ctx, warehouseId uint, categoryCode string, dbTransaction *gorm.DB, actorID uint, projectFlockKandangId *uint) (*entity.ProductWarehouse, error) {

	products, err := s.ProductWarehouseRepo.GetByFlagAndWarehouseID(ctx.Context(), categoryCode, warehouseId)
	if err == nil && len(products) > 0 {
		existingPW := &products[0]
		// Update project_flock_kandang_id if not already set
		if existingPW.ProjectFlockKandangId == nil && projectFlockKandangId != nil {
			existingPW.ProjectFlockKandangId = projectFlockKandangId
			if err := s.ProductWarehouseRepo.WithTx(dbTransaction).UpdateOne(ctx.Context(), existingPW.Id, existingPW, nil); err != nil {
				return nil, fmt.Errorf("failed to update %s product warehouse with project_flock_kandang_id: %w", categoryCode, err)
			}
		}
		return existingPW, nil
	}

	product, err := s.ProductWarehouseRepo.GetFirstProductByFlag(ctx.Context(), categoryCode)
	if err != nil {
		return nil, fmt.Errorf("failed to get %s product: %w", categoryCode, err)
	}
	if product == nil {
		return nil, fmt.Errorf("no %s product found in system", categoryCode)
	}

	newPW := &entity.ProductWarehouse{
		ProductId:             product.Id,
		WarehouseId:           warehouseId,
		ProjectFlockKandangId: projectFlockKandangId,
		Quantity:              0,
		// CreatedBy:   actorID,
	}

	if err := s.ProductWarehouseRepo.WithTx(dbTransaction).CreateOne(ctx.Context(), newPW, nil); err != nil {
		return nil, fmt.Errorf("failed to create %s product warehouse: %w", categoryCode, err)
	}

	return newPW, nil
}

func (s *chickinService) convertChickinsToTarget(ctx *fiber.Ctx, chickins []entity.ProjectChickin, targetPW *entity.ProductWarehouse, dbTransaction *gorm.DB, actorID uint) error {

	if targetPW == nil || targetPW.Id == 0 {
		return fmt.Errorf("invalid target product warehouse")
	}

	chickinRepoTx := repository.NewChickinRepository(dbTransaction)
	productWarehouseTx := s.ProductWarehouseRepo.WithTx(dbTransaction)
	ProjectFlockPopulationRepotx := s.ProjectflockPopulationRepo.WithTx(dbTransaction)

	for _, chickin := range chickins {

		populationExists, err := ProjectFlockPopulationRepotx.ExistsByProjectChickinID(ctx.Context(), chickin.Id)
		if err != nil {
			return fmt.Errorf("failed to check population existence for chickin %d: %w", chickin.Id, err)
		}

		if populationExists {
			s.Log.Infof("population already exists for chickin %d, skipping", chickin.Id)
			continue
		}

		quantityToConvert := chickin.PendingUsageQty

		if err := chickinRepoTx.PatchOne(ctx.Context(), chickin.Id, map[string]any{
			"usage_qty":         quantityToConvert,
			"pending_usage_qty": 0,
		}, nil); err != nil {
			return fmt.Errorf("failed to update chickin %d qty: %w", chickin.Id, err)
		}

		if chickin.ProductWarehouseId != targetPW.Id {
			if err := productWarehouseTx.PatchOne(ctx.Context(), chickin.ProductWarehouseId, map[string]any{
				"qty": gorm.Expr("qty - ?", quantityToConvert),
			}, nil); err != nil {
				if errors.Is(err, gorm.ErrRecordNotFound) {
					return fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("Source product warehouse %d not found", chickin.ProductWarehouseId))
				}
				return fmt.Errorf("failed to deduct source warehouse quantity for chickin %d: %w", chickin.Id, err)
			}
		}

		if err := productWarehouseTx.PatchOne(ctx.Context(), targetPW.Id, map[string]any{
			"qty": gorm.Expr("qty + ?", quantityToConvert),
		}, nil); err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("Target product warehouse %d not found", targetPW.Id))
			}
			return fmt.Errorf("failed to update target warehouse quantity: %w", err)
		}

		population := &entity.ProjectFlockPopulation{
			ProjectChickinId:   chickin.Id,
			ProductWarehouseId: targetPW.Id,
			TotalQty:           quantityToConvert,
			TotalUsedQty:       0,
			Notes:              chickin.Notes,
			CreatedBy:          actorID,
		}
		if err := ProjectFlockPopulationRepotx.CreateOne(ctx.Context(), population, nil); err != nil {
			return err
		}
	}

	return nil
}