package distribution

import (
	"context"
	"errors"

	"hfb_sys/backend/internal/model"
	"hfb_sys/backend/internal/modules/auth"
)

var ErrDependencyUnavailable = errors.New("distribution dependency unavailable")

type Service struct {
	repo *Repository
	jwt  *auth.JWTManager
}

func NewService(repo *Repository, jwt ...*auth.JWTManager) *Service {
	s := &Service{repo: repo}
	if len(jwt) > 0 {
		s.jwt = jwt[0]
	}
	return s
}

func (s *Service) available() error {
	if s == nil || s.repo == nil {
		return ErrDependencyUnavailable
	}
	return nil
}
func (s *Service) ListSites(ctx context.Context) ([]SiteDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListSites(ctx)
}
func (s *Service) ListSitesForAdmin(ctx context.Context, adminID uint64) ([]SiteDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	items, err := s.repo.ListSites(ctx)
	if err != nil {
		return nil, err
	}
	var members []model.DistributionSiteMember
	if adminID == 0 || s.repo.db == nil {
		return items, nil
	}
	if err := s.repo.db.WithContext(ctx).Where("admin_user_id = ? AND status = 'active'", adminID).Find(&members).Error; err != nil {
		return nil, err
	}
	if len(members) == 0 {
		return items, nil
	}
	allowed := make(map[uint64]struct{}, len(members))
	for _, member := range members {
		allowed[member.SiteID] = struct{}{}
	}
	filtered := make([]SiteDTO, 0, len(allowed))
	for _, item := range items {
		if _, ok := allowed[item.ID]; ok {
			filtered = append(filtered, item)
		}
	}
	return filtered, nil
}
func (s *Service) ScopeSiteID(ctx context.Context, adminID, requested uint64) (uint64, error) {
	if err := s.available(); err != nil {
		return 0, err
	}
	return s.repo.ScopeSiteID(ctx, adminID, requested)
}
func (s *Service) FindSite(ctx context.Context, adminID, id uint64) (*SiteDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.FindSite(ctx, adminID, id)
}
func (s *Service) CreateSite(ctx context.Context, req CreateSiteRequest) (*SiteDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.CreateSite(ctx, req)
}
func (s *Service) UpdateSite(ctx context.Context, adminID, id uint64, req UpdateSiteRequest) (*SiteDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.UpdateSite(ctx, adminID, id, req)
}
func (s *Service) ListRules(ctx context.Context, adminID uint64, siteID *uint64, mode string) ([]RuleDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListRules(ctx, adminID, siteID, mode)
}
func (s *Service) CreateRule(ctx context.Context, adminID uint64, req CreateRuleRequest) (*RuleDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.CreateRule(ctx, adminID, req)
}
func (s *Service) UpdateRuleStatus(ctx context.Context, adminID, id uint64, status string) (*RuleDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.UpdateRuleStatus(ctx, adminID, id, status)
}

func (s *Service) ListOrders(ctx context.Context, query DistributionOrderListQuery) (*DistributionOrderPage, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListOrders(ctx, query)
}
func (s *Service) FindOrder(ctx context.Context, adminID, id uint64) (*DistributionOrderDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.FindOrder(ctx, adminID, id)
}
func (s *Service) ListAccountDisplays(ctx context.Context, siteID uint64, status string) ([]AccountDisplayDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListAccountDisplays(ctx, siteID, status)
}
func (s *Service) UpdateAccountDisplay(ctx context.Context, adminID, id uint64, status string) (*AccountDisplayDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.UpdateAccountDisplay(ctx, adminID, id, status)
}
func (s *Service) ListPaymentChannels(ctx context.Context, siteID uint64) ([]PaymentChannelDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListPaymentChannels(ctx, siteID)
}
func (s *Service) BindPaymentChannel(ctx context.Context, siteID uint64, req BindPaymentChannelRequest) (*PaymentChannelDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.BindPaymentChannel(ctx, siteID, req)
}
func (s *Service) UnbindPaymentChannel(ctx context.Context, adminID, id uint64) error {
	if err := s.available(); err != nil {
		return err
	}
	return s.repo.UnbindPaymentChannel(ctx, adminID, id)
}
func (s *Service) ListSettlementBatches(ctx context.Context, siteID uint64) ([]SettlementBatchDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListSettlementBatches(ctx, siteID)
}
func (s *Service) CreateSettlementBatch(ctx context.Context, adminID uint64, req CreateSettlementBatchRequest) (*SettlementBatchDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.CreateSettlementBatch(ctx, adminID, req)
}
func (s *Service) ListSettlementItems(ctx context.Context, adminID, batchID uint64) ([]SettlementItemDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListSettlementItems(ctx, adminID, batchID)
}
func (s *Service) MarkSettlementBatch(ctx context.Context, adminID, id uint64) (*SettlementBatchDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.MarkSettlementBatch(ctx, adminID, id)
}

func (s *Service) CreateFinancialSnapshot(ctx context.Context, adminID, orderID uint64, req CreateFinancialSnapshotRequest) (*DistributionOrderDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.CreateFinancialSnapshot(ctx, adminID, orderID, req)
}

func (s *Service) Login(ctx context.Context, req DistributionLoginRequest, clientIP string) (*DistributionLoginResponse, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	if s.jwt == nil {
		return nil, ErrDependencyUnavailable
	}
	admin, member, err := s.repo.LoginMember(ctx, req.Username, req.Password)
	if err != nil {
		return nil, err
	}
	pair, err := s.jwt.GenerateSubjectPairWithVersion(admin.ID, admin.Username, "admin", admin.TokenVersion)
	if err != nil {
		return nil, err
	}
	return &DistributionLoginResponse{
		Token:        pair.AccessToken,
		RefreshToken: pair.RefreshToken,
		Member:       *member,
	}, nil
}

func (s *Service) Me(ctx context.Context, adminID uint64) (*DistributionCurrentMemberDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.GetMemberProfile(ctx, adminID)
}

func (s *Service) OnboardSite(ctx context.Context, req OnboardSiteRequest) (*OnboardSiteResponse, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.OnboardSite(ctx, req)
}

func (s *Service) SyncSiteAccounts(ctx context.Context, adminID, siteID uint64) (*SyncSiteAccountsResult, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.SyncSiteAccounts(ctx, adminID, siteID)
}

func (s *Service) ListPublicSiteListings(ctx context.Context, siteCode string, page, pageSize int) (*PublicDistributionListingsResult, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListPublicSiteListings(ctx, siteCode, page, pageSize)
}

func (s *Service) GetPublicSiteInfo(ctx context.Context, code, domain string) (*PublicSiteInfoDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.GetPublicSiteInfo(ctx, code, domain)
}

func (s *Service) UpdateSiteBranding(ctx context.Context, adminID, siteID uint64, req UpdateSiteBrandingRequest) (*SiteDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.UpdateSiteBranding(ctx, adminID, siteID, req)
}

func (s *Service) UpdateAccountMarkup(ctx context.Context, adminID, id uint64, markupCent int64) (*AccountDisplayDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.UpdateAccountMarkup(ctx, adminID, id, markupCent)
}

func (s *Service) BatchUpdateAccountMarkup(ctx context.Context, adminID, siteID uint64, req BatchUpdateAccountMarkupRequest) error {
	if err := s.available(); err != nil {
		return err
	}
	return s.repo.BatchUpdateAccountMarkup(ctx, adminID, siteID, req)
}

func (s *Service) ListReceivedListings(ctx context.Context, adminID, siteID uint64, q ReceivedListingQuery) (*ReceivedListingPage, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListReceivedListings(ctx, adminID, siteID, q)
}

func (s *Service) UpdateReceivedListingStatus(ctx context.Context, adminID, listingID uint64, status string) error {
	if err := s.available(); err != nil {
		return err
	}
	return s.repo.UpdateReceivedListingStatus(ctx, adminID, listingID, status)
}

func (s *Service) GetSiteWallet(ctx context.Context, adminID, siteID uint64) (*SiteWalletDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.GetSiteWallet(ctx, adminID, siteID)
}

func (s *Service) ApplySiteWithdrawal(ctx context.Context, adminID, siteID uint64, req ApplySiteWithdrawalRequest) (*SiteWithdrawalDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ApplySiteWithdrawal(ctx, adminID, siteID, req)
}

func (s *Service) ListSiteWithdrawals(ctx context.Context, adminID, siteID uint64, page, size int) (*SiteWithdrawalPage, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListSiteWithdrawals(ctx, adminID, siteID, page, size)
}

func (s *Service) GetDashboardAnalytics(ctx context.Context, adminID, siteID uint64) (*DistributionAnalyticsDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.GetDashboardAnalytics(ctx, adminID, siteID)
}