package usecase

import (
	"fmt"
	"time"
	"users_management/m/model/dto/req"
	"users_management/m/model/dto/res"
	"users_management/m/model/entity"
	"users_management/m/repository"
	"users_management/m/utils/helper"

	"github.com/go-playground/validator/v10"
	"github.com/google/uuid"
)

type BackboneUseCase interface {
	CreateBackbone(backbone req.BackboneDTO) error
	GetAllBackbone() ([]res.BackboneResponse, error)

	GetByID(id uuid.UUID) (res.BackboneResponse, error)
	UpdateBackbone(id uuid.UUID, backbone req.UpdateBackboneDTO) error
}

type backboneUseCase struct {
	backboneRepo repository.BackboneRepo
	fishboneRepo repository.FishboneRepo
	validate *validator.Validate
}

func NewBackboneUseCase(backboneRepo repository.BackboneRepo, fishboneRepo repository.FishboneRepo) BackboneUseCase {
	return &backboneUseCase{
		backboneRepo: backboneRepo,
		fishboneRepo: fishboneRepo,
		validate: validator.New(),
	}
}

func (u *backboneUseCase) CreateBackbone(backbone req.BackboneDTO) error {
	err := u.validate.Struct(backbone)
	if err != nil {
		return fmt.Errorf("validation error: %w", err)
	}

	newBackbone := entity.Backbone{
		ID: uuid.New(),
		DeviceStartID: backbone.DeviceStartID,
		DeviceEndID: backbone.DeviceEndID,
		CoreAmount: backbone.CoreAmount,
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
	}

	
	return u.backboneRepo.Post(newBackbone)
}

func (u *backboneUseCase) GetAllBackbone() ([]res.BackboneResponse, error) {
	backbones, err := u.backboneRepo.GetAll()
	if err != nil {
		return nil, err
	}
	totalFishbone,err := u.fishboneRepo.CountFishbone()
	if err != nil {
		return nil, err
	}

	backboneResp, err := helper.ConvertToBackboneResponses(backbones,totalFishbone)

	if err != nil {
		return nil, err
	}
	return backboneResp, nil
}

func (u *backboneUseCase) GetByID(id uuid.UUID) (res.BackboneResponse, error) {
	backbone, err := u.backboneRepo.GetByID(id)
	if err != nil {
		return res.BackboneResponse{}, err
	}

	fishboneCount, err := u.fishboneRepo.CountFishboneByBackboneID(backbone.ID)

	if err != nil {
		return res.BackboneResponse{}, err
	}

	backboneResp, err := helper.ConvertToBackboneRespId(backbone,fishboneCount)

	if err != nil {
		return res.BackboneResponse{}, err
	}
	
	return backboneResp, nil
}

func (u *backboneUseCase) UpdateBackbone(id uuid.UUID, backbone req.UpdateBackboneDTO) error {
	err := u.validate.Struct(backbone)
	if err != nil {
		return fmt.Errorf("validation error: %w", err)
	}

	updates := make(map[string]interface{})

	if backbone.DeviceStartID != nil {
		updates["DeviceStartID"] = backbone.DeviceStartID
	}

	if backbone.DeviceEndID != nil {
		updates["DeviceEndID"] = backbone.DeviceEndID
	}

	if backbone.CoreAmount != nil {
		updates["CoreAmount"] = backbone.CoreAmount
	}

	updates["UpdatedAt"] = time.Now()

	return u.backboneRepo.Update(id, updates)
}