package service

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

	"github.com/gofiber/fiber/v2"
	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
	rProductWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/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"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

func (s *transferService) CreateSystemTransfer(ctx context.Context, req *SystemTransferRequest) (*entity.StockTransfer, error) {
	if req == nil {
		return nil, fmt.Errorf("system transfer request is required")
	}
	if strings.TrimSpace(req.TransferReason) == "" {
		return nil, fmt.Errorf("transfer reason is required")
	}
	if req.TransferDate.IsZero() {
		return nil, fmt.Errorf("transfer date is required")
	}
	if req.SourceWarehouseID == 0 || req.DestinationWarehouseID == 0 {
		return nil, fmt.Errorf("source and destination warehouse are required")
	}
	if req.SourceWarehouseID == req.DestinationWarehouseID {
		return nil, fmt.Errorf("source and destination warehouse must be different")
	}
	if req.ActorID == 0 {
		return nil, fmt.Errorf("actor id is required")
	}

	if err := s.validateTransferWarehousesAndProducts(ctx, req.SourceWarehouseID, req.DestinationWarehouseID, req.Products); err != nil {
		return nil, err
	}

	var result *entity.StockTransfer
	err := s.StockTransferRepo.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		movementResult, err := s.createTransferMovement(ctx, tx, req)
		if err != nil {
			return err
		}
		result = movementResult.Transfer
		return nil
	})
	if err != nil {
		return nil, err
	}

	return result, nil
}

func (s *transferService) DeleteSystemTransfer(ctx context.Context, id uint, actorID uint) error {
	if id == 0 {
		return fmt.Errorf("transfer id is required")
	}
	if actorID == 0 {
		return fmt.Errorf("actor id is required")
	}

	var deletedDetails []entity.StockTransferDetail
	err := s.StockTransferRepo.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		var err error
		deletedDetails, err = s.deleteTransferCore(ctx, tx, uint64(id), actorID)
		return err
	})
	if err != nil {
		return err
	}

	if len(deletedDetails) > 0 && s.ExpenseBridge != nil {
		if err := s.ExpenseBridge.OnItemsDeleted(ctx, uint64(id), deletedDetails); err != nil {
			s.Log.Errorf("Failed to cleanup transfer expense link for transfer_id=%d: %+v", id, err)
			return fiber.NewError(fiber.StatusInternalServerError, "Transfer berhasil dihapus, namun sinkronisasi expense gagal. Silakan cek modul expense")
		}
	}

	return nil
}

func (s *transferService) validateTransferWarehousesAndProducts(
	ctx context.Context,
	sourceWarehouseID uint,
	destinationWarehouseID uint,
	products []SystemTransferProduct,
) error {
	if len(products) == 0 {
		return fmt.Errorf("transfer products are required")
	}

	pwIDs := make([]uint, 0, len(products))
	for _, product := range products {
		if product.ProductID == 0 {
			return fmt.Errorf("product id is required")
		}
		if product.ProductQty <= 0 {
			return fmt.Errorf("product qty must be greater than 0 for product %d", product.ProductID)
		}

		sourcePW, err := s.ProductWarehouseRepo.GetProductWarehouseByProductAndWarehouseID(
			ctx, product.ProductID, sourceWarehouseID,
		)
		if err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Produk dengan ID %d tidak ditemukan di gudang asal (ID: %d)", product.ProductID, sourceWarehouseID))
			}
			s.Log.Errorf("Failed to fetch product warehouse for product_id=%d, warehouse_id=%d: %+v", product.ProductID, sourceWarehouseID, err)
			return fiber.NewError(fiber.StatusInternalServerError, "Gagal mengecek stok produk")
		}
		if sourcePW.Quantity < product.ProductQty {
			return 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(ctx, s.StockTransferRepo.DB(), pwIDs); err != nil {
		return err
	}

	destPfkID, err := s.getActiveProjectFlockKandangID(ctx, destinationWarehouseID)
	if err != nil {
		return err
	}
	if destPfkID == 0 {
		return nil
	}

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

	return nil
}

func (s *transferService) createTransferMovement(
	ctx context.Context,
	tx *gorm.DB,
	req *SystemTransferRequest,
) (*transferMovementResult, error) {
	if tx == nil {
		return nil, fmt.Errorf("transaction is required")
	}

	stockTransferRepoTX := s.StockTransferRepo.WithTx(tx)
	stockTransferDetailRepoTX := s.StockTransferDetailRepo.WithTx(tx)
	productWarehouseRepoTX := rProductWarehouse.NewProductWarehouseRepository(tx)
	stockLogsRepoTX := rStockLogs.NewStockLogRepository(tx)

	movementNumber := strings.TrimSpace(req.MovementNumber)
	if movementNumber == "" {
		var err error
		movementNumber, err = s.StockTransferRepo.GenerateMovementNumber(ctx)
		if err != nil {
			s.Log.Errorf("Failed to generate movement number: %+v", err)
			return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat nomor transfer")
		}
	}

	entityTransfer := &entity.StockTransfer{
		FromWarehouseId: uint64(req.SourceWarehouseID),
		ToWarehouseId:   uint64(req.DestinationWarehouseID),
		Reason:          req.TransferReason,
		TransferDate:    req.TransferDate,
		MovementNumber:  movementNumber,
		CreatedBy:       uint64(req.ActorID),
	}
	if err := stockTransferRepoTX.CreateOne(ctx, entityTransfer, nil); err != nil {
		return nil, err
	}

	details := make([]*entity.StockTransferDetail, 0, len(req.Products))
	detailMap := make(map[uint64]*entity.StockTransferDetail, len(req.Products))
	for _, product := range req.Products {
		sourcePW, err := productWarehouseRepoTX.GetProductWarehouseByProductAndWarehouseID(
			ctx, product.ProductID, req.SourceWarehouseID,
		)
		if err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return nil, 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 nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data stok gudang asal")
		}

		destPW, err := productWarehouseRepoTX.GetProductWarehouseByProductAndWarehouseID(
			ctx, product.ProductID, 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 nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data stok gudang tujuan")
		}
		if errors.Is(err, gorm.ErrRecordNotFound) {
			projectFlockKandangID, err := s.getActiveProjectFlockKandangID(ctx, req.DestinationWarehouseID)
			if err != nil {
				return nil, err
			}

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

			destPW = &entity.ProductWarehouse{
				ProductId:             product.ProductID,
				WarehouseId:           req.DestinationWarehouseID,
				Quantity:              0,
				ProjectFlockKandangId: pfkID,
			}
			if err := productWarehouseRepoTX.CreateOne(ctx, 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 nil, 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(ctx, details, nil); err != nil {
		return nil, err
	}

	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 nil, fiber.NewError(fiber.StatusInternalServerError, "Data transfer detail tidak valid")
		}

		flagGroupCode, ok := flagGroupByProduct[product.ProductID]
		if !ok {
			var err error
			flagGroupCode, err = s.resolveTransferFlagGroup(ctx, tx, product.ProductID)
			if err != nil {
				return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("FIFO v2 route tidak ditemukan untuk produk %d: %v", product.ProductID, err))
			}
			flagGroupByProduct[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 nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal memperbarui data tracking")
		}

		asOf := req.TransferDate
		if _, err := s.FifoStockV2Svc.Reflow(ctx, commonSvc.FifoStockV2ReflowRequest{
			FlagGroupCode:      flagGroupCode,
			ProductWarehouseID: uint(*detail.SourceProductWarehouseID),
			AsOf:               &asOf,
			Tx:                 tx,
		}); err != nil {
			return nil, 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(ctx, commonSvc.FifoStockV2ReflowRequest{
			FlagGroupCode:      flagGroupCode,
			ProductWarehouseID: uint(*detail.DestProductWarehouseID),
			AsOf:               &asOf,
			Tx:                 tx,
		}); err != nil {
			return nil, 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(ctx).
			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 nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data tracking")
		}
		outUsageQty := usage.UsageQty
		outPendingQty := usage.PendingQty
		if outPendingQty > 1e-6 {
			return nil, 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:          req.ActorID,
			Increase:           0,
			Decrease:           outUsageQty,
			LoggableType:       string(utils.StockLogTypeTransfer),
			LoggableId:         uint(detail.Id),
			Notes:              req.StockLogNotes,
		}
		stockLogs, err := stockLogsRepoTX.GetByProductWarehouse(ctx, uint(*detail.SourceProductWarehouseID), 1)
		if err != nil {
			s.Log.Errorf("Failed to get stock logs: %+v", err)
			return nil, 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(ctx, stockLogDecrease, nil); err != nil {
			return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat log stok keluar")
		}

		stockLogIncrease := &entity.StockLog{
			ProductWarehouseId: uint(*detail.DestProductWarehouseID),
			CreatedBy:          req.ActorID,
			Increase:           outUsageQty,
			Decrease:           0,
			LoggableType:       string(utils.StockLogTypeTransfer),
			LoggableId:         uint(detail.Id),
			Notes:              req.StockLogNotes,
		}
		stockLogs, err = stockLogsRepoTX.GetByProductWarehouse(ctx, uint(*detail.DestProductWarehouseID), 1)
		if err != nil {
			s.Log.Errorf("Failed to get stock logs: %+v", err)
			return nil, 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(ctx, stockLogIncrease, nil); err != nil {
			return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat log stok masuk")
		}
	}

	return &transferMovementResult{
		Transfer:    entityTransfer,
		DetailByPID: detailMap,
	}, nil
}

func (s *transferService) deleteTransferCore(
	ctx context.Context,
	tx *gorm.DB,
	transferID uint64,
	actorID uint,
) ([]entity.StockTransferDetail, error) {
	stockLogRepoTx := rStockLogs.NewStockLogRepository(tx)

	var transfer entity.StockTransfer
	if err := tx.WithContext(ctx).
		Clauses(clause.Locking{Strength: "UPDATE"}).
		Where("id = ?", transferID).
		Where("deleted_at IS NULL").
		Take(&transfer).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("Transfer dengan ID %d tidak ditemukan", transferID))
		}
		return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data transfer")
	}

	var details []entity.StockTransferDetail
	if err := tx.WithContext(ctx).
		Clauses(clause.Locking{Strength: "UPDATE"}).
		Where("stock_transfer_id = ?", transfer.Id).
		Where("deleted_at IS NULL").
		Order("id ASC").
		Find(&details).Error; err != nil {
		return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil detail transfer")
	}
	if len(details) == 0 {
		return nil, fiber.NewError(fiber.StatusBadRequest, "Transfer tidak memiliki detail produk")
	}

	detailIDs := make([]uint64, 0, len(details))
	for _, detail := range details {
		detailIDs = append(detailIDs, detail.Id)
	}
	if err := s.ensureDeletePolicyForDownstreamConsumption(ctx, tx, detailIDs); err != nil {
		return nil, err
	}

	type reflowKey struct {
		flagGroupCode      string
		productWarehouseID uint
	}
	destReflows := make(map[reflowKey]struct{})

	for _, detail := range details {
		if detail.SourceProductWarehouseID == nil || *detail.SourceProductWarehouseID == 0 {
			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Detail transfer %d tidak memiliki source product warehouse valid", detail.Id))
		}
		if detail.DestProductWarehouseID == nil || *detail.DestProductWarehouseID == 0 {
			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Detail transfer %d tidak memiliki destination product warehouse valid", detail.Id))
		}

		flagGroupCode, err := s.resolveTransferFlagGroup(ctx, tx, uint(detail.ProductId))
		if err != nil {
			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("FIFO v2 route tidak ditemukan untuk produk %d: %v", detail.ProductId, err))
		}

		rollbackRes, err := s.FifoStockV2Svc.Rollback(ctx, commonSvc.FifoStockV2RollbackRequest{
			ProductWarehouseID: uint(*detail.SourceProductWarehouseID),
			Usable: commonSvc.FifoStockV2Ref{
				ID:            uint(detail.Id),
				LegacyTypeKey: fifo.UsableKeyStockTransferOut.String(),
				FunctionCode:  "STOCK_TRANSFER_OUT",
			},
			Reason: fmt.Sprintf("transfer delete #%s", transfer.MovementNumber),
			Tx:     tx,
		})
		if err != nil {
			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Gagal rollback FIFO v2 transfer detail %d: %v", detail.Id, err))
		}

		releasedQty := 0.0
		if rollbackRes != nil {
			releasedQty = rollbackRes.ReleasedQty
		}
		if detail.UsageQty > 1e-6 && releasedQty < detail.UsageQty-1e-6 {
			return nil, fiber.NewError(
				fiber.StatusBadRequest,
				fmt.Sprintf("Rollback FIFO v2 source transfer detail %d tidak lengkap. Dibutuhkan %.3f, terlepas %.3f", detail.Id, detail.UsageQty, releasedQty),
			)
		}

		if releasedQty > 1e-6 {
			if err := s.appendStockLog(
				ctx,
				stockLogRepoTx,
				uint(*detail.SourceProductWarehouseID),
				actorID,
				releasedQty,
				0,
				uint(detail.Id),
				fmt.Sprintf("TRANSFER DELETE #%s", transfer.MovementNumber),
			); err != nil {
				return nil, err
			}
		}

		destDecreaseQty := detail.TotalQty
		if destDecreaseQty <= 1e-6 {
			destDecreaseQty = detail.UsageQty
		}
		if destDecreaseQty > 1e-6 {
			if err := s.appendStockLog(
				ctx,
				stockLogRepoTx,
				uint(*detail.DestProductWarehouseID),
				actorID,
				0,
				destDecreaseQty,
				uint(detail.Id),
				fmt.Sprintf("TRANSFER DELETE #%s", transfer.MovementNumber),
			); err != nil {
				return nil, err
			}
		}

		destReflows[reflowKey{
			flagGroupCode:      flagGroupCode,
			productWarehouseID: uint(*detail.DestProductWarehouseID),
		}] = struct{}{}
	}

	now := time.Now().UTC()
	if err := tx.WithContext(ctx).
		Where("stock_transfer_detail_id IN ?", detailIDs).
		Delete(&entity.StockTransferDeliveryItem{}).Error; err != nil {
		return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal menghapus item delivery transfer")
	}
	if err := tx.WithContext(ctx).
		Model(&entity.StockTransferDelivery{}).
		Where("stock_transfer_id = ?", transfer.Id).
		Where("deleted_at IS NULL").
		Updates(map[string]any{
			"deleted_at": now,
			"updated_at": now,
		}).Error; err != nil {
		return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal menghapus delivery transfer")
	}
	if err := tx.WithContext(ctx).
		Model(&entity.StockTransferDetail{}).
		Where("id IN ?", detailIDs).
		Where("deleted_at IS NULL").
		Updates(map[string]any{
			"deleted_at": now,
			"updated_at": now,
		}).Error; err != nil {
		return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal menghapus detail transfer")
	}

	asOf := transfer.TransferDate
	for key := range destReflows {
		if _, err := s.FifoStockV2Svc.Reflow(ctx, commonSvc.FifoStockV2ReflowRequest{
			FlagGroupCode:      key.flagGroupCode,
			ProductWarehouseID: key.productWarehouseID,
			AsOf:               &asOf,
			Tx:                 tx,
		}); err != nil {
			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Gagal reflow stok tujuan saat delete transfer: %v", err))
		}
	}

	if err := tx.WithContext(ctx).
		Model(&entity.StockTransfer{}).
		Where("id = ?", transfer.Id).
		Where("deleted_at IS NULL").
		Updates(map[string]any{
			"deleted_at": now,
			"updated_at": now,
		}).Error; err != nil {
		return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal menghapus transfer")
	}

	return details, nil
}