package service

import (
	"context"

	"github.com/Caknoooo/go-gin-clean-starter/database/entities"
	"github.com/Caknoooo/go-gin-clean-starter/modules/aisle/dto"
	"github.com/Caknoooo/go-gin-clean-starter/modules/aisle/query"
	"github.com/Caknoooo/go-gin-clean-starter/modules/aisle/repository"
	"github.com/Caknoooo/go-gin-clean-starter/pkg/constants"
	"github.com/Caknoooo/go-gin-clean-starter/pkg/utils"
	"github.com/google/uuid"
	"github.com/sirupsen/logrus"
	"gorm.io/gorm"
)

type AisleService interface {
	Create(ctx context.Context, req dto.AisleCreateRequest) (dto.AisleResponse, error)
	GetById(ctx context.Context, aisleId string) (dto.AisleResponse, error)
	GetAll(ctx context.Context, filter query.AisleFilter) ([]dto.AisleResponse, int64, error)
	Update(ctx context.Context, req dto.AisleUpdateRequest, aisleId string) (dto.AisleResponse, error)
	Delete(ctx context.Context, aisleId string) error
}

type aisleService struct {
	db        *gorm.DB
	aisleRepo repository.AisleRepository
	log       *logrus.Logger
}

func (s *aisleService) Create(ctx context.Context, req dto.AisleCreateRequest) (dto.AisleResponse, error) {
	tx := s.db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	zoneUUID, err := uuid.Parse(req.ZoneID)
	if err != nil {
		tx.Rollback()
		return dto.AisleResponse{}, err
	}
	dimUomUUID, err := uuid.Parse(req.DimUomID)
	if err != nil {
		tx.Rollback()
		return dto.AisleResponse{}, err
	}
	weightUomUUID, err := uuid.Parse(req.WeightUomID)
	if err != nil {
		tx.Rollback()
		return dto.AisleResponse{}, err
	}
	clientUUID, err := uuid.Parse(req.ClientID)
	if err != nil {
		tx.Rollback()
		return dto.AisleResponse{}, err
	}
	aisle := entities.MAisleEntity{
		Code:           req.Code,
		Name:           req.Name,
		IsleX:          req.IsleX,
		BinY:           req.BinY,
		LevelZ:         req.LevelZ,
		DimLength:      req.DimLength,
		DimWidth:       req.DimWidth,
		DimHeight:      req.DimHeight,
		Weight:         req.Weight,
		QrCodeAisle:    req.QrCodeAisle,
		IsActive:       req.IsActive,
		ZoneID:         zoneUUID,
		DimUomID:       dimUomUUID,
		WeightUomID:    weightUomUUID,
		ClientID:       clientUUID,
		FullAuditTrail: utils.FillAuditTrail(ctx, constants.CREATE),
	}
	created, err := s.aisleRepo.Create(ctx, tx, aisle)
	if err != nil {
		tx.Rollback()
		return dto.AisleResponse{}, err
	}
	tx.Commit()
	result, err := s.aisleRepo.GetById(ctx, nil, created.ID.String())
	if err != nil {
		return dto.AisleResponse{}, err
	}
	s.log.WithFields(logrus.Fields{
		"user_id":   utils.GetUserID(ctx),
		"action":    "create",
		"entity":    "aisle",
		"entity_id": created.ID.String(),
	}).Info("Aisle created")
	return dto.ToAisleResponse(result), nil
}

func (s *aisleService) GetById(ctx context.Context, aisleId string) (dto.AisleResponse, error) {
	aisle, err := s.aisleRepo.GetById(ctx, nil, aisleId)
	if err != nil {
		return dto.AisleResponse{}, err
	}
	return dto.ToAisleResponse(aisle), nil
}

func (s *aisleService) GetAll(ctx context.Context, filter query.AisleFilter) ([]dto.AisleResponse, int64, error) {
	aisles, total, err := s.aisleRepo.GetAll(ctx, filter)
	if err != nil {
		return nil, 0, err
	}
	var responses []dto.AisleResponse
	for _, e := range aisles {
		responses = append(responses, dto.ToAisleResponse(e))
	}
	if responses == nil {
		responses = make([]dto.AisleResponse, 0)
	}
	return responses, total, nil
}

func (s *aisleService) Update(ctx context.Context, req dto.AisleUpdateRequest, aisleId string) (dto.AisleResponse, error) {
	tx := s.db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	aisle, err := s.aisleRepo.GetById(ctx, tx, aisleId)
	if err != nil {
		tx.Rollback()
		return dto.AisleResponse{}, err
	}
	if req.Code != "" {
		aisle.Code = req.Code
	}
	if req.Name != "" {
		aisle.Name = req.Name
	}
	if req.IsleX != 0 {
		aisle.IsleX = req.IsleX
	}
	if req.BinY != 0 {
		aisle.BinY = req.BinY
	}
	if req.LevelZ != 0 {
		aisle.LevelZ = req.LevelZ
	}
	if req.DimLength != 0 {
		aisle.DimLength = req.DimLength
	}
	if req.DimWidth != 0 {
		aisle.DimWidth = req.DimWidth
	}
	if req.DimHeight != 0 {
		aisle.DimHeight = req.DimHeight
	}
	if req.Weight != 0 {
		aisle.Weight = req.Weight
	}
	if req.QrCodeAisle != "" {
		aisle.QrCodeAisle = req.QrCodeAisle
	}
	aisle.IsActive = req.IsActive
	aisle.FullAuditTrail = utils.FillAuditTrail(ctx, constants.UPDATE)
	updated, err := s.aisleRepo.Update(ctx, tx, aisle)
	if err != nil {
		tx.Rollback()
		return dto.AisleResponse{}, err
	}
	tx.Commit()
	result, err := s.aisleRepo.GetById(ctx, nil, updated.ID.String())
	if err != nil {
		return dto.AisleResponse{}, err
	}
	s.log.WithFields(logrus.Fields{
		"user_id":   utils.GetUserID(ctx),
		"action":    "update",
		"entity":    "aisle",
		"entity_id": aisleId,
	}).Info("Aisle updated")
	return dto.ToAisleResponse(result), nil
}

func (s *aisleService) Delete(ctx context.Context, aisleId string) error {
	tx := s.db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	aisle, err := s.aisleRepo.GetById(ctx, tx, aisleId)
	if err != nil {
		tx.Rollback()
		return err
	}
	aisle.FullAuditTrail = utils.FillAuditTrail(ctx, constants.DELETE)
	if _, err := s.aisleRepo.Update(ctx, tx, aisle); err != nil {
		tx.Rollback()
		return err
	}
	if err := s.aisleRepo.Delete(ctx, tx, aisleId); err != nil {
		tx.Rollback()
		return err
	}
	tx.Commit()
	s.log.WithFields(logrus.Fields{
		"user_id":   utils.GetUserID(ctx),
		"action":    "delete",
		"entity":    "aisle",
		"entity_id": aisleId,
	}).Info("Aisle deleted")
	return nil
}

func NewAisleService(aisleRepo repository.AisleRepository, db *gorm.DB, log *logrus.Logger) AisleService {
	return &aisleService{
		aisleRepo: aisleRepo,
		db:        db,
		log:       log,
	}
}