package order

import "errors"

var (
	ErrDependencyUnavailable = errors.New("dependency unavailable")
	ErrInvalidRentHours      = errors.New("invalid rent hours")
	ErrListingUnavailable    = errors.New("listing unavailable")
	ErrCannotRentOwnListing  = errors.New("cannot rent own listing")
	ErrOrderCannotCancel     = errors.New("order cannot cancel")
	ErrOrderCannotHandoff    = errors.New("order cannot handoff")
	ErrOrderCannotReceive    = errors.New("order cannot receive")
	ErrOrderCannotReturn     = errors.New("order cannot return")
	ErrOrderCannotComplete   = errors.New("order cannot complete")
	ErrPermissionDenied      = errors.New("permission denied")
)

type Service struct {
	repo *Repository
}

func NewService(repo *Repository) *Service {
	return &Service{repo: repo}
}

func (s *Service) Create(userID uint64, req CreateRequest) (*OrderDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	if req.ListingID == 0 || req.RentHours <= 0 {
		return nil, ErrInvalidRentHours
	}
	return s.repo.Create(userID, req)
}

func (s *Service) Cancel(userID uint64, orderID uint64) error {
	if s.repo == nil {
		return ErrDependencyUnavailable
	}
	return s.repo.Cancel(userID, orderID)
}

func (s *Service) SubmitHandoff(userID uint64, orderID uint64, req SubmitHandoffRequest) (*HandoffRecordDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	if orderID == 0 || req.Content == "" {
		return nil, ErrOrderCannotHandoff
	}
	return s.repo.SubmitHandoff(userID, orderID, req)
}

func (s *Service) ConfirmReceive(userID uint64, orderID uint64) error {
	if s.repo == nil {
		return ErrDependencyUnavailable
	}
	return s.repo.ConfirmReceive(userID, orderID)
}

func (s *Service) HandoffRecords(userID uint64, orderID uint64) ([]HandoffRecordDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	return s.repo.HandoffRecords(userID, orderID)
}

func (s *Service) SubmitReturn(userID uint64, orderID uint64, req SubmitReturnRequest) (*HandoffRecordDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	if orderID == 0 || req.Content == "" {
		return nil, ErrOrderCannotReturn
	}
	return s.repo.SubmitReturn(userID, orderID, req)
}

func (s *Service) ConfirmReturn(userID uint64, orderID uint64) error {
	if s.repo == nil {
		return ErrDependencyUnavailable
	}
	return s.repo.ConfirmReturn(userID, orderID)
}

func (s *Service) ListForUser(userID uint64) ([]OrderDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	return s.repo.ListForUser(userID)
}

func (s *Service) ListAdmin() ([]OrderDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	return s.repo.ListAdmin()
}

func (s *Service) FindAdmin(orderID uint64) (*OrderDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	return s.repo.FindAdmin(orderID)
}

func (s *Service) HandoffRecordsAdmin(orderID uint64) ([]HandoffRecordDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	return s.repo.HandoffRecordsAdmin(orderID)
}

func (s *Service) FindForUser(userID uint64, orderID uint64) (*OrderDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	return s.repo.FindForUser(userID, orderID)
}