package service

import (
	"context"

	"apskel-pos-be/internal/constants"
	"apskel-pos-be/internal/contract"
	"apskel-pos-be/internal/models"
	"apskel-pos-be/internal/processor"
	"apskel-pos-be/internal/transformer"

	"github.com/google/uuid"
)

type ProductOutletPriceService interface {
	Upsert(ctx context.Context, req *contract.CreateProductOutletPriceRequest) *contract.Response
	GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) *contract.Response
	GetByProduct(ctx context.Context, productID uuid.UUID) *contract.Response
	GetByOutlet(ctx context.Context, outletID uuid.UUID) *contract.Response
	Delete(ctx context.Context, id uuid.UUID) *contract.Response
	BulkUpsert(ctx context.Context, req *contract.BulkCreateProductOutletPriceRequest) *contract.Response
}

type ProductOutletPriceServiceImpl struct {
	processor processor.ProductOutletPriceProcessor
}

func NewProductOutletPriceService(proc processor.ProductOutletPriceProcessor) *ProductOutletPriceServiceImpl {
	return &ProductOutletPriceServiceImpl{
		processor: proc,
	}
}

func (s *ProductOutletPriceServiceImpl) Upsert(ctx context.Context, req *contract.CreateProductOutletPriceRequest) *contract.Response {
	modelReq := transformer.CreateProductOutletPriceRequestToModel(req)

	result, err := s.processor.Upsert(ctx, modelReq)
	if err != nil {
		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
	}

	contractResp := transformer.ProductOutletPriceModelToResponse(result)
	return contract.BuildSuccessResponse(contractResp)
}

func (s *ProductOutletPriceServiceImpl) GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) *contract.Response {
	result, err := s.processor.GetByProductAndOutlet(ctx, productID, outletID)
	if err != nil {
		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
	}

	contractResp := transformer.ProductOutletPriceModelToResponse(result)
	return contract.BuildSuccessResponse(contractResp)
}

func (s *ProductOutletPriceServiceImpl) GetByProduct(ctx context.Context, productID uuid.UUID) *contract.Response {
	results, err := s.processor.GetByProduct(ctx, productID)
	if err != nil {
		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
	}

	contractResps := transformer.ProductOutletPriceModelsToResponses(results)
	return contract.BuildSuccessResponse(&contract.ListProductOutletPricesResponse{
		Prices:     contractResps,
		TotalCount: len(contractResps),
	})
}

func (s *ProductOutletPriceServiceImpl) GetByOutlet(ctx context.Context, outletID uuid.UUID) *contract.Response {
	results, err := s.processor.GetByOutlet(ctx, outletID)
	if err != nil {
		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
	}

	contractResps := transformer.ProductOutletPriceModelsToResponses(results)
	return contract.BuildSuccessResponse(&contract.ListProductOutletPricesResponse{
		Prices:     contractResps,
		TotalCount: len(contractResps),
	})
}

func (s *ProductOutletPriceServiceImpl) Delete(ctx context.Context, id uuid.UUID) *contract.Response {
	err := s.processor.Delete(ctx, id)
	if err != nil {
		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
	}

	return contract.BuildSuccessResponse(map[string]interface{}{
		"message": "Product outlet price deleted successfully",
	})
}

func (s *ProductOutletPriceServiceImpl) BulkUpsert(ctx context.Context, req *contract.BulkCreateProductOutletPriceRequest) *contract.Response {
	prices := make([]models.CreateProductOutletPriceRequest, len(req.Prices))
	for i, p := range req.Prices {
		prices[i] = models.CreateProductOutletPriceRequest{
			ProductID: req.ProductID,
			OutletID:  p.OutletID,
			Price:     p.Price,
		}
	}

	results, err := s.processor.BulkUpsert(ctx, req.ProductID, prices)
	if err != nil {
		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
	}

	contractResps := transformer.ProductOutletPriceModelsToResponses(results)
	return contract.BuildSuccessResponse(&contract.ListProductOutletPricesResponse{
		Prices:     contractResps,
		TotalCount: len(contractResps),
	})
}