package app

import (
	"context"
	"fmt"
	"io"

	"gitea.maximumdirect.net/eric/distributor/internal/bundle"
	"gitea.maximumdirect.net/eric/distributor/internal/storage"
)

type ValidateOptions struct {
	Path         string
	Stdout       io.Writer
	OutputFormat OutputFormat
}

func Validate(ctx context.Context, options ValidateOptions) error {
	if err := ValidateOutputFormat(options.OutputFormat); err != nil {
		return err
	}
	if options.Path == "" {
		return fmt.Errorf("validate command requires a path")
	}
	backend, err := newBackendFactory().openLocalPath(ctx, options.Path)
	if err != nil {
		return err
	}
	bundles, err := bundle.Discover(ctx, backend, "")
	if err != nil {
		return err
	}
	if IsJSONOutput(options.OutputFormat) {
		return WriteJSONEnvelope(options.Stdout, "validate", true, nil, validateResultFromBundles(bundles), nil)
	}
	if options.Stdout != nil {
		_, err = fmt.Fprintf(options.Stdout, "Validated %d bundle(s)\n", len(bundles))
	}
	return err
}

type validateResult struct {
	BundleCount int                    `json:"bundle_count"`
	Bundles     []validateBundleResult `json:"bundles"`
}

type validateBundleResult struct {
	Path string `json:"path"`
	ID   string `json:"id"`
}

func validateResultFromBundles(bundles []bundle.Bundle) validateResult {
	result := validateResult{
		BundleCount: len(bundles),
		Bundles:     make([]validateBundleResult, 0, len(bundles)),
	}
	for _, sourceBundle := range bundles {
		result.Bundles = append(result.Bundles, validateBundleResult{
			Path: storage.DisplayPath(sourceBundle.RootRelativePath),
			ID:   sourceBundle.Manifest.ID,
		})
	}
	return result
}