package service

import (
	"context"
	"errors"
	"fmt"
	"math"
	"strings"
	"time"

	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"
	rProduct "gitlab.com/mbugroup/lti-api.git/internal/modules/master/products/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"
	rTransferLaying "gitlab.com/mbugroup/lti-api.git/internal/modules/production/transfer_layings/repositories"
	rStockLogs "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
	"gitlab.com/mbugroup/lti-api.git/internal/utils"
	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"

	"github.com/go-playground/validator/v10"
	"github.com/gofiber/fiber/v2"
	"github.com/jackc/pgconn"
	pgconnv5 "github.com/jackc/pgx/v5/pgconn"
	"github.com/sirupsen/logrus"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

const chickinDeletePopulationGuardMessage = "Chickin tidak dapat dihapus karena sudah memiliki population. Lakukan rollback/penyesuaian population terlebih dahulu"

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)
	EnsureChickInExists(ctx context.Context, projectFlockKandangID uint) error
}

type chickinService struct {
	Log                        *logrus.Logger
	Validate                   *validator.Validate
	Repository                 repository.ProjectChickinRepository
	KandangRepo                KandangRepo.KandangRepository
	WarehouseRepo              rWarehouse.WarehouseRepository
	ProductWarehouseRepo       rProductWarehouse.ProductWarehouseRepository
	ProductRepo                rProduct.ProductRepository
	ProjectFlockRepo           rProjectFlock.ProjectflockRepository
	ProjectflockKandangRepo    rProjectFlock.ProjectFlockKandangRepository
	ProjectflockPopulationRepo rProjectFlock.ProjectFlockPopulationRepository
	ProjectChickinDetailRepo   repository.ProjectChickinDetailRepository
	TransferLayingRepo         rTransferLaying.TransferLayingRepository
	FifoStockV2Svc             commonSvc.FifoStockV2Service
	StockLogRepo               rStockLogs.StockLogRepository
}

func NewChickinService(repo repository.ProjectChickinRepository, kandangRepo KandangRepo.KandangRepository, warehouseRepo rWarehouse.WarehouseRepository, productWarehouseRepo rProductWarehouse.ProductWarehouseRepository, productRepo rProduct.ProductRepository, projectFlockRepo rProjectFlock.ProjectflockRepository, projectflockkandangRepo rProjectFlock.ProjectFlockKandangRepository, projectflockpopulationRepo rProjectFlock.ProjectFlockPopulationRepository, projectChickinDetailRepo repository.ProjectChickinDetailRepository, transferLayingRepo rTransferLaying.TransferLayingRepository, validate *validator.Validate, fifoStockV2Svc commonSvc.FifoStockV2Service) ChickinService {
	return &chickinService{
		Log:                        utils.Log,
		Validate:                   validate,
		Repository:                 repo,
		KandangRepo:                kandangRepo,
		WarehouseRepo:              warehouseRepo,
		ProductWarehouseRepo:       productWarehouseRepo,
		ProductRepo:                productRepo,
		ProjectFlockRepo:           projectFlockRepo,
		ProjectflockKandangRepo:    projectflockkandangRepo,
		ProjectflockPopulationRepo: projectflockpopulationRepo,
		ProjectChickinDetailRepo:   projectChickinDetailRepo,
		TransferLayingRepo:         transferLayingRepo,
		FifoStockV2Svc:             fifoStockV2Svc,
		StockLogRepo:               rStockLogs.NewStockLogRepository(repo.DB()),
	}
}

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.ProductionStandard.ProductionStandardDetails").
		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 {
		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 {
		return nil, err
	}
	return chickin, nil
}

func (s chickinService) ensureNotTransferred(ctx context.Context, projectFlockKandangID uint) error {
	if projectFlockKandangID == 0 || s.TransferLayingRepo == nil {
		return nil
	}

	transfer, err := s.TransferLayingRepo.GetLatestApprovedBySourceKandang(ctx, projectFlockKandangID)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil
		}
		s.Log.Errorf("Failed to resolve transfer laying by source kandang %d: %+v", projectFlockKandangID, err)
		return fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi transfer laying")
	}

	if transfer != nil && transfer.ExecutedAt != nil && !transfer.ExecutedAt.IsZero() {
		return fiber.NewError(fiber.StatusBadRequest, "Project flock kandang sudah dipindahkan ke laying")
	}

	return 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
	}

	if err := s.ensureNotTransferred(c.Context(), req.ProjectFlockKandangId); 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")
	}

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

	newChikins := make([]*entity.ProjectChickin, 0)
	chickinQtyMap := make(map[uint]float64)

	for idx, chickinReq := range req.ChickinRequests {

		productWarehouse, err := s.ProductWarehouseRepo.GetByID(c.Context(), chickinReq.ProductWarehouseId, func(db *gorm.DB) *gorm.DB {
			return db.Preload("Product.Flags")
		})
		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 belongs to different flock. Only product warehouses with project_flock_kandang_id = NULL or = %d can be used", chickinReq.ProductWarehouseId, req.ProjectFlockKandangId))
		}

		if productWarehouse.Product.Id != 0 {
			category := strings.ToUpper(strings.TrimSpace(projectFlockKandang.ProjectFlock.Category))
			if category != string(utils.ProjectFlockCategoryGrowing) && category != string(utils.ProjectFlockCategoryLaying) {
				return nil, fmt.Errorf("invalid flock category for chickin")
			}

			hasAyamFlag := false
			for _, flag := range productWarehouse.Product.Flags {
				if utils.CanonicalFlagType(flag.Name) == utils.FlagAyam {
					hasAyamFlag = true
					break
				}
			}

			if !hasAyamFlag {
				return nil, fmt.Errorf(
					"product warehouse %d cannot be used for %s chickin. Product must have AYAM flag (or legacy alias DOC/PULLET/LAYER) (product ID: %d, warehouse ID: %d)",
					chickinReq.ProductWarehouseId,
					projectFlockKandang.ProjectFlock.Category,
					productWarehouse.Product.Id,
					productWarehouse.Id,
				)
			}
		}

		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))
		}

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

		newChikins = append(newChikins, newChickin)

		totalPopulationQty, err := s.ProjectflockPopulationRepo.GetTotalQtyByProductWarehouseID(c.Context(), chickinReq.ProductWarehouseId)
		if err != nil {
			return nil, fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to get total population quantity for product warehouse %d", chickinReq.ProductWarehouseId))
		}

		availableQty := productWarehouse.Quantity - totalPopulationQty
		if availableQty < 0 {
			availableQty = 0
		}

		chickinQtyMap[uint(idx)] = availableQty
	}

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

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

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

		isFirstTime := len(existingChikins) == 0

		pendingQtyMap := make(map[uint]float64)
		for _, existingChickin := range existingChikins {
			if existingChickin.PendingUsageQty > 0 {
				pendingQtyMap[existingChickin.ProductWarehouseId] += existingChickin.PendingUsageQty
			}
		}
		for idx, chickin := range newChikins {
			pendingQty := pendingQtyMap[chickin.ProductWarehouseId]
			desiredQty := chickinQtyMap[uint(idx)]

			availableQty := desiredQty - pendingQty
			if availableQty < 0 {
				availableQty = 0
			}

			if availableQty <= 0 {
				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("No available stock in product warehouse %d for chickin. Warehouse: %.0f, Pending: %.0f, Available: %.0f", chickin.ProductWarehouseId, desiredQty, pendingQty, availableQty))
			}

			chickinQtyMap[uint(idx)] = availableQty

			pendingQtyMap[chickin.ProductWarehouseId] += availableQty
		}

		approvalSvcTx := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))

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

		for idx, chickin := range newChikins {
			desiredQty := chickinQtyMap[uint(idx)]
			if err := s.StageChickinStocks(c.Context(), dbTransaction, chickin, desiredQty, actorID); err != nil {
				return err
			}
		}

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

		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
	}

	chickin, err := s.Repository.GetByID(c.Context(), id, nil)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, fiber.NewError(fiber.StatusNotFound, "Chickin not found")
		}
		return nil, err
	}
	if err := s.ensureNotTransferred(c.Context(), chickin.ProjectFlockKandangId); 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")
		}
		return nil, err
	}

	updated, err := s.GetOne(c, id)
	if err != nil {
		return nil, err
	}

	if updated.UsageQty > 0 {
		if err := s.syncChickinTraceForProductWarehouse(c.Context(), nil, updated.ProductWarehouseId); err != nil {
			return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to sync chickin stock trace")
		}
	}

	return updated, nil
}

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

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

	if err := s.ensureNotTransferred(c.Context(), chickin.ProjectFlockKandangId); err != nil {
		return err
	}
	hasPopulation, err := s.ProjectflockPopulationRepo.ExistsByProjectChickinID(c.Context(), chickin.Id)
	if err != nil {
		s.Log.Errorf("Failed to check population by chickin %d: %+v", chickin.Id, err)
		return fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi population chickin")
	}
	if hasPopulation {
		return fiber.NewError(fiber.StatusBadRequest, chickinDeletePopulationGuardMessage)
	}

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

	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {
		chickinRepoTx := repository.NewChickinRepository(tx)
		if chickin.UsageQty > 0 || chickin.PendingUsageQty > 0 {
			if err := s.ReleaseChickinStocks(c.Context(), tx, chickin, actorID); err != nil {
				return err
			}
		}
		now := time.Now().UTC()
		note := "delete chickin rollback"
		if err := tx.WithContext(c.Context()).
			Model(&entity.StockAllocation{}).
			Where("usable_type = ? AND usable_id = ? AND status = ?",
				fifo.UsableKeyProjectChickin.String(),
				chickin.Id,
				entity.StockAllocationStatusActive,
			).
			Updates(map[string]any{
				"status":      entity.StockAllocationStatusReleased,
				"released_at": now,
				"note":        note,
			}).Error; err != nil {
			return fiber.NewError(fiber.StatusInternalServerError, "Gagal release alokasi FIFO chickin")
		}

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

		if err := s.syncChickinTraceForProductWarehouse(c.Context(), tx, chickin.ProductWarehouseId); err != nil {
			return err
		}

		return nil
	})
	if err != nil {
		if fiberErr, ok := err.(*fiber.Error); ok {
			return fiberErr
		}
		return err
	}

	return nil
}

func isForeignKeyViolation(err error) bool {
	if err == nil {
		return false
	}

	var pgErr *pgconn.PgError
	if errors.As(err, &pgErr) {
		return pgErr.Code == "23503"
	}

	var pgErrV5 *pgconnv5.PgError
	if errors.As(err, &pgErrV5) {
		return pgErrV5.Code == "23503"
	}

	return false
}

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 {

		if err := commonSvc.EnsureRelations(c.Context(), commonSvc.RelationCheck{Name: "ProjectFlockKandang", ID: &id, Exists: s.ProjectflockKandangRepo.IdExists}); err != nil {
			return nil, err
		}
		if err := s.ensureNotTransferred(c.Context(), id); 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)
		ProjectFlockPopulationRepotx := s.ProjectflockPopulationRepo.WithTx(dbTransaction)
		touchedProductWarehouseIDs := make(map[uint]struct{})

		for _, approvableID := range approvableIDs {
			// Re-check latest approval inside transaction to prevent double-approve races.
			var latest entity.Approval
			if err := dbTransaction.WithContext(c.Context()).
				Table("approvals").
				Where("approvable_type = ? AND approvable_id = ?", utils.ApprovalWorkflowChickin.String(), approvableID).
				Order("id DESC").
				Limit(1).
				Clauses(clause.Locking{Strength: "UPDATE"}).
				Take(&latest).Error; err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
				return fiber.NewError(fiber.StatusInternalServerError, "Failed to recheck approval status")
			}
			if latest.Id != 0 && latest.StepNumber != uint16(utils.ChickinStepPengajuan) {
				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("ProjectFlockKandang %d sudah tidak berada di tahap PENGAJUAN", approvableID))
			}

			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))

				var targetFlag utils.FlagType
				if category == string(utils.ProjectFlockCategoryGrowing) {
					targetFlag = utils.FlagPullet
				} else if category == string(utils.ProjectFlockCategoryLaying) {
					targetFlag = utils.FlagLayer
				} else {
					continue
				}

				for _, chickin := range chickins {
					approvedQty := chickin.UsageQty
					if approvedQty <= 0 {
						approvedQty = chickin.PendingUsageQty
					}
					if approvedQty < 0 {
						approvedQty = 0
					}

					if err := s.ConsumeChickinStocks(c.Context(), dbTransaction, &chickin, approvedQty, actorID); err != nil {
						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to finalize usage qty for chickin %d", chickin.Id))
					}
					chickin.UsageQty = approvedQty
					chickin.PendingUsageQty = 0
					touchedProductWarehouseIDs[chickin.ProductWarehouseId] = struct{}{}

					populationExists, err := ProjectFlockPopulationRepotx.ExistsByProjectChickinID(c.Context(), chickin.Id)
					if err != nil {
						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to check population for chickin %d", chickin.Id))
					}
					if populationExists {
						continue
					}

					sourcePW, err := s.ProductWarehouseRepo.GetByID(c.Context(), chickin.ProductWarehouseId, func(db *gorm.DB) *gorm.DB {
						return db.Preload("Product.Flags")
					})
					if err != nil {
						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to get product warehouse for chickin %d", chickin.Id))
					}

					if err := s.autoAddFlagToProduct(c.Context(), dbTransaction, sourcePW.Product.Id, targetFlag); err != nil {
						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to auto-add flag to product %d", sourcePW.Product.Id))
					}

					population := &entity.ProjectFlockPopulation{
						ProjectChickinId:   chickin.Id,
						ProductWarehouseId: sourcePW.Id,
						TotalQty:           0,
						TotalUsedQty:       0,
						Notes:              chickin.Notes,
						CreatedBy:          actorID,
					}
					if err := ProjectFlockPopulationRepotx.CreateOne(c.Context(), population, nil); err != nil {
						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to create population for chickin %d", chickin.Id))
					}

					if err := s.ReplenishChickinStocks(c.Context(), dbTransaction, &chickin, sourcePW, population, actorID); err != nil {
						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to replenish stock for chickin %d", chickin.Id))
					}
				}
			}
			if action == entity.ApprovalActionRejected {
				chickins, err := chickinRepoTx.GetByProjectFlockKandangID(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
				}

				for _, chickin := range chickins {
					populationExists, err := ProjectFlockPopulationRepotx.ExistsByProjectChickinID(c.Context(), chickin.Id)
					if err != nil {
						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to check population for chickin %d", chickin.Id))
					}
					if populationExists {
						continue
					}

					if chickin.UsageQty <= 0 && chickin.PendingUsageQty <= 0 {
						continue
					}

					if err := s.ReleaseChickinStocks(c.Context(), dbTransaction, &chickin, actorID); err != nil {
						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to release stock for rejected chickin %d: %v", chickin.Id, err))
					}
					touchedProductWarehouseIDs[chickin.ProductWarehouseId] = struct{}{}

					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))
						}
					}
				}
			}
		}

		for productWarehouseID := range touchedProductWarehouseIDs {
			if err := s.syncChickinTraceForProductWarehouse(c.Context(), dbTransaction, productWarehouseID); err != nil {
				return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to sync chickin trace for product warehouse %d", productWarehouseID))
			}
		}

		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) autoAddFlagToProduct(ctx context.Context, tx *gorm.DB, productID uint, targetFlag utils.FlagType) error {
	if s.ProductRepo == nil {
		return nil
	}

	currentFlags, err := s.ProductRepo.GetFlags(ctx, productID)
	if err != nil {
		return fmt.Errorf("failed to get product flags: %w", err)
	}

	hasTargetFlag := false
	currentFlagNames := make([]string, 0, len(currentFlags))
	for _, flag := range currentFlags {
		currentFlagNames = append(currentFlagNames, flag.Name)
		if flag.Name == string(targetFlag) {
			hasTargetFlag = true
		}
	}

	if hasTargetFlag {
		return nil
	}

	newFlags := append(currentFlagNames, string(targetFlag))
	if err := s.ProductRepo.SyncFlags(ctx, tx, productID, newFlags); err != nil {
		return fmt.Errorf("failed to sync flags: %w", err)
	}

	return nil
}

func (s *chickinService) ConsumeChickinStocks(ctx context.Context, tx *gorm.DB, chickin *entity.ProjectChickin, desiredQty float64, actorID uint) error {
	if chickin == nil {
		return nil
	}
	if tx == nil {
		return errors.New("transaction is required")
	}
	if desiredQty < 0 {
		return errors.New("desired quantity must be zero or greater")
	}

	return s.Repository.UpdateUsageFields(ctx, tx, chickin.Id, desiredQty, 0)
}

func (s *chickinService) StageChickinStocks(ctx context.Context, tx *gorm.DB, chickin *entity.ProjectChickin, desiredQty float64, actorID uint) error {
	if chickin == nil {
		return nil
	}
	if tx == nil {
		return errors.New("transaction is required")
	}
	if desiredQty < 0 {
		return errors.New("desired quantity must be zero or greater")
	}

	return s.Repository.UpdateUsageFields(ctx, tx, chickin.Id, 0, desiredQty)
}

func (s *chickinService) ReplenishChickinStocks(ctx context.Context, tx *gorm.DB, chickin *entity.ProjectChickin, targetPW *entity.ProductWarehouse, population *entity.ProjectFlockPopulation, actorID uint) error {
	if chickin == nil || targetPW == nil || population == nil {
		return nil
	}
	if tx == nil {
		return errors.New("transaction is required")
	}
	if s.FifoStockV2Svc == nil {
		return errors.New("fifo v2 service is not available")
	}

	if err := tx.WithContext(ctx).
		Model(&entity.ProjectFlockPopulation{}).
		Where("id = ?", population.Id).
		Update("total_qty", chickin.UsageQty).Error; err != nil {
		return err
	}

	asOf := chickin.ChickInDate
	if asOf.IsZero() {
		asOf = chickin.CreatedAt
	}
	return reflowChickinScope(ctx, s.FifoStockV2Svc, tx, targetPW.Id, &asOf)
}

func (s *chickinService) ReleaseChickinStocks(ctx context.Context, tx *gorm.DB, chickin *entity.ProjectChickin, actorID uint) error {
	if chickin == nil {
		return nil
	}
	if tx == nil {
		return errors.New("transaction is required")
	}

	if err := s.Repository.UpdateUsageFields(ctx, tx, chickin.Id, 0, 0); err != nil {
		return err
	}

	return nil
}

func (s *chickinService) syncChickinTraceForProductWarehouse(ctx context.Context, tx *gorm.DB, productWarehouseID uint) error {
	if productWarehouseID == 0 {
		return nil
	}
	if s.FifoStockV2Svc == nil {
		return nil
	}

	if tx == nil {
		return s.Repository.DB().WithContext(ctx).Transaction(func(innerTx *gorm.DB) error {
			return s.syncChickinTraceForProductWarehouse(ctx, innerTx, productWarehouseID)
		})
	}

	flagGroupCode, err := s.resolveFlagGroupByProductWarehouse(ctx, tx, productWarehouseID)
	if err != nil {
		return err
	}
	if strings.TrimSpace(flagGroupCode) == "" {
		return nil
	}

	now := time.Now()
	if err := tx.WithContext(ctx).
		Table("stock_allocations").
		Where("product_warehouse_id = ?", productWarehouseID).
		Where("usable_type = ?", fifo.UsableKeyProjectChickin.String()).
		Where("allocation_purpose = ?", entity.StockAllocationPurposeTraceChickin).
		Where("status = ?", entity.StockAllocationStatusActive).
		Updates(map[string]any{
			"status":      entity.StockAllocationStatusReleased,
			"released_at": now,
			"updated_at":  now,
			"note":        "chickin_trace_reflow_reset",
		}).Error; err != nil {
		return err
	}

	type chickinTraceRow struct {
		ID       uint      `gorm:"column:id"`
		UsageQty float64   `gorm:"column:usage_qty"`
		ChickIn  time.Time `gorm:"column:chick_in_date"`
	}
	chickins := make([]chickinTraceRow, 0)
	if err := tx.WithContext(ctx).
		Table("project_chickins").
		Select("id, usage_qty, chick_in_date").
		Where("product_warehouse_id = ?", productWarehouseID).
		Where("deleted_at IS NULL").
		Where("usage_qty > 0").
		Order("chick_in_date ASC, id ASC").
		Scan(&chickins).Error; err != nil {
		return err
	}
	if len(chickins) == 0 {
		return nil
	}

	gatherRows, err := s.FifoStockV2Svc.Gather(ctx, commonSvc.FifoStockV2GatherRequest{
		FlagGroupCode:      flagGroupCode,
		Lane:               "STOCKABLE",
		ProductWarehouseID: productWarehouseID,
		Limit:              50000,
		Tx:                 tx,
	})
	if err != nil {
		return err
	}
	if len(gatherRows) == 0 {
		return nil
	}

	type lotKey struct {
		StockableType string
		StockableID   uint
	}
	remainingByLot := make(map[lotKey]float64, len(gatherRows))
	for _, row := range gatherRows {
		key := lotKey{StockableType: row.Ref.LegacyTypeKey, StockableID: row.Ref.ID}
		remainingByLot[key] = row.AvailableQuantity
	}

	lotIndex := 0
	traceNow := time.Now()
	for _, chickin := range chickins {
		remaining := chickin.UsageQty
		for remaining > 1e-6 && lotIndex < len(gatherRows) {
			lot := gatherRows[lotIndex]
			key := lotKey{StockableType: lot.Ref.LegacyTypeKey, StockableID: lot.Ref.ID}
			available := remainingByLot[key]
			if available <= 1e-6 {
				lotIndex++
				continue
			}

			portion := math.Min(remaining, available)
			if portion <= 1e-6 {
				lotIndex++
				continue
			}

			insert := map[string]any{
				"product_warehouse_id": productWarehouseID,
				"stockable_type":       lot.Ref.LegacyTypeKey,
				"stockable_id":         lot.Ref.ID,
				"usable_type":          fifo.UsableKeyProjectChickin.String(),
				"usable_id":            chickin.ID,
				"qty":                  portion,
				"status":               entity.StockAllocationStatusActive,
				"allocation_purpose":   entity.StockAllocationPurposeTraceChickin,
				"engine_version":       "v2",
				"flag_group_code":      flagGroupCode,
				"function_code":        "CHICKIN_TRACE",
				"created_at":           traceNow,
				"updated_at":           traceNow,
			}
			if err := tx.WithContext(ctx).Table("stock_allocations").Create(insert).Error; err != nil {
				return err
			}

			remaining -= portion
			remainingByLot[key] = available - portion
		}

		if remaining > 1e-6 {
			s.Log.Warnf(
				"chickin trace partial allocation for product_warehouse_id=%d chickin_id=%d: remaining=%.3f",
				productWarehouseID,
				chickin.ID,
				remaining,
			)
		}
	}

	return nil
}

func (s *chickinService) resolveFlagGroupByProductWarehouse(ctx context.Context, tx *gorm.DB, productWarehouseID uint) (string, error) {
	type row struct {
		FlagGroupCode string `gorm:"column:flag_group_code"`
	}

	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 = 'STOCKABLE'").
		Where(`
			EXISTS (
				SELECT 1
				FROM product_warehouses pw
				JOIN flags f ON f.flagable_id = pw.product_id
				JOIN fifo_stock_v2_flag_members fm ON fm.flag_name = f.name AND fm.is_active = TRUE
				WHERE pw.id = ?
				  AND f.flagable_type = ?
				  AND fm.flag_group_code = rr.flag_group_code
			)
		`, productWarehouseID, entity.FlagableTypeProduct).
		Order("fg.priority ASC, rr.id ASC").
		Limit(1).
		Take(&selected).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return "", nil
		}
		return "", err
	}
	return selected.FlagGroupCode, nil
}

func (s chickinService) EnsureChickInExists(ctx context.Context, projectFlockKandangID uint) error {
	if projectFlockKandangID == 0 {
		return fiber.NewError(fiber.StatusBadRequest, "Project flock kandang tidak valid")
	}

	populations, err := s.ProjectflockPopulationRepo.GetByProjectFlockKandangID(ctx, projectFlockKandangID)
	if err != nil {
		s.Log.Errorf("Failed to check project flock population for project_flock_kandang_id=%d: %+v", projectFlockKandangID, err)
		return fiber.NewError(fiber.StatusInternalServerError, "Gagal memeriksa data chick in")
	}

	if len(populations) == 0 {
		return fiber.NewError(fiber.StatusBadRequest, "Project flock belum memiliki chick in yang disetujui sehingga belum dapat membuat recording")
	}

	for _, population := range populations {
		if population.TotalQty > 0 {
			return nil
		}
	}

	return fiber.NewError(fiber.StatusBadRequest, "Chick in project flock belum disetujui sehingga belum dapat membuat recording")
}