package services

// import (
// 	"fmt"
// 	"rijig/dto"
// 	"rijig/internal/repositories"
// 	"rijig/model"
// 	"rijig/utils"
// )

// type RequestPickupService interface {
// 	// CreateRequestPickup(request dto.RequestPickup, UserId string) (*dto.ResponseRequestPickup, error)
// 	// GetRequestPickupByID(id string) (*dto.ResponseRequestPickup, error)
// 	// GetAllRequestPickups(userid string) ([]dto.ResponseRequestPickup, error)
// 	// GetRequestPickupsForCollector(collectorId string) ([]dto.ResponseRequestPickup, error)
// 	// SelectCollectorInRequest(userId, collectorId string) error
// }

// type requestPickupService struct {
// 	repo        repositories.RequestPickupRepository
// 	repoColl    repositories.CollectorRepository
// 	repoAddress repositories.AddressRepository
// 	repoTrash   repositories.TrashRepository
// 	repoUser    repositories.UserProfilRepository
// }

// func NewRequestPickupService(repo repositories.RequestPickupRepository,
// 	repoColl repositories.CollectorRepository,
// 	repoAddress repositories.AddressRepository,
// 	repoTrash repositories.TrashRepository,
// 	repoUser repositories.UserProfilRepository) RequestPickupService {
// 	return &requestPickupService{repo: repo, repoColl: repoColl, repoAddress: repoAddress, repoTrash: repoTrash, repoUser: repoUser}
// }

// func (s *requestPickupService) CreateRequestPickup(request dto.RequestPickup, UserId string) (*dto.ResponseRequestPickup, error) {

// 	errors, valid := request.ValidateRequestPickup()
// 	if !valid {
// 		return nil, fmt.Errorf("validation errors: %v", errors)
// 	}

// 	_, err := s.repoAddress.FindAddressByID(request.AddressID)
// 	if err != nil {
// 		return nil, fmt.Errorf("address with ID %s not found", request.AddressID)
// 	}

// 	existingRequest, err := s.repo.FindRequestPickupByAddressAndStatus(UserId, "waiting_collector", "otomatis")
// 	if err != nil {
// 		return nil, fmt.Errorf("error checking for existing request pickup: %v", err)
// 	}
// 	if existingRequest != nil {
// 		return nil, fmt.Errorf("there is already a pending pickup request for address %s", request.AddressID)
// 	}

// 	modelRequest := model.RequestPickup{
// 		UserId:        UserId,
// 		AddressId:     request.AddressID,
// 		EvidenceImage: request.EvidenceImage,
// 		RequestMethod: request.RequestMethod,
// 	}

// 	err = s.repo.CreateRequestPickup(&modelRequest)
// 	if err != nil {
// 		return nil, fmt.Errorf("failed to create request pickup: %v", err)
// 	}

// 	createdAt, _ := utils.FormatDateToIndonesianFormat(modelRequest.CreatedAt)
// 	updatedAt, _ := utils.FormatDateToIndonesianFormat(modelRequest.UpdatedAt)

// 	response := &dto.ResponseRequestPickup{
// 		ID:            modelRequest.ID,
// 		UserId:        UserId,
// 		AddressID:     modelRequest.AddressId,
// 		EvidenceImage: modelRequest.EvidenceImage,
// 		StatusPickup:  modelRequest.StatusPickup,
// 		CreatedAt:     createdAt,
// 		UpdatedAt:     updatedAt,
// 	}

// 	for _, item := range request.RequestItems {

// 		findTrashCategory, err := s.repoTrash.GetCategoryByID(item.TrashCategoryID)
// 		if err != nil {
// 			return nil, fmt.Errorf("trash category with ID %s not found", item.TrashCategoryID)
// 		}

// 		modelItem := model.RequestPickupItem{
// 			RequestPickupId: modelRequest.ID,
// 			TrashCategoryId: findTrashCategory.ID,
// 			EstimatedAmount: item.EstimatedAmount,
// 		}
// 		err = s.repo.CreateRequestPickupItem(&modelItem)
// 		if err != nil {
// 			return nil, fmt.Errorf("failed to create request pickup item: %v", err)
// 		}

// 		response.RequestItems = append(response.RequestItems, dto.ResponseRequestPickupItem{
// 			ID:              modelItem.ID,
// 			TrashCategory:   []dto.ResponseTrashCategoryDTO{{Name: findTrashCategory.Name, Icon: findTrashCategory.Icon}},
// 			EstimatedAmount: modelItem.EstimatedAmount,
// 		})
// 	}

// 	return response, nil
// }

// func (s *requestPickupService) GetRequestPickupByID(id string) (*dto.ResponseRequestPickup, error) {

// 	request, err := s.repo.FindRequestPickupByID(id)
// 	if err != nil {
// 		return nil, fmt.Errorf("error fetching request pickup with ID %s: %v", id, err)
// 	}

// 	createdAt, _ := utils.FormatDateToIndonesianFormat(request.CreatedAt)
// 	updatedAt, _ := utils.FormatDateToIndonesianFormat(request.UpdatedAt)

// 	response := &dto.ResponseRequestPickup{
// 		ID:            request.ID,
// 		UserId:        request.UserId,
// 		AddressID:     request.AddressId,
// 		EvidenceImage: request.EvidenceImage,
// 		StatusPickup:  request.StatusPickup,
// 		CreatedAt:     createdAt,
// 		UpdatedAt:     updatedAt,
// 	}

// 	return response, nil
// }

// func (s *requestPickupService) GetAllRequestPickups(userid string) ([]dto.ResponseRequestPickup, error) {

// 	requests, err := s.repo.FindAllRequestPickups(userid)
// 	if err != nil {
// 		return nil, fmt.Errorf("error fetching all request pickups: %v", err)
// 	}

// 	var response []dto.ResponseRequestPickup
// 	for _, request := range requests {
// 		createdAt, _ := utils.FormatDateToIndonesianFormat(request.CreatedAt)
// 		updatedAt, _ := utils.FormatDateToIndonesianFormat(request.UpdatedAt)
// 		response = append(response, dto.ResponseRequestPickup{
// 			ID:            request.ID,
// 			UserId:        request.UserId,
// 			AddressID:     request.AddressId,
// 			EvidenceImage: request.EvidenceImage,
// 			StatusPickup:  request.StatusPickup,
// 			CreatedAt:     createdAt,
// 			UpdatedAt:     updatedAt,
// 		})
// 	}

// 	return response, nil
// }

// // func (s *requestPickupService) GetRequestPickupsForCollector(collectorId string) ([]dto.ResponseRequestPickup, error) {
// // 	requests, err := s.repo.GetAutomaticRequestPickupsForCollector()
// // 	if err != nil {
// // 		return nil, fmt.Errorf("error retrieving automatic pickup requests: %v", err)
// // 	}

// // 	var response []dto.ResponseRequestPickup

// // 	for _, req := range requests {

// // 		collector, err := s.repoColl.FindCollectorById(collectorId)
// // 		if err != nil {
// // 			return nil, fmt.Errorf("error fetching collector data: %v", err)
// // 		}

// // 		_, distance := utils.Distance(
// // 			utils.Coord{Lat: collector.Address.Latitude, Lon: collector.Address.Longitude},
// // 			utils.Coord{Lat: req.Address.Latitude, Lon: req.Address.Longitude},
// // 		)

// // 		if distance <= 20 {

// // 			mappedRequest := dto.ResponseRequestPickup{
// // 				ID:            req.ID,
// // 				UserId:        req.UserId,
// // 				AddressID:     req.AddressId,
// // 				EvidenceImage: req.EvidenceImage,
// // 				StatusPickup:  req.StatusPickup,
// // 				CreatedAt:     req.CreatedAt.Format("2006-01-02 15:04:05"),
// // 				UpdatedAt:     req.UpdatedAt.Format("2006-01-02 15:04:05"),
// // 			}

// // 			user, err := s.repoUser.FindByID(req.UserId)
// // 			if err != nil {
// // 				return nil, fmt.Errorf("error fetching user data: %v", err)
// // 			}
// // 			mappedRequest.User = []dto.UserResponseDTO{
// // 				{
// // 					Name:  user.Name,
// // 					Phone: user.Phone,
// // 				},
// // 			}

// // 			address, err := s.repoAddress.FindAddressByID(req.AddressId)
// // 			if err != nil {
// // 				return nil, fmt.Errorf("error fetching address data: %v", err)
// // 			}
// // 			mappedRequest.Address = []dto.AddressResponseDTO{
// // 				{
// // 					District: address.District,
// // 					Village:  address.Village,
// // 					Detail:   address.Detail,
// // 				},
// // 			}

// // 			requestItems, err := s.repo.GetRequestPickupItems(req.ID)
// // 			if err != nil {
// // 				return nil, fmt.Errorf("error fetching request items: %v", err)
// // 			}

// // 			var mappedRequestItems []dto.ResponseRequestPickupItem

// // 			for _, item := range requestItems {
// // 				trashCategory, err := s.repoTrash.GetCategoryByID(item.TrashCategoryId)
// // 				if err != nil {
// // 					return nil, fmt.Errorf("error fetching trash category: %v", err)
// // 				}

// // 				mappedRequestItems = append(mappedRequestItems, dto.ResponseRequestPickupItem{
// // 					ID: item.ID,
// // 					TrashCategory: []dto.ResponseTrashCategoryDTO{{
// // 						Name: trashCategory.Name,
// // 						Icon: trashCategory.Icon,
// // 					}},
// // 					EstimatedAmount: item.EstimatedAmount,
// // 				})
// // 			}

// // 			mappedRequest.RequestItems = mappedRequestItems

// // 			response = append(response, mappedRequest)
// // 		}
// // 	}

// // 	return response, nil
// // }

// // func (s *requestPickupService) GetManualRequestPickupsForCollector(collectorId string) ([]dto.ResponseRequestPickup, error) {

// // 	collector, err := s.repoColl.FindCollectorById(collectorId)
// // 	if err != nil {
// // 		return nil, fmt.Errorf("error fetching collector data: %v", err)
// // 	}
// // 	requests, err := s.repo.GetManualReqMethodforCollect(collector.ID)
// // 	if err != nil {
// // 		return nil, fmt.Errorf("error retrieving manual pickup requests: %v", err)
// // 	}

// // 	var response []dto.ResponseRequestPickup

// // 	for _, req := range requests {

// // 		createdAt, _ := utils.FormatDateToIndonesianFormat(req.CreatedAt)
// // 		updatedAt, _ := utils.FormatDateToIndonesianFormat(req.UpdatedAt)

// // 		mappedRequest := dto.ResponseRequestPickup{
// // 			ID:            req.ID,
// // 			UserId:        req.UserId,
// // 			AddressID:     req.AddressId,
// // 			EvidenceImage: req.EvidenceImage,
// // 			StatusPickup:  req.StatusPickup,
// // 			CreatedAt:     createdAt,
// // 			UpdatedAt:     updatedAt,
// // 		}

// // 		user, err := s.repoUser.FindByID(req.UserId)
// // 		if err != nil {
// // 			return nil, fmt.Errorf("error fetching user data: %v", err)
// // 		}
// // 		mappedRequest.User = []dto.UserResponseDTO{
// // 			{
// // 				Name:  user.Name,
// // 				Phone: user.Phone,
// // 			},
// // 		}

// // 		address, err := s.repoAddress.FindAddressByID(req.AddressId)
// // 		if err != nil {
// // 			return nil, fmt.Errorf("error fetching address data: %v", err)
// // 		}
// // 		mappedRequest.Address = []dto.AddressResponseDTO{
// // 			{
// // 				District: address.District,
// // 				Village:  address.Village,
// // 				Detail:   address.Detail,
// // 			},
// // 		}

// // 		requestItems, err := s.repo.GetRequestPickupItems(req.ID)
// // 		if err != nil {
// // 			return nil, fmt.Errorf("error fetching request items: %v", err)
// // 		}

// // 		var mappedRequestItems []dto.ResponseRequestPickupItem

// // 		for _, item := range requestItems {

// // 			trashCategory, err := s.repoTrash.GetCategoryByID(item.TrashCategoryId)
// // 			if err != nil {
// // 				return nil, fmt.Errorf("error fetching trash category: %v", err)
// // 			}

// // 			mappedRequestItems = append(mappedRequestItems, dto.ResponseRequestPickupItem{
// // 				ID: item.ID,
// // 				TrashCategory: []dto.ResponseTrashCategoryDTO{{
// // 					Name: trashCategory.Name,
// // 					Icon: trashCategory.Icon,
// // 				}},
// // 				EstimatedAmount: item.EstimatedAmount,
// // 			})
// // 		}

// // 		mappedRequest.RequestItems = mappedRequestItems

// // 		response = append(response, mappedRequest)
// // 	}

// // 	return response, nil
// // }

// // func (s *requestPickupService) SelectCollectorInRequest(userId, collectorId string) error {

// // 	request, err := s.repo.FindRequestPickupByStatus(userId, "waiting_collector", "manual")
// // 	if err != nil {
// // 		return fmt.Errorf("request pickup not found: %v", err)
// // 	}

// // 	if request.StatusPickup != "waiting_collector" && request.RequestMethod != "manual" {
// // 		return fmt.Errorf("pickup request is not in 'waiting_collector' status and not 'manual' method")
// // 	}

// // 	collector, err := s.repoColl.FindCollectorByIdWithoutAddr(collectorId)
// // 	if err != nil {
// // 		return fmt.Errorf("collector tidak ditemukan: %v", err)
// // 	}

// // 	request.CollectorID = &collector.ID

// // 	err = s.repo.UpdateRequestPickup(request.ID, request)
// // 	if err != nil {
// // 		return fmt.Errorf("failed to update request pickup: %v", err)
// // 	}

// // 	return nil
// // }