package usecase

import (
	"context"
	"encoding/base64"
	"fmt"
	"strings"
	"time"

	"apps/backend/internal/module/growth/domain"
)

// PlanQuota returns monthly platform credits by plan id (for invite cap).
type PlanQuota func(planID string) int

// BonusCrediter adds invite bonus points to inviter platform pool.
type BonusCrediter interface {
	CreditInviteBonus(ctx context.Context, uid int64, points int, ref string) error
}

// Notifier optional station notification.
type Notifier interface {
	Notify(ctx context.Context, ownerUID int64, title, body, kind, refType, refID string) error
}

// HealthSignals optional inputs for recompute.
type HealthSignals struct {
	Sends24h           int
	IntervalViolations int
	FailRate7d         float64 // 0..1
	TokenBad           bool
}

type Service struct {
	Repo        domain.Repository
	PlanQuota   PlanQuota
	Bonus       BonusCrediter
	Notifier    Notifier
	SignalProbe string // documentation: "degraded" | "partial" | "full"
}

func New(repo domain.Repository) *Service {
	return &Service{
		Repo:        repo,
		PlanQuota:   defaultPlanQuota,
		SignalProbe: "degraded", // Threads scope not fully available; OC-08 path active
	}
}

func defaultPlanQuota(planID string) int {
	switch strings.ToLower(planID) {
	case "starter":
		return 600
	case "pro":
		return 2000
	default:
		return 120
	}
}

// --- Outcomes ---

func (s *Service) RecordPublished(ctx context.Context, ownerUID int64, sourceType, sourceID, accountID string, sentAt int64) (*domain.OutcomeEvent, error) {
	if ownerUID <= 0 || sourceType == "" || sourceID == "" {
		return nil, fmt.Errorf("%w: missing source", domain.ErrValidation)
	}
	if sentAt <= 0 {
		sentAt = domain.NowNano()
	}
	now := domain.NowNano()
	e := &domain.OutcomeEvent{
		OwnerUID:         ownerUID,
		SourceType:       sourceType,
		SourceID:         sourceID,
		ThreadsAccountID: accountID,
		Kind:             domain.KindReach,
		Confidence:       domain.ConfidenceConfirmed,
		Status:           domain.StatusObserving,
		WindowEndsAt:     sentAt + int64(domain.ObserveWindow),
		SentAt:           sentAt,
		CreatedAt:        now,
		UpdatedAt:        now,
	}
	if err := s.Repo.UpsertOutcomeBySource(ctx, e); err != nil {
		return nil, err
	}
	return s.Repo.GetOutcome(ctx, e.ID)
}

func (s *Service) GetOutcome(ctx context.Context, ownerUID int64, id string) (*domain.OutcomeEvent, error) {
	e, err := s.Repo.GetOutcome(ctx, id)
	if err != nil {
		return nil, err
	}
	if e.OwnerUID != ownerUID {
		return nil, domain.ErrForbidden
	}
	return e, nil
}

func (s *Service) ListOutcomes(ctx context.Context, ownerUID int64, f domain.OutcomeListFilter) ([]*domain.OutcomeEvent, int64, error) {
	if f.Page < 1 {
		f.Page = 1
	}
	if f.PageSize < 1 || f.PageSize > 50 {
		f.PageSize = 20
	}
	return s.Repo.ListOutcomes(ctx, ownerUID, f)
}

func (s *Service) Summary(ctx context.Context, ownerUID int64, from, to int64) (*domain.OutcomeSummary, error) {
	if to <= 0 {
		to = domain.NowNano()
	}
	if from <= 0 {
		from = to - int64(7*24*time.Hour)
	}
	list, _, err := s.Repo.ListOutcomes(ctx, ownerUID, domain.OutcomeListFilter{From: from, To: to, Page: 1, PageSize: 1000})
	if err != nil {
		return nil, err
	}
	sum := &domain.OutcomeSummary{From: from, To: to}
	for _, e := range list {
		sum.Reach++
		if e.Kind == domain.KindReply || e.ReplyCountDelta > 0 {
			sum.Conversations++
		}
		if e.FollowersDelta > 0 || e.Kind == domain.KindFollow {
			follows := e.FollowersDelta
			if follows < 1 {
				follows = 1
			}
			if e.Confidence == domain.ConfidenceConfirmed {
				sum.FollowsConfirmed += follows
			} else {
				sum.FollowsPossible += follows
			}
		}
		if e.HasConversion || e.Kind == domain.KindConversion {
			sum.Conversions++
			sum.ConversionAmount += e.ConversionAmount
		}
	}
	return sum, nil
}

func (s *Service) ReportConversion(ctx context.Context, ownerUID int64, id string, amount float64, note, currency string) (*domain.OutcomeEvent, error) {
	e, err := s.GetOutcome(ctx, ownerUID, id)
	if err != nil {
		return nil, err
	}
	if currency == "" {
		currency = "TWD"
	}
	now := domain.NowNano()
	e.HasConversion = true
	e.ConversionAmount = amount
	e.ConversionNote = note
	e.ConversionCurrency = currency
	e.Kind = domain.KindConversion
	e.Confidence = domain.ConfidenceConfirmed
	e.Status = domain.StatusConfirmed
	e.UpdatedAt = now
	if err := s.Repo.SaveOutcome(ctx, e); err != nil {
		return nil, err
	}
	return e, nil
}

func (s *Service) UpdateConversion(ctx context.Context, ownerUID int64, id string, amount float64, note, currency string) (*domain.OutcomeEvent, error) {
	return s.ReportConversion(ctx, ownerUID, id, amount, note, currency)
}

func (s *Service) DeleteConversion(ctx context.Context, ownerUID int64, id string) error {
	e, err := s.GetOutcome(ctx, ownerUID, id)
	if err != nil {
		return err
	}
	e.HasConversion = false
	e.ConversionAmount = 0
	e.ConversionNote = ""
	e.ConversionCurrency = ""
	if e.ReplyCountDelta > 0 {
		e.Kind = domain.KindReply
		e.Status = domain.StatusConfirmed
	} else if e.FollowersDelta > 0 {
		e.Kind = domain.KindFollow
		e.Status = domain.StatusPossible
		e.Confidence = domain.ConfidencePossible
	} else {
		e.Kind = domain.KindReach
		e.Status = domain.StatusObserving
		e.Confidence = domain.ConfidenceConfirmed
	}
	e.UpdatedAt = domain.NowNano()
	return s.Repo.SaveOutcome(ctx, e)
}

// ApplyObserveSignals updates observing events. Missing signals are skipped (OC-08).
func (s *Service) ApplyObserveSignals(ctx context.Context, id string, replyDelta, likeDelta, followersDelta int) (*domain.OutcomeEvent, error) {
	e, err := s.Repo.GetOutcome(ctx, id)
	if err != nil {
		return nil, err
	}
	now := domain.NowNano()
	if e.Status != domain.StatusObserving && e.Status != domain.StatusPossible {
		if now > e.WindowEndsAt && e.Status == domain.StatusObserving {
			e.Status = domain.StatusExpired
			e.UpdatedAt = now
			_ = s.Repo.SaveOutcome(ctx, e)
		}
		return e, nil
	}
	if replyDelta > 0 {
		e.ReplyCountDelta += replyDelta
		e.Kind = domain.KindReply
		e.Confidence = domain.ConfidenceConfirmed
		e.Status = domain.StatusConfirmed
	}
	if likeDelta > 0 {
		e.LikeCountDelta += likeDelta
		if e.Kind == domain.KindReach {
			e.Kind = domain.KindInteraction
			e.Confidence = domain.ConfidencePossible
			e.Status = domain.StatusPossible
		}
	}
	if followersDelta > 0 {
		e.FollowersDelta += followersDelta
		if e.Kind != domain.KindReply && e.Kind != domain.KindConversion {
			e.Kind = domain.KindFollow
			e.Confidence = domain.ConfidencePossible
			e.Status = domain.StatusPossible
		}
	}
	if now > e.WindowEndsAt && e.Status == domain.StatusObserving {
		e.Status = domain.StatusExpired
	}
	e.UpdatedAt = now
	if err := s.Repo.SaveOutcome(ctx, e); err != nil {
		return nil, err
	}
	return e, nil
}

func (s *Service) ObserveTick(ctx context.Context, now int64) (int, error) {
	if now <= 0 {
		now = domain.NowNano()
	}
	list, err := s.Repo.ListObservingDue(ctx, now, 100)
	if err != nil {
		return 0, err
	}
	n := 0
	for _, e := range list {
		if now > e.WindowEndsAt {
			e.Status = domain.StatusExpired
			e.UpdatedAt = now
			_ = s.Repo.SaveOutcome(ctx, e)
			n++
		}
		// Signal fetch left degraded: no external Threads probe in default path.
	}
	return n, nil
}

// --- Checkups (no usage debit — caller must not meter) ---

func (s *Service) GenerateCheckup(ctx context.Context, ownerUID int64, timezone string, force bool) (*domain.WeeklyCheckup, error) {
	now := domain.NowNano()
	if force {
		since := now - int64(7*24*time.Hour)
		cnt, err := s.Repo.CountCheckupGenerations(ctx, ownerUID, since)
		if err != nil {
			return nil, err
		}
		if cnt >= 2 {
			return nil, domain.ErrRateLimited
		}
	}
	weekKey := weekKeyFor(timezone, time.Now().UTC())
	// Build report from outcome summary (no external AI required for MVP reliability).
	sum, err := s.Summary(ctx, ownerUID, 0, 0)
	if err != nil {
		return nil, err
	}
	findings := []domain.CheckupFinding{}
	if sum.Reach > 0 {
		findings = append(findings, domain.CheckupFinding{
			Claim:    fmt.Sprintf("近 7 日送出／標記完成 %d 則，可作為本週觸達基線", sum.Reach),
			Evidence: []string{fmt.Sprintf("outcome_reach=%d", sum.Reach)},
		})
	}
	if sum.Conversations > 0 {
		findings = append(findings, domain.CheckupFinding{
			Claim:    fmt.Sprintf("有 %d 則進入對話訊號，優先回覆這些串", sum.Conversations),
			Evidence: []string{fmt.Sprintf("outcome_conversations=%d", sum.Conversations)},
		})
	}
	if sum.Conversions > 0 {
		findings = append(findings, domain.CheckupFinding{
			Claim:    fmt.Sprintf("已回報 %d 筆成交，持續追蹤同類痛點", sum.Conversions),
			Evidence: []string{fmt.Sprintf("outcome_conversions=%d amount=%.0f", sum.Conversions, sum.ConversionAmount)},
		})
	}
	if len(findings) == 0 {
		findings = append(findings, domain.CheckupFinding{
			Claim:    "本週尚無足夠送出紀錄；建議先完成海巡外展或標記完成以累積訊號",
			Evidence: []string{"outcome_reach=0"},
		})
	}
	// keep only findings with evidence
	var okFindings []domain.CheckupFinding
	for _, f := range findings {
		if len(f.Evidence) > 0 && strings.TrimSpace(f.Claim) != "" {
			okFindings = append(okFindings, f)
		}
	}
	actions := []domain.CheckupAction{
		{Title: "處理海巡待回", Reason: "把待處理命中變成可歸因送出", Deeplink: "scout"},
		{Title: "寫一則主貼", Reason: "維持帳號節奏，累積可分析貼文", Deeplink: "studio_compose"},
		{Title: "回顧今日成果", Reason: "用成本＋成果判斷本週重點", Deeplink: "today"},
	}
	c := &domain.WeeklyCheckup{
		ID:        domain.NewID(),
		OwnerUID:  ownerUID,
		WeekKey:   weekKey,
		Status:    domain.CheckupReady,
		Summary:   fmt.Sprintf("本週觸達 %d、對話 %d、成交 %d。", sum.Reach, sum.Conversations, sum.Conversions),
		Findings:  okFindings,
		Actions:   actions,
		CreatedAt: now,
		UpdatedAt: now,
	}
	if err := s.Repo.SaveCheckup(ctx, c); err != nil {
		return nil, err
	}
	if s.Notifier != nil {
		_ = s.Notifier.Notify(ctx, ownerUID, "每週帳號健檢已完成", c.Summary, "system", "checkup", c.ID)
	}
	return c, nil
}

func weekKeyFor(tz string, now time.Time) string {
	loc := time.UTC
	if tz != "" {
		if l, err := time.LoadLocation(tz); err == nil {
			loc = l
		}
	}
	local := now.In(loc)
	// ISO week
	y, w := local.ISOWeek()
	return fmt.Sprintf("%d-W%02d", y, w)
}

func (s *Service) LatestCheckup(ctx context.Context, ownerUID int64) (*domain.WeeklyCheckup, error) {
	return s.Repo.LatestCheckup(ctx, ownerUID)
}

func (s *Service) GetCheckup(ctx context.Context, ownerUID int64, id string) (*domain.WeeklyCheckup, error) {
	c, err := s.Repo.GetCheckup(ctx, id)
	if err != nil {
		return nil, err
	}
	if c.OwnerUID != ownerUID {
		return nil, domain.ErrForbidden
	}
	return c, nil
}

func (s *Service) ListCheckups(ctx context.Context, ownerUID int64, page, pageSize int) ([]*domain.WeeklyCheckup, int64, error) {
	return s.Repo.ListCheckups(ctx, ownerUID, page, pageSize)
}

// --- Account health ---

func (s *Service) RecomputeHealth(ctx context.Context, ownerUID int64, accountID string, sig HealthSignals) (*domain.AccountHealth, error) {
	score := 100
	var factors []string
	if sig.Sends24h > 20 {
		score -= 25
		factors = append(factors, fmt.Sprintf("24h 發送 %d 次偏高", sig.Sends24h))
	} else if sig.Sends24h > 10 {
		score -= 10
		factors = append(factors, fmt.Sprintf("24h 發送 %d 次", sig.Sends24h))
	}
	if sig.IntervalViolations > 0 {
		d := sig.IntervalViolations * 8
		if d > 30 {
			d = 30
		}
		score -= d
		factors = append(factors, fmt.Sprintf("間隔違規 %d 次", sig.IntervalViolations))
	}
	if sig.FailRate7d >= 0.5 {
		score -= 25
		factors = append(factors, fmt.Sprintf("7 日失敗率 %.0f%%", sig.FailRate7d*100))
	} else if sig.FailRate7d >= 0.25 {
		score -= 12
		factors = append(factors, fmt.Sprintf("7 日失敗率 %.0f%%", sig.FailRate7d*100))
	}
	if sig.TokenBad {
		score -= 40
		factors = append(factors, "token 失效或錯誤")
	}
	if score < 0 {
		score = 0
	}
	level := domain.HealthNormal
	advice := "操作節奏正常，可持續。"
	if score < 40 {
		level = domain.HealthThrottle
		advice = "帳號風險偏高：已阻擋自動送出，請改用複製→標記完成，並降低密度。"
	} else if score < 70 {
		level = domain.HealthWarn
		advice = "建議加倍發送間隔，並優先處理失敗步驟。"
	}
	if len(factors) == 0 {
		factors = []string{"無異常訊號"}
	}
	h := &domain.AccountHealth{
		ThreadsAccountID: accountID,
		OwnerUID:         ownerUID,
		Score:            score,
		Level:            level,
		Factors:          factors,
		Advice:           advice,
		ComputedAt:       domain.NowNano(),
	}
	if err := s.Repo.SaveHealth(ctx, h); err != nil {
		return nil, err
	}
	return h, nil
}

func (s *Service) GetHealth(ctx context.Context, ownerUID int64, accountID string) (*domain.AccountHealth, error) {
	h, err := s.Repo.GetHealth(ctx, accountID)
	if err != nil {
		if err == domain.ErrNotFound {
			// default healthy until computed
			return &domain.AccountHealth{
				ThreadsAccountID: accountID,
				OwnerUID:         ownerUID,
				Score:            85,
				Level:            domain.HealthNormal,
				Factors:          []string{"尚未重算，預設正常"},
				Advice:           "尚無足夠操作數據。",
				ComputedAt:       domain.NowNano(),
			}, nil
		}
		return nil, err
	}
	if h.OwnerUID != ownerUID {
		return nil, domain.ErrForbidden
	}
	return h, nil
}

func (s *Service) ListHealth(ctx context.Context, ownerUID int64) ([]*domain.AccountHealth, error) {
	return s.Repo.ListHealth(ctx, ownerUID)
}

// EnsureAutoSendAllowed returns health_warning message or ErrThrottle.
func (s *Service) EnsureAutoSendAllowed(ctx context.Context, ownerUID int64, accountID string) (warning string, err error) {
	if accountID == "" {
		return "", nil
	}
	h, err := s.GetHealth(ctx, ownerUID, accountID)
	if err != nil {
		return "", err
	}
	switch h.Level {
	case domain.HealthThrottle:
		return "", fmt.Errorf("%w: score=%d %s", domain.ErrThrottle, h.Score, h.Advice)
	case domain.HealthWarn:
		return fmt.Sprintf("健康分 %d（警告）：%s", h.Score, h.Advice), nil
	default:
		return "", nil
	}
}

// --- Invite rewards ---

func (s *Service) OnFirstPaidPlan(ctx context.Context, inviteeUID, parentUID int64, planID string) (*domain.InviteReward, error) {
	planID = strings.ToLower(strings.TrimSpace(planID))
	if parentUID <= 0 || inviteeUID <= 0 {
		return &domain.InviteReward{Status: domain.RewardSkipped}, nil
	}
	if planID != "starter" && planID != "pro" {
		return &domain.InviteReward{Status: domain.RewardSkipped}, nil
	}
	has, err := s.Repo.HasInviteRewardForInvitee(ctx, inviteeUID)
	if err != nil {
		return nil, err
	}
	if has {
		return &domain.InviteReward{Status: domain.RewardSkipped, InviteeUID: inviteeUID}, nil
	}
	points := 100
	if planID == "pro" {
		points = 300
	}
	quota := 120
	if s.PlanQuota != nil {
		// cap based on inviter plan — unknown → free quota
		quota = s.PlanQuota("free")
	}
	// Prefer looking up inviter plan via PlanQuota with "inviter" if set externally;
	// default month cap = free 50% unless Bonus path sets better.
	monthCap := quota / 2
	if monthCap < 0 {
		monthCap = 0
	}
	// Try inviter starter/pro quotas: use max of free half as floor; service callers
	// should set PlanQuota to resolve inviter plan.
	if s.PlanQuota != nil {
		// convention: PlanQuota("__inviter__") not used; pass inviter plan via
		// PlanQuota already closed over. Month cap = PlanQuota("current")/2.
		// Here PlanQuota receives plan id; for month cap we call with "starter" max?
		// Spec: 邀請人當月方案額度 50%. Caller should set:
		//   s.PlanQuota = func(id string) int { if id=="@inviter") return inviterQuota }
		if q := s.PlanQuota("@inviter"); q > 0 {
			monthCap = q / 2
		}
	}
	monthStart := time.Date(time.Now().UTC().Year(), time.Now().UTC().Month(), 1, 0, 0, 0, 0, time.UTC).UnixNano()
	used, err := s.Repo.SumInviteRewardPointsMonth(ctx, parentUID, monthStart)
	if err != nil {
		return nil, err
	}
	r := &domain.InviteReward{
		ID:         domain.NewID(),
		InviterUID: parentUID,
		InviteeUID: inviteeUID,
		PlanID:     planID,
		Points:     points,
		CreatedAt:  domain.NowNano(),
	}
	if used+points > monthCap && monthCap >= 0 {
		r.Status = domain.RewardCapped
		r.Points = 0
		_ = s.Repo.SaveInviteReward(ctx, r)
		return r, nil
	}
	r.Status = domain.RewardCredited
	if err := s.Repo.SaveInviteReward(ctx, r); err != nil {
		return nil, err
	}
	if s.Bonus != nil && points > 0 {
		_ = s.Bonus.CreditInviteBonus(ctx, parentUID, points, r.ID)
	}
	return r, nil
}

func (s *Service) InviteRewardsSummary(ctx context.Context, inviterUID int64, inviterPlanID string) (total, month, cap int, recent []*domain.InviteReward, err error) {
	quota := defaultPlanQuota(inviterPlanID)
	if s.PlanQuota != nil {
		if q := s.PlanQuota(inviterPlanID); q > 0 {
			quota = q
		}
	}
	cap = quota / 2
	monthStart := time.Date(time.Now().UTC().Year(), time.Now().UTC().Month(), 1, 0, 0, 0, 0, time.UTC).UnixNano()
	total, err = s.Repo.SumInviteRewardPointsTotal(ctx, inviterUID)
	if err != nil {
		return
	}
	month, err = s.Repo.SumInviteRewardPointsMonth(ctx, inviterUID, monthStart)
	if err != nil {
		return
	}
	recent, err = s.Repo.ListInviteRewards(ctx, inviterUID, 20)
	return
}

// --- Workspaces ---

func (s *Service) EnsureDefaultWorkspace(ctx context.Context, ownerUID int64) (*domain.Workspace, error) {
	list, err := s.Repo.ListWorkspaces(ctx, ownerUID, true)
	if err != nil {
		return nil, err
	}
	for _, w := range list {
		if w.IsDefault && !w.Archived {
			return w, nil
		}
	}
	for _, w := range list {
		if !w.Archived {
			return w, nil
		}
	}
	now := domain.NowNano()
	w := &domain.Workspace{
		ID:        domain.NewID(),
		OwnerUID:  ownerUID,
		Name:      "預設工作區",
		IsDefault: true,
		CreatedAt: now,
		UpdatedAt: now,
	}
	if err := s.Repo.SaveWorkspace(ctx, w); err != nil {
		return nil, err
	}
	_ = s.Repo.SaveMemberWSState(ctx, &domain.MemberWorkspaceState{
		OwnerUID: ownerUID, CurrentWorkspaceID: w.ID, UpdatedAt: now,
	})
	return w, nil
}

func (s *Service) ListWorkspaces(ctx context.Context, ownerUID int64) ([]*domain.Workspace, string, error) {
	_, _ = s.EnsureDefaultWorkspace(ctx, ownerUID)
	list, err := s.Repo.ListWorkspaces(ctx, ownerUID, false)
	if err != nil {
		return nil, "", err
	}
	cur := ""
	st, err := s.Repo.GetMemberWSState(ctx, ownerUID)
	if err == nil && st != nil {
		cur = st.CurrentWorkspaceID
	}
	if cur == "" && len(list) > 0 {
		cur = list[0].ID
	}
	return list, cur, nil
}

func (s *Service) CreateWorkspace(ctx context.Context, ownerUID int64, name string) (*domain.Workspace, error) {
	name = strings.TrimSpace(name)
	if name == "" {
		return nil, fmt.Errorf("%w: name required", domain.ErrValidation)
	}
	_, _ = s.EnsureDefaultWorkspace(ctx, ownerUID)
	now := domain.NowNano()
	w := &domain.Workspace{
		ID:        domain.NewID(),
		OwnerUID:  ownerUID,
		Name:      name,
		CreatedAt: now,
		UpdatedAt: now,
	}
	if err := s.Repo.SaveWorkspace(ctx, w); err != nil {
		return nil, err
	}
	return w, nil
}

func (s *Service) UpdateWorkspace(ctx context.Context, ownerUID int64, id, name string, review *bool) (*domain.Workspace, error) {
	w, err := s.Repo.GetWorkspace(ctx, id)
	if err != nil {
		return nil, err
	}
	if w.OwnerUID != ownerUID {
		return nil, domain.ErrForbidden
	}
	if name = strings.TrimSpace(name); name != "" {
		w.Name = name
	}
	if review != nil {
		w.ReviewRequired = *review
	}
	w.UpdatedAt = domain.NowNano()
	if err := s.Repo.SaveWorkspace(ctx, w); err != nil {
		return nil, err
	}
	return w, nil
}

func (s *Service) ArchiveWorkspace(ctx context.Context, ownerUID int64, id string) error {
	w, err := s.Repo.GetWorkspace(ctx, id)
	if err != nil {
		return err
	}
	if w.OwnerUID != ownerUID {
		return domain.ErrForbidden
	}
	n, err := s.Repo.CountActiveWorkspaces(ctx, ownerUID)
	if err != nil {
		return err
	}
	if n <= 1 {
		return fmt.Errorf("%w: must keep at least one workspace", domain.ErrValidation)
	}
	w.Archived = true
	w.UpdatedAt = domain.NowNano()
	return s.Repo.SaveWorkspace(ctx, w)
}

func (s *Service) SwitchWorkspace(ctx context.Context, ownerUID int64, id string) error {
	w, err := s.Repo.GetWorkspace(ctx, id)
	if err != nil {
		return err
	}
	if w.OwnerUID != ownerUID || w.Archived {
		return domain.ErrForbidden
	}
	return s.Repo.SaveMemberWSState(ctx, &domain.MemberWorkspaceState{
		OwnerUID: ownerUID, CurrentWorkspaceID: id, UpdatedAt: domain.NowNano(),
	})
}

func (s *Service) CurrentWorkspaceID(ctx context.Context, ownerUID int64) (string, error) {
	list, cur, err := s.ListWorkspaces(ctx, ownerUID)
	if err != nil {
		return "", err
	}
	if cur != "" {
		return cur, nil
	}
	if len(list) > 0 {
		return list[0].ID, nil
	}
	return "", domain.ErrNotFound
}

// --- Draft review ---

func (s *Service) SubmitReview(ctx context.Context, ownerUID int64, refType, refID, workspaceID string) (*domain.DraftReview, error) {
	if refType == "" || refID == "" {
		return nil, fmt.Errorf("%w: ref required", domain.ErrValidation)
	}
	if workspaceID == "" {
		var err error
		workspaceID, err = s.CurrentWorkspaceID(ctx, ownerUID)
		if err != nil {
			return nil, err
		}
	}
	now := domain.NowNano()
	r := &domain.DraftReview{
		ID:          domain.NewID(),
		OwnerUID:    ownerUID,
		WorkspaceID: workspaceID,
		RefType:     refType,
		RefID:       refID,
		Status:      domain.ReviewPending,
		CreatedAt:   now,
		UpdatedAt:   now,
	}
	if err := s.Repo.SaveReview(ctx, r); err != nil {
		return nil, err
	}
	return r, nil
}

func (s *Service) DecideReview(ctx context.Context, actorUID int64, id, status, reason string) (*domain.DraftReview, error) {
	r, err := s.Repo.GetReview(ctx, id)
	if err != nil {
		return nil, err
	}
	// owner of draft OR workspace collaborator may decide
	if r.OwnerUID != actorUID && !s.CanReviewInWorkspace(ctx, actorUID, r.WorkspaceID) {
		return nil, domain.ErrForbidden
	}
	r.Status = status
	r.Reason = reason
	r.UpdatedAt = domain.NowNano()
	if err := s.Repo.SaveReview(ctx, r); err != nil {
		return nil, err
	}
	return r, nil
}

func (s *Service) ListReviews(ctx context.Context, ownerUID int64, status string, page, pageSize int) ([]*domain.DraftReview, int64, error) {
	return s.Repo.ListReviews(ctx, ownerUID, status, page, pageSize)
}

// EnsureReviewAllowsAutoSend checks workspace review gate.
func (s *Service) EnsureReviewAllowsAutoSend(ctx context.Context, ownerUID int64, workspaceID, refType, refID string) error {
	if workspaceID == "" {
		var err error
		workspaceID, err = s.CurrentWorkspaceID(ctx, ownerUID)
		if err != nil {
			return nil // no workspace → no gate
		}
	}
	w, err := s.Repo.GetWorkspace(ctx, workspaceID)
	if err != nil {
		if err == domain.ErrNotFound {
			return nil
		}
		return err
	}
	if !w.ReviewRequired {
		return nil
	}
	r, err := s.Repo.FindReviewByRef(ctx, ownerUID, refType, refID)
	if err != nil {
		return domain.ErrReviewPending
	}
	if r.Status != domain.ReviewApproved {
		return domain.ErrReviewPending
	}
	return nil
}

// ExportReportMarkdown returns a simple text report (PDF engine optional; content is the contract).
func (s *Service) ExportReportMarkdown(ctx context.Context, ownerUID int64, workspaceID, yearMonth string) (filename, body string, err error) {
	if yearMonth == "" {
		yearMonth = time.Now().UTC().Format("2006-01")
	}
	w, err := s.Repo.GetWorkspace(ctx, workspaceID)
	if err != nil {
		return "", "", err
	}
	if w.OwnerUID != ownerUID {
		ok, _, _ := s.Repo.IsWorkspaceMember(ctx, workspaceID, ownerUID)
		if !ok {
			return "", "", domain.ErrForbidden
		}
	}
	sum, err := s.Summary(ctx, ownerUID, 0, 0)
	if err != nil {
		return "", "", err
	}
	title := w.Name
	if w.BrandName != "" {
		title = w.BrandName
	}
	filename = fmt.Sprintf("report-%s-%s.md", sanitize(title), yearMonth)
	body = fmt.Sprintf("# 月報 %s · %s\n\n- 觸達: %d\n- 對話: %d\n- 成交: %d (%.0f)\n- 追蹤(可能/確定): %d / %d\n",
		title, yearMonth, sum.Reach, sum.Conversations, sum.Conversions, sum.ConversionAmount, sum.FollowsPossible, sum.FollowsConfirmed)
	if w.FooterText != "" {
		body += "\n---\n" + w.FooterText + "\n"
	}
	if !w.HidePoweredBy {
		body += "\n_Powered by 巡樓_\n"
	}
	return filename, body, nil
}

// ExportReport returns md or pdf data URL.
func (s *Service) ExportReport(ctx context.Context, ownerUID int64, workspaceID, yearMonth, format string) (filename, contentType, dataURL string, err error) {
	fn, body, err := s.ExportReportMarkdown(ctx, ownerUID, workspaceID, yearMonth)
	if err != nil {
		return "", "", "", err
	}
	format = strings.ToLower(strings.TrimSpace(format))
	if format == "pdf" {
		title := strings.TrimSuffix(fn, ".md")
		pdf := ExportReportPDF(title, body)
		b64 := encodeB64(pdf)
		return strings.TrimSuffix(fn, ".md") + ".pdf", "application/pdf", "data:application/pdf;base64," + b64, nil
	}
	b64 := encodeB64([]byte(body))
	return fn, "text/markdown", "data:text/markdown;base64," + b64, nil
}

func encodeB64(b []byte) string {
	return base64.StdEncoding.EncodeToString(b)
}

func sanitize(s string) string {
	s = strings.TrimSpace(s)
	s = strings.ReplaceAll(s, " ", "-")
	if s == "" {
		return "workspace"
	}
	return s
}