package listing

import (
	"errors"
)

var (
	ErrDependencyUnavailable = errors.New("dependency unavailable")
	ErrInvalidInput          = errors.New("invalid listing input")
	ErrListingLocked         = errors.New("listing locked")
)

type Service struct {
	repo *Repository
}

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

func (s *Service) Create(ownerID uint64, req CreateRequest) (*ListingDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	if err := validateRequest(req); err != nil {
		return nil, err
	}
	return s.repo.Create(ownerID, req)
}

func (s *Service) Update(ownerID uint64, id uint64, req UpdateRequest) (*ListingDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	if err := validateRequest(req); err != nil {
		return nil, err
	}
	return s.repo.Update(ownerID, id, req)
}

func (s *Service) SubmitReview(ownerID uint64, id uint64) (*ListingDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	return s.repo.SubmitReview(ownerID, id)
}

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

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

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

func (s *Service) AdminOffline(adminID uint64, id uint64, req AdminActionRequest, meta AuditMeta) (*ListingDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	if req.Reason == "" {
		return nil, ErrInvalidInput
	}
	return s.repo.AdminOffline(adminID, id, req, meta)
}

func (s *Service) AdminMarkAbnormal(adminID uint64, id uint64, req AdminActionRequest, meta AuditMeta) (*ListingDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	if req.Reason == "" {
		return nil, ErrInvalidInput
	}
	return s.repo.AdminMarkAbnormal(adminID, id, req, meta)
}

func (s *Service) Approve(id uint64) (*ListingDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	return s.repo.Approve(id)
}

func (s *Service) Reject(id uint64, req ReviewRequest) (*ListingDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	if req.Reason == "" {
		return nil, ErrInvalidInput
	}
	return s.repo.Reject(id, req)
}

func (s *Service) Offline(ownerID uint64, id uint64) error {
	if s.repo == nil {
		return ErrDependencyUnavailable
	}
	return s.repo.Offline(ownerID, id)
}

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

func (s *Service) ListMine(ownerID uint64) ([]ListingDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	return s.repo.ListMine(ownerID)
}

func (s *Service) FindPublic(id uint64) (*ListingDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	return s.repo.FindPublic(id)
}

func (s *Service) FindMine(ownerID uint64, id uint64) (*ListingDTO, error) {
	if s.repo == nil {
		return nil, ErrDependencyUnavailable
	}
	return s.repo.FindMine(ownerID, id)
}

func validateRequest(req CreateRequest) error {
	if req.Title == "" || req.ServerRegion == "" {
		return ErrInvalidInput
	}
	if req.PriceHourly <= 0 || req.DepositAmount < 0 {
		return ErrInvalidInput
	}
	if req.MinRentHours <= 0 || req.MaxRentHours < req.MinRentHours {
		return ErrInvalidInput
	}
	if req.HafCoinAmount < 0 {
		return ErrInvalidInput
	}
	return nil
}