package hostorg

import (
	"context"
	"fmt"
	"strconv"
	"strings"

	"hyapp-admin-server/internal/integration/userclient"
)

type Service struct {
	userClient userclient.Client
	reader     *Reader
}

func NewService(userClient userclient.Client, reader *Reader) *Service {
	return &Service{userClient: userClient, reader: reader}
}

func (s *Service) ListBDLeaders(ctx context.Context, query listQuery) ([]*userclient.BDProfile, int64, error) {
	query = normalizeListQuery(query)
	return s.reader.ListBDProfiles(ctx, query, "bd_leader")
}

func (s *Service) ListBDs(ctx context.Context, query listQuery) ([]*userclient.BDProfile, int64, error) {
	query = normalizeListQuery(query)
	return s.reader.ListBDProfiles(ctx, query, "bd")
}

func (s *Service) ListAgencies(ctx context.Context, query listQuery) ([]*userclient.Agency, int64, error) {
	query = normalizeListQuery(query)
	return s.reader.ListAgencies(ctx, query)
}

func (s *Service) ListHosts(ctx context.Context, query listQuery) ([]*userclient.HostProfile, int64, error) {
	query = normalizeListQuery(query)
	return s.reader.ListHostProfiles(ctx, query)
}

func (s *Service) ListCoinSellers(ctx context.Context, query listQuery) ([]*CoinSellerListItem, int64, error) {
	query = normalizeListQuery(query)
	return s.reader.ListCoinSellers(ctx, query)
}

func (s *Service) CreateBDLeader(ctx context.Context, actorID int64, requestID string, req createBDLeaderRequest) (*userclient.BDProfile, error) {
	targetUserID, err := s.resolveDisplayUserID(ctx, requestID, req.TargetUserID)
	if err != nil {
		return nil, err
	}
	// BD Leader 创建时后台选择的区域是显式运营归属，由 user-service 在同一事务里更新 users.region_id 和 bd_profiles.region_id。
	return s.userClient.CreateBDLeader(ctx, userclient.CreateBDLeaderRequest{
		RequestID:    requestID,
		Caller:       "hyapp-admin-server",
		CommandID:    strings.TrimSpace(req.CommandID),
		AdminUserID:  actorID,
		RegionID:     req.RegionID,
		TargetUserID: targetUserID,
		Reason:       strings.TrimSpace(req.Reason),
	})
}

func (s *Service) CreateBD(ctx context.Context, actorID int64, requestID string, req createBDRequest) (*userclient.BDProfile, error) {
	targetUserID, err := s.resolveDisplayUserID(ctx, requestID, req.TargetUserID)
	if err != nil {
		return nil, err
	}
	parentLeaderUserID, err := s.resolveDisplayUserID(ctx, requestID, req.ParentLeaderUserID)
	if err != nil {
		return nil, err
	}
	return s.userClient.CreateBD(ctx, userclient.CreateBDRequest{
		RequestID:          requestID,
		Caller:             "hyapp-admin-server",
		CommandID:          strings.TrimSpace(req.CommandID),
		AdminUserID:        actorID,
		TargetUserID:       targetUserID,
		ParentLeaderUserID: parentLeaderUserID,
		Reason:             strings.TrimSpace(req.Reason),
	})
}

func (s *Service) SetBDStatus(ctx context.Context, actorID int64, targetUserID int64, requestID string, req bdStatusRequest) (*userclient.BDProfile, error) {
	return s.userClient.SetBDStatus(ctx, userclient.SetBDStatusRequest{
		RequestID:    requestID,
		Caller:       "hyapp-admin-server",
		CommandID:    strings.TrimSpace(req.CommandID),
		AdminUserID:  actorID,
		TargetUserID: targetUserID,
		Status:       strings.TrimSpace(req.Status),
		Reason:       strings.TrimSpace(req.Reason),
	})
}

func (s *Service) CreateCoinSeller(ctx context.Context, actorID int64, requestID string, req createCoinSellerRequest) (*userclient.CoinSellerProfile, error) {
	targetUserID, err := s.resolveDisplayUserID(ctx, requestID, req.TargetUserID)
	if err != nil {
		return nil, err
	}
	return s.userClient.CreateCoinSeller(ctx, userclient.CreateCoinSellerRequest{
		RequestID:    requestID,
		Caller:       "hyapp-admin-server",
		CommandID:    strings.TrimSpace(req.CommandID),
		AdminUserID:  actorID,
		TargetUserID: targetUserID,
		Reason:       strings.TrimSpace(req.Reason),
	})
}

func (s *Service) SetCoinSellerStatus(ctx context.Context, actorID int64, targetUserID int64, requestID string, req coinSellerStatusRequest) (*userclient.CoinSellerProfile, error) {
	return s.userClient.SetCoinSellerStatus(ctx, userclient.SetCoinSellerStatusRequest{
		RequestID:    requestID,
		Caller:       "hyapp-admin-server",
		CommandID:    strings.TrimSpace(req.CommandID),
		AdminUserID:  actorID,
		TargetUserID: targetUserID,
		Status:       strings.TrimSpace(req.Status),
		Reason:       strings.TrimSpace(req.Reason),
	})
}

func (s *Service) CreateAgency(ctx context.Context, actorID int64, requestID string, req createAgencyRequest) (*userclient.CreateAgencyResult, error) {
	ownerUserID, err := s.resolveDisplayUserID(ctx, requestID, req.OwnerUserID)
	if err != nil {
		return nil, err
	}
	parentBDUserID, err := s.resolveDisplayUserID(ctx, requestID, req.ParentBDUserID)
	if err != nil {
		return nil, err
	}
	joinEnabled := false
	if req.JoinEnabled != nil {
		joinEnabled = *req.JoinEnabled
	}
	return s.userClient.CreateAgency(ctx, userclient.CreateAgencyRequest{
		RequestID:      requestID,
		Caller:         "hyapp-admin-server",
		CommandID:      strings.TrimSpace(req.CommandID),
		AdminUserID:    actorID,
		OwnerUserID:    ownerUserID,
		ParentBDUserID: parentBDUserID,
		Name:           strings.TrimSpace(req.Name),
		JoinEnabled:    joinEnabled,
		MaxHosts:       req.MaxHosts,
		Reason:         strings.TrimSpace(req.Reason),
	})
}

func (s *Service) CloseAgency(ctx context.Context, actorID int64, agencyID int64, requestID string, req agencyCloseRequest) (*userclient.Agency, error) {
	return s.userClient.CloseAgency(ctx, userclient.CloseAgencyRequest{
		RequestID:   requestID,
		Caller:      "hyapp-admin-server",
		CommandID:   strings.TrimSpace(req.CommandID),
		AdminUserID: actorID,
		AgencyID:    agencyID,
		Reason:      strings.TrimSpace(req.Reason),
	})
}

func (s *Service) resolveDisplayUserID(ctx context.Context, requestID string, displayUserID int64) (int64, error) {
	if displayUserID <= 0 {
		return 0, fmt.Errorf("display_user_id is required")
	}
	identity, err := s.userClient.ResolveDisplayUserID(ctx, userclient.ResolveDisplayUserIDRequest{
		RequestID:     requestID,
		Caller:        "hyapp-admin-server",
		DisplayUserID: strconv.FormatInt(displayUserID, 10),
	})
	if err != nil {
		return 0, err
	}
	if identity == nil || identity.UserID <= 0 {
		return 0, fmt.Errorf("display_user_id %d not found", displayUserID)
	}
	return identity.UserID, nil
}

func (s *Service) SetAgencyJoinEnabled(ctx context.Context, actorID int64, agencyID int64, requestID string, req agencyJoinEnabledRequest) (*userclient.Agency, error) {
	joinEnabled := false
	if req.JoinEnabled != nil {
		joinEnabled = *req.JoinEnabled
	}
	return s.userClient.SetAgencyJoinEnabled(ctx, userclient.SetAgencyJoinEnabledRequest{
		RequestID:   requestID,
		Caller:      "hyapp-admin-server",
		CommandID:   strings.TrimSpace(req.CommandID),
		AdminUserID: actorID,
		AgencyID:    agencyID,
		JoinEnabled: joinEnabled,
		Reason:      strings.TrimSpace(req.Reason),
	})
}

func normalizeListQuery(query listQuery) listQuery {
	if query.Page < 1 {
		query.Page = 1
	}
	if query.PageSize < 1 {
		query.PageSize = 20
	}
	if query.PageSize > 100 {
		query.PageSize = 100
	}
	query.Keyword = strings.TrimSpace(query.Keyword)
	query.Status = strings.ToLower(strings.TrimSpace(query.Status))
	return query
}