lti-api/internal/common/service/common.hpp.service.go

package service

import (
	"context"
	"time"

	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
)

type HppService interface {
	CalculateHppCost(projectFlockKandangId uint, date *time.Time) (*HppCostResponse, error)
	GetTotalDepresiasiFlockGrowing(sourceProjectFlockID uint, date *time.Time) (float64, error)
	GetTotalProductionCost(projectFlockKandangId uint, date *time.Time, totalDepresiasiGrowing float64) (float64, error)
}

type HppCostResponse struct {
	Estimation HppCostDetail `json:"estimation"`
	Real       HppCostDetail `json:"real"`
}

type HppCostDetail struct {
	HargaKg    float64 `json:"harga_kg"`
	HargaButir float64 `json:"harga_butir"`
	Total      float64 `json:"total"`
	Kg         float64 `json:"kg"`
	Butir      float64 `json:"butir"`
}

type hppService struct {
	hppRepo commonRepo.HppCostRepository
}

func NewHppService(hppRepo commonRepo.HppCostRepository) HppService {
	return &hppService{hppRepo: hppRepo}
}

func (s *hppService) CalculateHppCost(projectFlockKandangId uint, date *time.Time) (*HppCostResponse, error) {
	if date == nil {
		now := time.Now()
		date = &now
	}

	var sourceProjectFlockID uint
	var transferTotalQty float64
	var err error
	sourceProjectFlockID, transferTotalQty, err = s.hppRepo.GetTransferSourceSummary(context.Background(), projectFlockKandangId)
	if err != nil {
		return nil, err
	}

	kandangIDsGrowing, err := s.hppRepo.GetProjectFlockKandangIDs(context.Background(), sourceProjectFlockID)

	if err != nil {
		return nil, err
	}

	totalPopulationFlockGrowing, err := s.hppRepo.GetTotalPopulation(context.Background(), kandangIDsGrowing)
	if err != nil {
		return nil, err
	}

	totalDepresiasiFlockGrowing, err := s.GetTotalDepresiasiFlockGrowing(sourceProjectFlockID, date)
	if err != nil {
		return nil, err
	}

	depresiasiTransfer := (totalDepresiasiFlockGrowing * transferTotalQty) / totalPopulationFlockGrowing

	_, err = s.GetTotalProductionCost(projectFlockKandangId, date, depresiasiTransfer)
	if err != nil {
		return nil, err
	}

	return &HppCostResponse{
		Estimation: HppCostDetail{},
		Real:       HppCostDetail{},
	}, nil
}

func (s *hppService) GetTotalDepresiasiFlockGrowing(sourceProjectFlockID uint, date *time.Time) (float64, error) {
	if date == nil {
		now := time.Now()
		date = &now
	}

	if s.hppRepo == nil {
		return 0, nil
	}

	kandangIDs, err := s.hppRepo.GetProjectFlockKandangIDs(context.Background(), sourceProjectFlockID)
	if err != nil {
		return 0, err
	}

	docCost, err := s.hppRepo.GetDocCost(context.Background(), kandangIDs)
	if err != nil {
		return 0, err
	}

	budgetCost, err := s.hppRepo.GetBudgetCostByProjectFlockId(context.Background(), sourceProjectFlockID)
	if err != nil {
		return 0, err
	}

	expedisionCost, err := s.hppRepo.GetExpedisionCost(context.Background(), kandangIDs)
	if err != nil {
		return 0, err
	}

	feedCost, err := s.hppRepo.GetFeedCost(context.Background(), kandangIDs, date)
	if err != nil {
		return 0, err
	}

	ovkCost, err := s.hppRepo.GetOvkCost(context.Background(), kandangIDs, date)
	if err != nil {
		return 0, err
	}

	return docCost + budgetCost + expedisionCost + feedCost + ovkCost, nil
}

func (s *hppService) GetTotalProductionCost(projectFlockKandangId uint, date *time.Time, depresiasiTransfer float64) (float64, error) {
	if date == nil {
		now := time.Now()
		date = &now
	}

	costPullet, err := s.hppRepo.GetPulletCost(context.Background(), projectFlockKandangId)
	if err != nil {
		return 0, err

	}

	_ = date

	return depresiasiTransfer + costPullet, nil
}