package graphql

import (
	"context"
	"fmt"
	"github.com/gshopify/service-wrapper/fun"
	"github.com/gshopify/service-wrapper/model"
	"github.com/gshopify/service-wrapper/server/middleware"
	"github.com/microcosm-cc/bluemonday"
	"gshopper.com/gshopify/products/graphql/generated"
	"gshopper.com/gshopify/products/graphql/helper"
	"strings"
)

func (r *queryResolver) Product(ctx context.Context, handle *string, id *string) (*generated.Product, error) {
	var (
		inContext *middleware.GShopifyContext
		product   *generated.Product
		err       error
	)

	if inContext, err = middleware.InContext(ctx); err != nil {
		return nil, err
	}

	if id == nil && handle == nil {
		return nil, fmt.Errorf("at least one argument must be specified")
	}

	if id != nil {
		if s, err := model.ParseId(model.GidProduct, *id); err != nil {
			return nil, err
		} else {
			*id = s
		}
	}

	if product, err = r.db.Product(inContext.Language, handle, id); err != nil {
		return nil, err
	}

	return product, nil
}

func (r *productResolver) Description(_ context.Context, product *generated.Product, truncateAt *int) (string, error) {
	return fun.TruncateAt(
		bluemonday.StrictPolicy().Sanitize(string(product.DescriptionHTML)),
		truncateAt)
}

// Products retrieves Product list by collection
// TODO: implement filters
// TODO: implement sort
func (r *collectionResolver) Products(ctx context.Context, collection *generated.Collection,
	after *string, before *string, filters []*generated.ProductFilter, first *int, last *int, reverse *bool, sort *generated.ProductCollectionSortKeys) (*generated.ProductConnection, error) {
	var (
		inContext *middleware.GShopifyContext
		products  []*generated.Product
		err       error
	)

	if inContext, err = middleware.InContext(ctx); err != nil {
		return nil, err
	}

	rawId, err := model.ParseId(model.GidCollection, collection.ID)
	if err != nil {
		return nil, err
	}

	if products, err = r.db.CollectionProducts(inContext.Language, rawId); err != nil {
		return nil, err
	}

	return helper.NewProductConnection(products, after, before, first, last, reverse, sort)
}

func (r *productResolver) Options(ctx context.Context, product *generated.Product, first *int) ([]*generated.ProductOption, error) {
	var (
		inContext *middleware.GShopifyContext
		options   []*generated.ProductOption
		err       error
	)

	if inContext, err = middleware.InContext(ctx); err != nil {
		return nil, err
	}

	rawId, err := model.ParseId(model.GidProduct, product.ID)
	if err != nil {
		return nil, err
	}

	if options, err = r.db.ProductOptions(inContext.Language, rawId); err != nil {
		return nil, err
	}

	return fun.First(options, first), nil
}

func (r *productResolver) Variants(ctx context.Context, product *generated.Product,
	first *int, after *string, last *int, before *string, reverse *bool, sort *generated.ProductVariantSortKeys) (*generated.ProductVariantConnection, error) {
	var (
		inContext *middleware.GShopifyContext
		variants  []*generated.ProductVariant
		err       error
	)

	inContext, err = middleware.InContext(ctx)
	if err != nil {
		return nil, err
	}

	rawId, err := model.ParseId(model.GidProduct, product.ID)
	if err != nil {
		return nil, err
	}

	variants, err = r.db.ProductVariants(inContext, rawId)
	if err != nil {
		return nil, err
	}

	return helper.NewProductVariantConnection(variants, after, before, first, last, reverse, sort)
}

func (r *productVariantResolver) Product(ctx context.Context, variant *generated.ProductVariant) (*generated.Product, error) {
	var (
		inContext *middleware.GShopifyContext
		err       error
	)

	if inContext, err = middleware.InContext(ctx); err != nil {
		return nil, err
	}

	if variant.Product == nil {
		return nil, fmt.Errorf("unknown product.ID for variant: `%s`", variant.ID)
	}

	rawId, err := model.ParseId(model.GidProduct, variant.Product.ID)
	if err != nil {
		return nil, err
	}

	return r.db.Product(inContext.Language, nil, &rawId)
}

// StoreAvailability TODO: implement
func (r *productVariantResolver) StoreAvailability(ctx context.Context, variant *generated.ProductVariant,
	first *int, after *string, last *int, before *string, reverse *bool) (*generated.StoreAvailabilityConnection, error) {
	panic("not implemented")
}

func (r *productVariantResolver) SelectedOptions(ctx context.Context, variant *generated.ProductVariant) ([]*generated.SelectedOption, error) {
	var (
		inContext *middleware.GShopifyContext
		err       error
	)

	if inContext, err = middleware.InContext(ctx); err != nil {
		return nil, err
	}

	rawId, err := model.ParseId(model.GidVariant, variant.ID)
	if err != nil {
		return nil, fmt.Errorf("unknown ID for variant: `%s`", variant.ID)
	}

	return r.db.ProductVariantOptions(inContext.Language, rawId)
}

func (r *productVariantResolver) Title(ctx context.Context, variant *generated.ProductVariant) (string, error) {
	opts, err := r.SelectedOptions(ctx, variant)
	if err != nil {
		return "", err
	}

	s := make([]string, len(opts))
	for i := range opts {
		s[i] = opts[i].Value
	}

	return strings.Join(s, " / "), nil
}