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"
	pkgdto "github.com/Caknoooo/go-gin-clean-starter/pkg/dto"
	"github.com/google/uuid"
	"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
}

func toAisleResponse(e entities.MAisleEntity) dto.AisleResponse {
	zona := pkgdto.IdNameResponse{}
	if e.Zona.ID != uuid.Nil {
		zona.ID = e.Zona.ID.String()
		zona.Name = e.Zona.Name
	}

	dimUom := pkgdto.IdNameResponse{}
	if e.DimUom.ID != uuid.Nil {
		dimUom.ID = e.DimUom.ID.String()
		dimUom.Name = e.DimUom.Name
	}

	weightUom := pkgdto.IdNameResponse{}
	if e.WeightUom.ID != uuid.Nil {
		weightUom.ID = e.WeightUom.ID.String()
		weightUom.Name = e.WeightUom.Name
	}

	client := pkgdto.IdNameResponse{}
	if e.Client.ID != uuid.Nil {
		client.ID = e.Client.ID.String()
		client.Name = e.Client.Name
	}

	return dto.AisleResponse{
		ID:          e.ID.String(),
		Code:        e.Code,
		Name:        e.Name,
		IsleX:       e.IsleX,
		BinY:        e.BinY,
		LevelZ:      e.LevelZ,
		DimLength:   e.DimLength,
		DimWidth:    e.DimWidth,
		DimHeight:   e.DimHeight,
		Weight:      e.Weight,
		QrCodeAisle: e.QrCodeAisle,
		IsActive:    e.IsActive,
		Zone:        zona,
		DimUom:      dimUom,
		WeightUom:   weightUom,
		Client:      client,
	}
}

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,
	}
	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
	}
	return 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 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, 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
	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
	}
	return 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()
		}
	}()
	if err := s.aisleRepo.Delete(ctx, tx, aisleId); err != nil {
		tx.Rollback()
		return err
	}
	tx.Commit()
	return nil
}

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