package caps

import (
	"context"

	abiv1 "git.dev.alexdunmow.com/block/pluginsdk/abi/v1"
	"git.dev.alexdunmow.com/block/pluginsdk/subscriptions"
	"github.com/google/uuid"
)

// subscriptionsStub implements subscriptions.Subscriptions over
// subscriptions.* capability calls.
type subscriptionsStub struct{ base }

var _ subscriptions.Subscriptions = (*subscriptionsStub)(nil)

func (s *subscriptionsStub) GetUserTierLevel(ctx context.Context, userID uuid.UUID) (*subscriptions.TierLevel, error) {
	resp := &abiv1.SubscriptionsGetUserTierLevelResponse{}
	req := &abiv1.SubscriptionsGetUserTierLevelRequest{UserId: userID.String()}
	if err := s.invoke(ctx, "get_user_tier_level", req, resp); err != nil {
		return nil, err
	}
	tl := resp.GetTierLevel()
	if tl == nil {
		return nil, nil
	}
	return &subscriptions.TierLevel{Level: int(tl.GetLevel()), Features: tl.GetFeatures()}, nil
}

func (s *subscriptionsStub) GetTierBySlug(ctx context.Context, slug string) (*subscriptions.Tier, error) {
	resp := &abiv1.SubscriptionsGetTierBySlugResponse{}
	req := &abiv1.SubscriptionsGetTierBySlugRequest{Slug: slug}
	if err := s.invoke(ctx, "get_tier_by_slug", req, resp); err != nil {
		return nil, err
	}
	t := resp.GetTier()
	if t == nil {
		return nil, nil
	}
	tier := tierFromProto(t)
	return &tier, nil
}

func (s *subscriptionsStub) ListTiers(ctx context.Context) ([]subscriptions.Tier, error) {
	resp := &abiv1.SubscriptionsListTiersResponse{}
	if err := s.invoke(ctx, "list_tiers", &abiv1.SubscriptionsListTiersRequest{}, resp); err != nil {
		return nil, err
	}
	tiers := make([]subscriptions.Tier, 0, len(resp.GetTiers()))
	for _, t := range resp.GetTiers() {
		tiers = append(tiers, tierFromProto(t))
	}
	return tiers, nil
}

func (s *subscriptionsStub) ListActivePlans(ctx context.Context, tierID uuid.UUID) ([]subscriptions.Plan, error) {
	resp := &abiv1.SubscriptionsListActivePlansResponse{}
	req := &abiv1.SubscriptionsListActivePlansRequest{TierId: tierID.String()}
	if err := s.invoke(ctx, "list_active_plans", req, resp); err != nil {
		return nil, err
	}
	plans := make([]subscriptions.Plan, 0, len(resp.GetPlans()))
	for _, p := range resp.GetPlans() {
		plan := subscriptions.Plan{
			ID:              parseUUID(p.GetId()),
			TierID:          parseUUID(p.GetTierId()),
			BillingInterval: p.GetBillingInterval(),
			Amount:          p.GetAmount(),
			Currency:        p.GetCurrency(),
			IsActive:        p.GetIsActive(),
		}
		if ts := p.GetCreatedAt(); ts != nil {
			plan.CreatedAt = ts.AsTime()
		}
		plans = append(plans, plan)
	}
	return plans, nil
}

func tierFromProto(t *abiv1.Tier) subscriptions.Tier {
	return subscriptions.Tier{
		ID:          parseUUID(t.GetId()),
		Name:        t.GetName(),
		Slug:        t.GetSlug(),
		Level:       int(t.GetLevel()),
		Description: t.GetDescription(),
		Features:    t.GetFeatures(),
		IsDefault:   t.GetIsDefault(),
		Position:    int(t.GetPosition()),
	}
}